פורום תכנות (עמוד 23)

לא ניתן להעלים שורה מאמצע מערך או להוסיף.

צריך ליצור מערך חדש עם/ ללא השורה.

(1) מחק את השורה שאתה רוצה.

(2) הזז אותה לסוף כך:

            א. הזז את כל הpointers של השורות שורה אחת אחורה.

            ב. בסוף ישאר לך מקום אחד פנוי/nullptr. 

 

דוגמא:

 

    const int sizex = 5;
    char** myarr = new char*[sizex];

    printf("My array pointers:\n");
    for (int i = 0; i < sizex; ++i)
    {
        printf("myarr[%d] = 0x%p\n", i, &myarr[i]);
    }

    printf("\nMy array pointers data:\n");
    for (int i = 0; i < sizex; ++i)
    {
        printf("myarr[%d] = 0x%p\n", i, myarr[i]);
    }

    printf("\nAlloc lines and put data:");
    const int sizey = 3;
    for (int i = 0; i < sizex; ++i)
    {
        myarr[i] = new char[sizey];
        for (int j = 0; j < sizey; ++j)
        {
            myarr[i][j] = i;
        }
    }

    printf("\nMy array pointers data:\n");
    for (int i = 0; i < sizex; ++i)
    {
        printf("myarr[%d] = 0x%p\n", i, myarr[i]);
    }

    printf("\nDelete line 3:\n");
    const int deleteIndex = 3;
    delete[] myarr[deleteIndex];
    myarr[deleteIndex] = nullptr;
    for (int i = 0; i < sizex; ++i)
    {
        printf("myarr[%d] = 0x%p\n", i, myarr[i]);
    }

    printf("\nMove the last lines back:\n");
    for (int i = deleteIndex; i < sizex - 1; ++i)
    {
        myarr[i] = myarr[i+1];
    }
    myarr[sizex - 1] = nullptr;
    for (int i = 0; i < sizex; ++i)
    {
        printf("myarr[%d] = 0x%p\n", i, myarr[i]);
    }
    
    for (int i = 0; i < sizex - 1; ++i)
    {
        for (int j = 0; j < sizey; ++j)
        {
            printf("%d ", (int)myarr[i][j]);
        }
        printf("\n");
    }

    delete[] myarr;
    myarr = nullptr;

אבל אם זה בתחילת המערך זה יוצא פחות יעיל מאשר ליצור מערך חדש.

אשמח להסבר.

 

לענ"ד, זה לא משנה בתחילה/אמצע/סוף.

 

בשביל לעשות את מה שאתה אמרת, צריך גם ליצור מערך חדש וגם להעתיק אותו.
בפתרון שלי בסה"כ מעתיקים את המצביעים. שזה בסך הכל 

לעומת

ובעיקר שהקצאת זיכרון היא פעולה יקרה.

delete[] myarr[deleteIndex];

for (int i = deleteIndex; i < sizex - 1; ++i)
{
    myarr[i] = myarr[i+1];
}
myarr[sizex - 1] = nullptr;

טעות שלי

אם הגדרת/ה אותו כמערך שמצביע על מערכים

זה משחק של מצביעים.

 

אם הגדרתה אותו כמערך דו ממדי,

אז בזיכרון הוא מוכנס כבלוק אחד ארוך

מחולק לפי הגודל של המערך הפנימי.

לכן אפשר להריץ מצביע מהשורה הבאה ולהעתיק כל תא בזיכרון

שורה למעלה, וככה פשוט לדרוס את כל המידע שיש

בשורה שרוצים למחוק.

ולא צריך לייצר מערך חדש ולהעתיק הכל לתוכו.

מקווה שזה מובן.

זה טריק ידוע מ-c.

בכל מקרה צריך לתקן את ההקצעות עם realloc.

 

הבעייה הגדולה מתחילה כשיש לך עוד מקומות שמצביעים לתוך המערך

שאז אי אפשר להזיז את שאר השורות במערך.

ואז הייתי שומר עוד טבלה שאומרת איזה שורות פעילות ואיזה לא.

במקום להתעסק במחיקות.

 

רק הערה קטנה:

realloc אפשר לעשות על זיכרון שהוקצאה בעזרת בmalloc/calloc ולא בעזרת new. [וכדאי להיות מודעים להבדלים... 

 

 

 

 

אני מעלה את כל שורה שורה למעלה ואז בשורה האחרונה מגדירה כ null?

ןהקצאת הזיכרון נעשתה ע"י new זה משנה?

ואיך מוסיפים שורה??

;int ** matrix

;[matrix = new int *[size

(++for (int i = 0; i < size; i
;[ matrix[i]  =new int[3

זה בעצם מערך בגודל שורות  משתנה אבל מספר העמודות תמיד ישאר שלוש...

השאלה מפה איך אפשר להוסיף עוד שורה..

לך כל הפעולות שאתה צריך.

במקרה שלך בגלל שאתה לא שולט בהקצעה
כדי להוסיף שורה אתה צריך להגדיר מערך חדש
ואז להעביר/להעתיק לשם את כל המידע.

או יותר פשוט להגדיר את המערך באמת דינמית
ולא בכיאלו, בעזרת malloc, ולהשתמש ב realloc.
יש לך גם smartpointer שמשחרר את הזיכרון לבד. תחפש בגוגל כדי לראות איזה
סוג הכי מתאים לך.

אבל הכי מומלץ כמו שכתבתי בכותרת.

בעיקרון אתה יכול לקחת את השורה האחרונה,
ולשים אותה במקום השורה שאתה רוצה למחוק.
ולשים באחרון null.
אם לא חשוב לך הסדר. אם כן, אז להזיז
את המצביעים אחד למעלה מאחרי השורה שאתה מוחק, ובאחרון null.

שים לב לשחרר זיכרון, במחיקה.

ואני אומר שוב עדיף שתשתמש בווקטור
או מערך דינמי, הם כבר מימשו את
הפעולות האלה שם.

אז חשבתי שהוא הקצע אותו בעזרת malloc.
לא חשבתי שהוא הקצע אובייקט.

בהקשר של ההקצאות:

 

חשוב לזכור שפעולות הקצאה/מחיקה, הן פעולות יקרות.
(בעיקר כשהן רבות, והביצועים חשובים...)

וכאשר אפשר להקצאות הכל מראש, ולמחוק בסוף הכל. עדיף.

 

ובדוגמא שלך:

אם חשובים לך הביצועים, אתה יכול להקצאות את מערך המצביעים בגודל המקסימלי שתצטרך.

[בהנחה שיש כזה...]

וכאשר אתה רוצה למחוק שורה, תעביר אותה לסוף.

[וכן תוכל למחזר את הזיכרון שלה לשימוש בdata שונה (בתנאי שהיא בגודל שאתה צריך...)]
ובסופו של דבר תמחק את כל מה שנשאר לך.
(אא"כ כמות הdata הזו של השורות המחוקות תתפוס לך יותר מדי זיכרון ותשחרר בכל זאת)

וכן כמו שL אמר אולי כדאי לך להשתמש במבנה נתונים שכבר הוגדר כמו בvector.
 

בהצלחה

כנראה עדיף שלא יקצא, שיהיה מערך רגיל.

כי מה שאתה אומר קבוע לגמרי, ויש מקרים שרוצים לקבוע את זה מראש בהתאם לקובץ config, או בהתאם למשהו אחר שידוע רק בזמן ריצה.

הם ציפו שהקלטים יועברו לשרת, או לדף HTML אחר?

כי לעבור לדף html אחר באותה תיקיה עם קלטים זה אמור להיות מאוד פשוט -

 

a.html

<html>
  <head>
  </head>
  <body>
    <form action="b.html">
    <input name="text">
    <input type="submit" value="submit">
</form>
  </body>
</html>

b.html

<html>
<body onload="document.querySelector('#text').innerText = location.search.split('=')[1]">
    <h1 id="text"></h1>
</body>
</html>

ולא שהם ישבו להכניס קלטים ויצא מה שהם ביקשו.

תודה!

שהמשחק עצמו יהיה אובייקט שיכיל את כל מה שצריך (כולל הגריד), וכשמאתחלים את המשחק אפשר פשוט ליצור אובייקט חדש.

יצרתי אותו לא בעזרת הקוד (ואולי פה הבעיה שלי...), אלא בעזרת הסרגל הויזואלי, ורק את ה"איוונטים" הגדרתי בקוד.

אז יש לי שם לכל דבר, אבל להתחיל לאתחל דבר דבר בקוד זה נראה לי מסורבל (ויש הרבה אלמנטים)

זה מצויין ליצור בעזרת הסרגל הויזואלי כי זה חוסך הרבה קוד. אבל אחרי שיצרת בעזרת הסרגל הויזואלי, תשחקי קצת עם הקוד ש"מאחורי הקלעים", ותגדירי שלחיצה על "משחק חדש" תיצור אובייקט חדש של המשחק. אם עושים את זה נכון, אפשר להגדיר בקוד את כל האלמנטים כך שיהיו תלויים באובייקט של המשחק (וזה עניין של כמה שורות קוד סה"כ) ואז מספיק ליצור אובייקט משחק חדש וזהו.

להגדיר את כל הגרפיקה כמשהו אחד שאפשר פשוט לאתחל אותו.

לא מוצאת בקוד איפה הם מוגדרים, ואני לא כ"כ יודעת איך להגדיר אותם בקוד בלי הסרגל הויזואלי...

בינתיים לחיצה על משחק חדש מייצרת משחק חדש תקין לגמרי מבחינת התיפעול - מלבד הגרפיקה שהיא שאריות מהמשחק הקודם...

יוצרים הכל בסרגל הויזואלי, ואחרי שמסיימים נכנסים לקוד שלו ומוסיפים כמה דברים. כשאהיה בבית אשתדל לבדוק את זה ולכתוב לך בדיוק איך עושים את זה...

יש פונקצייה אחת עם שם קבוע שבתוכה יש את האתחול של כל הviews.
אז אם יהיה לך את השם שלה תוכלי לקרוא לה ולאתחל מחדש הכל.

נראה לי. מזמן לא נגעתי בממשק משתמש ב#C

אבל לא הצלחתי לחקור ולגלות מהי, לכן אני שואלת פה

אין לי מושג על מה הוא מדבר... הפתרון שאני הצעתי שונה לגמרי.

ואגב... למה אנשים כותבים כאן (ובפורום מחשבים) מאנונימי? מה זה משנה שידעו מי זה?
@אנונימי

מישהו יודע איך נקראת הפקודה שגורמת לכל הviews להיות מאותחלים?

 

או לחלופין - איך בקוד אני מגדירה את הgrid כדי לקרוא לו מחדש בכל תחילת משחק?

יש לנו, נגיד, App.xaml ומאחוריו יש App.xaml.cs שהוא הקובץ שבו את מכניסה את הלוגיקה שלך. ב-App.xaml.cs מוגדר -

    sealed partial class App : Application
    {
        public App()
        {
            this.InitializeComponent();
            this.Suspending += OnSuspending;
        }

שימי לב - זהו partial class, זאת אומרת שרק חלק מהקוד נמצא כאן, שאר הקוד נמצא בקובץ אחר.

הקובץ הזה לא נמצא ב-solution explorer, אבל F12 על InitializeComponent או Shift+F12 על App יביאו אותנו לקובץ בשם App.g.i.cs.

קריאה ל-InitializeComponent היא בעייתית מכיוון שחלק הקוד ששם צריך לרוץ רק פעם אחת.

את יכולה אבל להבין מה קורה שם ולהעתיק את קטעי הקוד הרלונטיים.

את יכולה לפתוח תהליך אם שפותח תהליך בן שהוא המשחק,

שכשאשר הבן לוחץ על new game יגמר המשחק הקודם

ויפתח משחק חדש.

את המידע מסוף המשחק הראשון אפשר לשמור בקובץ טקסט אם רוצים.

 

עוד אפשרות היא פשוט להריץ את התוכנה (זה במקרה שכבר יש לך קובץ ריצה).

(פה צריך לבדוק אם אפשר לסגור את התהליך הקורא ליפני שייגמר תהליך הבן או לא

וקצת ניסוים).

 

גילוי נאות אין לי מושג איך לתכנת ב-#c לכן הבאתי עקרון ולא קוד ממש.

זה API מיושן פיירפוקס כבר לא תומכים בו אבל כרום עדיין כן.

בכרום זה מאוד נחמד כי יש לך גם קונסול שאפשר לעבוד מולו.

יוצרים DB בצורה הבאה -

var db = openDatabase('mydb', '1.0', 'Test DB', 2 * 1024 * 1024);

לאחר מכן התחביר הוא של sql סטנדרטי, ניתן באמצעות קוד js-

db.transaction(function (tx) {
  tx.executeSql('CREATE TABLE IF NOT EXISTS LOGS (id unique, log)');
  tx.executeSql('INSERT INTO LOGS (id, log) VALUES (1, "foobar")');
  tx.executeSql('INSERT INTO LOGS (id, log) VALUES (2, "logmsg")');
  tx.executeSql('SELECT * FROM LOGS', [], function (tx, results) {
   var len = results.rows.length;
   for (var i = 0; i < len; i++){
     console.log(results.rows.item(i).log);
   }
 }, null); 
)};

ניתן גם לעבוד בקונסול של כרום -

devtools => applications => websql => mydb

שם יש קונסול שניתן לכתוב בו בתחביר סטנדרטי של sqllite.

 

 

נוצר לך קובץ של sqllite שאפשר לעבוד איתו גם מחוץ לכרום, הקובץ נמצא בנתיב - 

%localappdata%\Google\Chrome\User Data\Default\databases\

ושם בתיקיה עם שם האתר שבו הרצת את הקוד.

SQL Server Express, MYSQL ברלציונים.

בלא רלציונים - mongoDb.

 

יש עוד הרבה, אבל אלה כלים מאוד נפוצים וחינמיים.

הוא רק מסמך אחד אז זה נורא פשוט.

עכשיו הרבה משתמשים ב mango
הוא לא sql אז תלוי מה רוצים לתרגל.

בתוכנה רגילה - פורמט windows form.

אני לא מאוד מבין בזה, אבל נראה לי שכך:

 

בשביל להריץ משהו שיעבוד על הgpu אתה צריך:

(1) לכתוב משהו שפונה ישירות לgpu. (בעזרת ספריות כמו CUDA/OpenCL) 

(2) להשתמש בספריות שיש להם אופטימזציות\משתמשות בעצמן בgpu. (נראה לי שזה המקרה שלך...)

[(3) לכתוב רגיל ולשים flag לקומפיילר שיעשה לך אופטימזציות לgpu.

-לא מכיר דבר כזה, אבל במחינת הרעיון בfeatures של cpu אני מכיר דברים כאלו.]

 

"האם אפשרי בכל מחשב?"
(1) אתה צריך שבמחשב שלך יהיה gpu כמובן.

     א. בהרבה מהמעבדים של intel היום יש gpu מובנה.

     ב. אם יש לך כרטיס מסך של nvidia אתה יכול להשתמש במשהו שמשתמש בCUDA.
(2) כנראה שתצטרך להתקין ספריות שתומכות בכך מול הgpu הקיים. OpenCL/CUDA.

 

בסופו של דבר נראה לי שכדאי שתחפש:

"tensorflow python gpu"

 

https://www.tensorflow.org/versions/master/how_tos/using_gpu/

 

https://www.tensorflow.org/get_started/os_setup

 

 

 

בהצלחה

ואשמח לדעת כשתצליח מה עשית בסוף...

בדוקומנטציה שלהם זה נראה די פשוט איך להגדיר לתכנית לרוץ על ה-gpu במקום על ה-cpu... 

 

למחשב שלי בעבודה יש gpu במעבד (בדקתי דרך הטרמינל) אבל לא של nvidia. 

לגבי חיפושים: אני כותב כאן כסוג של צעד ייאוש. קראתי באתר את כל מה שקשור בזה ועברתי דפים על גבי דפים בפורומים ושלל אתרים. (בעיקר stackpverflow ו-github אבל גם אחרים). 

 

מעניין אותי אם אני יכול למצוא מישהו שעשה את זה ויכול לחלוק איתי מתובנותיו... 

 

אני אמשיף לעבוד על זה ואם תהיה הצלחה, אעדכן. 

 

תודה ושבת שלום. 

אבל זה נראה שבכל מקרה לכל הOS כיום זה נכון.

 

אלא אם כן אפשר להריץ cuda בלי gpu של NVIDIA, כמו בעזרת OpenCL...

 

כאן זה נראה שלא:

אבל אולי בעזרת זה, זה יעבוד:

[לא בדקתי את זה לעומק...]

 

עוד נקודה חשובה לבדיקה [גם אם משהו כמו "cuda on cl"] יעבוד, עדיין צריך לדאוג שגם cuDNN [שגם הוא של NVIDIA] יעבוד...

 

בהצלחה

וכאן הgit repo שלו:

לילה טוב

זה לא פורום תוֹכְנוֹת אלא תִכְנוּת.

מה זה "החלון שמראה את התהליך"? איזה תהליך?

עקרונית חלונות שקשורים בדבאג נמצאים ב-Debug=>Windows, שאר החלונות נמצאים ב-View.

 

הרצה ב-F10 זהה לחלוטין להרצה ב-F5 חוץ מהעובדה שהקוד נעצר בשורה הראשונה של התוכנית עד להמשך ההרצה.

http://stackoverflow.com/questions/13896450/rand-returns-the-same-number-each-time-the-program-is-run

 

ואני כרגע משתמש בeclipse וזה סבבה בשביל java (בסיסי מאוד) לא יודע מה לגבי ישמוני מובייל.

אני הצלחתי להשיג ג'אווה וגם קומפיילר (netbeans) פורטייבל, נייד.

מה שאני לא מצליח זה להתקין עליו תוסף של ג'אווה מי (JAVA ME) שזה בעצם סביבת פיתוח למכשירים ניידים.

 

אם מישהו יכול לעזור לי אשמח מאד.

כשאני מנסה להתקין את התוסף הוא אומר לי שחסרים לי הרבה תוספים אחרים בכל מיני גרסאות שלא הצלחתי למצוא...

 

תודה!

לבנתיים הראו לי דרכים עוקפות ועוקפות עוקפות, אבל טוב שיש גם פיתרון אמיתי

 

כך שכל דבר שקשור איכשהו לתכנות הוא בהחלט נחשב ברמת הפורום...
אז תרגיש בנוח.

זה עדיף כי זה יתרגם אותם סימולטנית...

מה זה לקמפל קוד של קומפיילר?
מהדרין מן המהדרין...

זה אה"נ

@LightStar

אז לfalse הוא באמת נותן false אבל בגלל שזה or הוא עובר לחלק השני (שאם הוא יהיה נכון אז כל הביטוי נכון כי בor מספיק שרק צד אחד אמת כדי שכל הביטוי יהיה אמת) שהוא true ולכן כל הביטוי הוא true ולכן הוא מחזיר בסה"כ true

 

מקווה שזה מובן

בהצלחה!

מספיק שרק אחד מהמשתנים יהיה true כדי שכל הביטוי יהיה true

לאובייקט List או LinkedList?

 

לגבי

 

 

האובייקט LinkedList הוא רשימה אמיתית -

האיבר הבסיסי שלו הוא LinkedListNode שמכיל הצבעה לאיבר הקודם, הבא, לרשימה ולערך.

באובייקט LinkedList נשמרים הצבעות לאיבר הראשון ברשימה והאחרון ברשימה.

כפועל יוצא - הוספת/ מחיקת איבר בהתחלה או בסוף O(1). הוספת/מחיקת איבר במקום n יהיה O(N) (הזמן שלוקח לעבור על כל האיברים עד למקום הרצוי).

גישה לאיבר במקום n תהיה ב-O(n).

 

האובייקט List, לעומת זאת, הוא פשוט עטיפה למערך.

יש לו מאפיין בשם Capacity (קיבולת), שאומר מה הגודל כרגע של המערך.

הגודל ההתחלתי של המערך הוא 0 (אלא אם הגדרת אחרת ב-ctor.)

כשמוסיפים לו איבר פעם ראשונה הוא יוצר מערך בגודל 4. ומאז כל פעם שהוא עובר את הגודל הזה הוא יוצר מערך בגודל כפול ומעביר לשם את האיברים הקיימים.

מכל זה יוצא שב-List - הוספת איבר בסוף רשימה של n פריטים יהיה במקרה הטוב (כשיש מקום במערך הנוכחי) O(1) ובמקרה הרע O(n). למעשה זה נחשב O(1) כי המקרה הרע הוא נדיר יחסית עבור מיליון הוספות 20 פעם.

הוספת/ הסרת איבר במקום n ברשימה בגודל m תהיה במקרה הטוב O(m-n)  (הזזה של כל המערך שאחרי המקום הזה), ובמקרה הרע O(n) (יצירת מערך מחדש). (נחשב O(n)).

היתרון הגדול במערך הוא בגישה באמצע המערך שהסיבוכיות שלה הוא O(1). עוד יתרון הוא שהוא חסכוני יותר מבחינת זכרון - הוא מקצה רק מקום לערכים עצמם, לעומת LinkedList שיוצר אובייקט עם 3 מצביעים מלבד הערך. ועוד יתרון - הוא מקצה את הזיכרון מראש ולא בזמן ההוספה של איבר חדש.

 

מכל זה יוצר ש-List יותר מהיר גם בהוספה (כי הוא לא יוצר איבר חדש עם 4 מאפיינים כל פעם. והמקרים שהוא צריך להקצות רשימה חדשה הם נדירים יחסית- עבור מיליון הוספות 20 פעם). וגם בגישה לאמצע הרשימה.

לגישה במיקום מסוים ברשימה יש משמעות מאוד גדולה בהרבה מאוד אלגוריתמים (מיון מהיר, לדוגמה).

הסיבה היחידה (שאני חושב עליה) להשתמש ב-LinkedList היא כשצריך הרבה פעמים להוסיף או להסיר איברים באמצע הרשימה.

עוד סיבה אפשרית היא רשימה גדולה של struct שתופס הרבה מקום בזיכרון. אבל שלא ידוע מראש כמה אברים יהיו ברשימה. במקרה כזה מערך יכול לתפוס הרבה מקום מיותר בזיכרון לעומת LinkedList.

 

 

אם כתבתי טכני מדי - אני יכול להסביר יותר...

זה תלוי במימוש של האפליקציה. יש עוד פיתרונות בתלות בסביבה ובשימושים שלה.

 

מה גודל האובייקט?

רעיונות יצירתיים נשמור לפרוייקטים אמיתיים.

 

(לא זוכר שהשתמשתי אי  פעם ב-LinkedList ב-20 השנים שלי במקצוע).

והמורה החדש לא יודע את החומר

אז בהחלט חפרתי יותר מדי.

ב"ה

 

תודה!

 

לא ידעתי את זה.

 

יש לך עוד חומרים כאלו?

 

כתבתי את זה מידע כללי.

אם יש ביקוש אני יכול לעשות פוסט כזה מדי פעם

http://stackoverflow.com/questions/169973/when-should-i-use-a-list-vs-a-linkedlist

bool isReadValidValue = false;
while(!isReadValidValue )
{

Console.Write("Enter cup size (big / medium / small): ");
string cupSize = Console.ReadLine();

isReadValidValue  =true; 
int price = 0;
switch (cupSize)
{
    case "big":
        price = 15;

        break;
 
    case "medium":
        price = 13;
        break;
 
    case "small":
        price = 9;
        break;
 
    default:
        Console.WriteLine("Invalid cup size! please try egain");
isReadValidValue  =false;
        break;
}

} 
if (price != 0)
{
    Console.WriteLine("The coffee price is " + price);
}

תכניס את הסוויצ' בתוך לולאה שתנאי הריצה:
כל עוד price == 0
ואת תנאי if למטה תוכל לבטל כי ברור שיציאה מהלולאה גרמה לprice להיות שונה מאפס. אוכל לשלוח קוד עוד מעט אם זה לא היה ברור.

אני בלי מחשב אבל:
הכרזה על price והצבת 0
התחלת while עם תנאי price == 0
קלט של סטרינג.
כל ה switch
סוף ה while.
פלט של המחיר.

// untested

  var prices= new Dictionary<string, int>()
    {
        { "big", 15},
        { "small",9},
        { "medium", 13}
    };

string cupSize = Console.ReadLine();

if (!prices.ContainsKey(cupSize) throw new Exception("cupSize is wrong") // or while, or what you want;

console.WriteLine("Cofee price is : " + prices[cupSize]);

בשלב הבא אתה צריך לשים שם לולאה (כמו שהציעו מעליי) או כל וריאציה אחרת (אני כמעט ולא עובד בקונסול).

העניין הוא שהרבה יותר פשוט לנהל את זה ככה, במיוחד אם הרשימה הזו מהגיעה מבסיס נתונים או קובץ XML או מה שלא יהיה....