להלן, קטע מדף ההנחייה

In this assignment, we deal with students that register
to courses. We keep lists of students and lists of courses,
where each student knows to which course they are registered,
and each course also “knows” which students are
registered to it.
The structures student and course are informational

קוד:

typedef struct student {
	 char *name;
	 int id;
	 struct clist *courses;
} student;
typedef struct course {
	 char *title;
	 int number;
	 struct slist *students;
} course

;
The structures slist and clist keep the data structure:

קוד:

typedef struct slist {
	 student *info;
	 struct slist *next;
} slist;
typedef struct clist {
	 course *info;
	 struct clist *next;
} clist

;
Note that the nested data structures are kept via pointers
as well—in order to be able to keep data pertaining
to the same student or course in several lists, without
multiplication.

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

תודה מראש

המ.. תחשוב על זה ככה...
יש לך 2 רשימות:
1) רשימת קורסים
2) רשימת סטודנטים

עכשיו, כל איבר ברשימות הללו, מכיר מספר איברים מהרשימה הנוספת. כשאני אומר "מכיר" אני מתכוון, כמובן, למכיל מצביע אליו.
אותו מצביע נשמר ברשימה בתוך אותו האיבר.
בצורה סכמאטית זה נראה בערך כך:



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

שים לב שהתמונה לא מכילה את כל הקשרים... פשוט לא היה לי כח לצייר כ"כ הרבה...

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

לפי הדוגמא למעלה - אין לך מצביע לאיבר הבא ברשימת הסטודנטים / קורסים.
כלומר חסר שדה:
struct student* next
במבנה הסטודנט, ושורה דומה:
struct course* next
במבנה הקורס.
ללא השורות הללו, לא תהיה רשימה מקושרת של סטודנטים ושל קורסים.

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

בברכה, מתן.
www.MatanNarkiss.com

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

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

צודק, נפל לי האסימון.
הרשימות הן רק מסוג slist ו- clist וה- data שהן מחזיקות הוא מסוג struct course ו- struct student.

בברכה, מתן.
www.MatanNarkiss.com

עכשיו אני צריך להגדיר את הפונקציה

קוד:

slist* add_student(slist *students, char *name, int id);

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

חstudents=(slist*)malloc(sizeof(slist));
וכך גם עבור
name
וכל פעם אני מקצה ככה זכרון חדש לשם חדש?


האם הבנתי נכון את השאלה?

ממה שאני מבין, יש לך מבנה מסוג student ורשימה של סטודנטים בשם slist.
אתה מתבקש להוסיף סטודנט לרשימה בפונקציה ולכן עליך:
1. להקצות דינאמית מקום למופע מסוג סטודנט
2. להוסיף אותו לרשימה
את הפרטים של הסטודנט אתה כבר מקבל מבחוץ (שם ומזהה).
ישנה שאלה על טיבו של השם - מאיפה אתה משיג אותו? האם הוא בעצמו הוקצה דינאמית או מה?
בכל מקרה, בשביל סעיף 1 אתה צריך להקצות מקום רק לסטודנט אחד, ולא לפי גודל כל הרשימה:

קוד PHP:

 student = (struct Student*) malloc (sizeof(struct Student));
student.name = name;
student.id = id; 


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

קוד PHP:

 strcpy(student.name, name); 


או משהו כזה, לא זוכר מי קודם - היעד או המקור.. חפש בגוגל

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

בברכה, מתן.
www.MatanNarkiss.com

אני חושב שאני צריך להקצות זכרון דינאמי הן לSLIST והן לSTUDENT עכשיו אני איכשהו אמור לקשר אותם ... אוקי.. יש לי מצביע של INFO שמצביע על המבנה של הסטודנט .. נראה לי שגם הצלחתי להזין ת.ז .. אבל אם אני מקבל *NAME בפונקציה כלומר, כתובת למחרוזת איך אני מעביר אותה בעזרת STRCPY לנתונים של הסטודנט?

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

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

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

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

קוד PHP:

 char buffer[255];
/* scan details */
printf("enter a name\n");
scnaf("%s", buffer);

/* create a new student */
struct Student* student = (struct Student*) malloc (sizeof(struct Student));

/* create a new string for student's name */
student.name = (char*) malloc (sizeof(char) * strlen (buffer));

/* copy the name from buffer into student.name */
strcpy (student.name , buffer); 


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

בברכה, מתן.
www.MatanNarkiss.com

והוא צריך גם לייצר slist חדש, ולהוסיף אותו לרשימה. אחרי שיצרנו את הסטודנט שעשית למעלה, צריך:

קוד:

slist * slist_student = malloc(sizeof(slist));
slist_student.info=student;
slist_student.next=NULL;
for (slist*cur=students; cur.next!=NULL || cur.next=slist_student; cur=cur.next);

לכבוד השנה החדשה כתבתי קוד מזעזע במיוחד.

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

קוד:

slist* add_student(slist *students, char *name, int id) { 
student* head; 
if (!( head = (student*)malloc(sizeof(student)))) exit (1); 
head->id = id; 
head->name = name; 

if (!( students = (slist*)malloc(sizeof(slist)))) exit (1); 
students->info = head ; 
students->next = NULL ; 

return students; }

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

לא. זה לא מה שכתבת. אתה כתבת משהו אחר, וזה נראה כאילו לא קראת או התעלמת ממה שאני ו-NARXX כתבנו לך למעלה. קודם כל, בחלק הזה יש באג:

ציטוט:

במקור נכתב על ידי Army_Boy קוד: slist* add_student(slist *students, char *name, int id) { student* head; if (!( head = (student*)malloc(sizeof(student)))) exit (1); head->id = id; head->name = name;

כמובן ש-NARXX הסביר למעלה מה אתה צריך לעשות, ואפילו כתב קוד לדוגמה:

ציטוט:

במקור נכתב על ידי Narxx במצב הזה, אתה לא יכול פשוט להעתיק עם strcpy, כיוון שאין לך מחרוזת אלא רק מצביע. אתה צריך קודם לכן להקצות מקום למחרוזת ורק אח"כ להעתיק. איך עושים? נניח שיש לך buffer כלשהו שאתה סורק אליו, ולצורך הפשטות, נניח שאתה משתמש ב scanf (אם אתה משתמש בפונקציה אחרת, פשוט זרום עם הדוגמא שלי ותשנה אצלך בקוד למה שזה לא יהיה). קוד PHP:  char buffer[255]; /* scan details */ printf("enter a name\n"); scnaf("%s", buffer); /* create a new student */ struct Student* student = (struct Student*) malloc (sizeof(struct Student));   /* create a new string for student's name */ student.name = (char*) malloc (sizeof(char) * strlen (buffer)); /* copy the name from buffer into student.name */  strcpy (student.name , buffer);

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

קוד:

void f() {
	char buf[255];
	printf("Enter name: ");
	fgets(buf, sizeof(buf));
	slist* students = getFromSomewhere();
	add_student(students, buf, 123);
}

void g() {
	f();
}

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


הבאג השני שלך הוא שבמקום להוסיף את הסטודנט לרשימה שנתנו לך, אתה זורק את הרשימה לעזאזל, ויוצר רשימה חדשה:

ציטוט:

במקור נכתב על ידי Army_Boy קוד: if (!( students = (slist*)malloc(sizeof(slist)))) exit (1); students->info = head ; students->next = NULL ; return students; }

כאילו, על מה חשבת כשעשית את זה?
נותנים לך את הפרמטר students, ואז אתה מתעלם ממה שיש בו, ודורס אותו עם ערך חדש משלך.
אז למה קיבלת את הפרמטר הזה בכלל?
כמובן שכתבתי למעלה מה היית אמור לעשות, אבל כמו במקרה עם NARXX, או שלא קראת או שהתעלמת.

ציטוט:

במקור נכתב על ידי פסטן והוא צריך גם לייצר slist חדש, ולהוסיף אותו לרשימה. אחרי שיצרנו את הסטודנט שעשית למעלה, צריך: קוד: slist * slist_student = malloc(sizeof(slist)); slist_student.info=student; slist_student.next=NULL; for (slist*cur=students; cur.next!=NULL || cur.next=slist_student; cur=cur.next); לכבוד השנה החדשה כתבתי קוד מזעזע במיוחד.

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

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

הפונקציה אמורה להחזיר ערך לstudents מה אני מחזיר? את ה

return cur=cur->next ?

איך אפשר בלי לולאה?
אני רוצה להגיע לאיבר האחרון ברשימה, ולהוסיף לשם את האיבר שיצרתי:

קוד:

slist foo = 0;
slist * new_element = malloc(sizeof(slist));
new_element.info = new_student;
new_element.next = 0;

foo = (*students).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
foo = (*foo).next;
...
(*foo).next = new_element;

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

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

ואז אני פשוט יוצר מבנה חדש ומקצה לו מקום חדש...

***

אני לא מבין מה זה אומר.
במקום שתהיה לך רשימה מקושרת, יש לך מיליון רשימות מקושרות שבכל-אחת מהן אלמנט אחד? למה זה טוב?

זה מה שעשיתי

קוד:

void free_course(clist *cl){ 
if (!cl) return; 

free_course(cl->next); 
free(cl->info->title); 
printf("FREED\n"); 
free(cl->info); 
printf("FREED\n"); 
free(cl); 
printf("FREED\n");

אבל זה נתקע לי בFREE הראשון... למה?

בלי לראות את הקוד אי אפשר לדעת, אבל הניחוש שלי הוא ש-cl->info->title מצביע למערך סטטי, או סתם לאיזו כתובת שלא הקצית בעזרת malloc...

בבקשה


[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://a4.sphotos.ak.fbcdn.net/hphotos-ak-ash4/388230_2849245987403_1147066737_33168695_1344227217_n.jpg]

כן, כל הנקודות שכתבתי שם אמורות להיות חצים:

קוד:

slist * slist_student = malloc(sizeof(slist));
slist_student->info=student;
slist_student->next=NULL;
for (slist*cur=students; cur->next!=NULL || cur->next=slist_student; cur=cur->next);

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

עשיתי עם חצים . עדיין יש בעיה

למה שלא תבדוק מה ה-error שכתוב לך על השורה הזאת בחלק למטה....של ה-error-ים?

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

קוד:

slist* add_student(slist *students, char *name, int id) { 
student* Student ; 
slist* list ; 
slist* current ; 
if (! (list = (slist*) malloc (sizeof(slist)))) exit (1); 

if (! (Student = (student*) malloc (sizeof(student)))) exit (1); 

if (! (Student->name = (char*) malloc (sizeof(char) * strlen (name)))) exit (1); 
strcpy (Student->name , name ); 
Student->id = id ; 

list->info = Student ; 
list->next = NULL ; 
for ( current=students; current->next !=NULL; current=current->next ); 

current->next = list ; 
return current; }

האם הוא בסדר עכשיו?

המטרה :
לרשום סטודנטים לקורסים

הקוד

קוד:

void reg_student(slist *students, clist *courses, int id, int number) { 
clist* temp=courses; 
while (students) { 
    if (students->info->id == id){ 
            temp = students->info->courses ; 
            break; } 
     students=students->next; } 

while (courses) { 
if (courses->info->number == number)
        { students = courses->info->students; 
          break; } 
courses=courses->next ; } 
courses = temp;
}

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

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://a2.sphotos.ak.fbcdn.net/hphotos-ak-ash4/397853_2850714784122_1147066737_33169909_82386391_n.jpg]


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

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

שים לב (בלי קשר) שהמשתנים new_clist ו-new_slist לא נשמרים בשום מקום ובעצם ברגע שאתה תצא מהפונק' לא תהיה לך דרך לגשת אליהם וזה גם יגרום לדליפת זיכרון.

כך אני גם מתגבר על הדליגת זכרון?

אם יש לך פונ' כאלה אז כן.

ההגשה למחר, אין לך הרבה זמן...

על פניו זה אמור לעבוד וזה עובד רק שמשום מה בNEXT האחרון יש בעיה .. אני לא מצליח להבין למה

קוד:

void reg_student(slist *students, clist *courses, int id, int number) { 
slist* new_std; 
clist* new_crs; 
if (!students||!courses) 
return; 

if (! (new_std = (slist*) malloc (sizeof(slist)))) exit (1); 
if (! (new_crs = (clist*) malloc (sizeof(clist)))) exit (1); 
for (;students->info->id!=id;students=students->next); 
for (;courses->info->number!=number;courses=courses->next); 

new_std->info = students->info ; 
new_crs->info = courses->info ; 

while (courses->info->students) 
      courses->info->students = courses->info->students->next ; 
new_std->next = NULL ; 
courses->info->students = new_std ; 

while (students->info->courses) 
      students->info->courses = students->info->courses->next ; 
new_crs->next = NULL ; 
students->info->courses = new_crs ; 
}

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://a1.sphotos.ak.fbcdn.net/hphotos-ak-ash4/381203_2883134434593_1147066737_33189722_283559361_n.jpg]


וזאת הבעיה :


[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://a7.sphotos.ak.fbcdn.net/hphotos-ak-ash4/388823_2883599406217_1147066737_33189878_2086358940_n.jpg]