מצביעים C

[omfir]

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

void LOGIN(char* A[SIZE],char PASS[][COLS])
{
  int i,j,k;
  char logname[63];
  puts("Please enter a user name:");
  fflush(stdin);
  gets(logname);
  for(i=0;i<SIZE;i++)
  {
  if(A[i]==logname)
  {
  printf("%s",logname);

  }
  }



}

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

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

[lost_dm]

1. למה אתה צריך את fflush?

2. אתה לא עושה שום שימוש בארגומנט PASS - למה אתה צריך אותו?

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

4. יש לך מערך של SIZE מצביעים לטיפוס char. כל אחד מהמצביעים הוא התחלה של null terminated string. מה שאתה רוצה לעשות זה להשוות את המחרוזת ב- longname לכל אחת מהמחרוזות שהמצביעים במערך מצביעים עליהם. ב- c לא משווים מחרוזות ע"י אופרטור == אלא ע"י strcmp ועדיף אפילו strncmp.

5. שורה תחתונה, אין אפשרות ללמד אותך כאן מצביעים. תתחיל ע"י כך שתקרא tutorial ועדיף אפילו ספר טוב. למשל: http://www2.its.strath.ac.uk/courses/c/ - לא חקרתי את הלינק לעומק אבל ברפרוף הוא נראה סביר.

[omfir]

תודה!..

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

char * NEW_USER()
{

	char* NAME;
	int i=0;
	char name[63];
	char name2[63];
	do
	{
	puts("Please enter a user name (up to 63 charactars):");
	fflush(stdin);
	gets(name);
	if(strlen(name)+1>63)
	{
		puts("Wrong input");

	}
	else
		if(strlen(name)+1<63)
		{
		for(i=0;name[i]!=0;i++)
		{
			name2[i]=name[i];
		}
		name2[i]='/0';
		NAME=(char*)malloc((strlen(name2)+1)*sizeof(char));
		strcpy(NAME,name2);
		return NAME;
		}
	}
	while(strlen(name2)+1>63);


}

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

הבקרה לא עובדת טוב,אם לדוגמא הכנסתי 63 תווים של 1 ולאחר מכן 4 תווים של 2 נוצר לי מצב כזה 2222011111111 ולכן לפי דעתי התכנית קורסת.

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

"stack arount the var 'name' is courapted"

[omfir]

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

[שניצל]

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

אתה צריך להשתמש ב-fgets, שמקבלת מספר תווים מקסימלי לקרוא (הפרמטר השלישי שמועבר לפונקציה הוא קובץ הקלט, במקרה שלך stdin).

[omfir]

כמה שאלות,

1)התכנית מדלגת על ה-if הראשון של בדיקת אורך הקלט,לא ברור לי למה.

2)שאלה כללית יותר לגבי פונקציות כאשר אני לדוג' משתמש בפונקציה strcmp שתי הארגומנטים שלה הם const* str.

אני לא מבין משהו קטן. למה יש את הconst,כדי שלא יתאפשר שינוי של תוכן המצביע?

char * NEW_USER()
{

	char* NAME;
	int i=0;
	char name[63];
	char name2[63];
	do
	{
	puts("Please enter a user name (up to 63 charactars):");
	fflush(stdin);
	fgets(name,63,stdin);
	if(strlen(name)+1>63)
	{
		puts("Wrong input");
		NEW_USER();
	}
	else
		if(strlen(name)+1<63)
		{
		NAME=(char*)malloc((strlen(name)+1)*sizeof(char));
		strcpy(NAME,name);
		return NAME;
		}
	}
	while(strlen(name)+1>63);

[שניצל]

1. בבירור אם אמרת ל-fgets לקרוא עד 63 תווים, האורך של המחרוזת לא יהיה יותר מ-63 תווים... ה-if הזה חסר משמעות.

2. כן, פחות או יותר. שים לב שיש כמה דרכים להשתמש ב-const:

const char *p = ...;
char *const q = ...;
const char *const s = ...;

בקוד הזה p הוא מצביע ל-const char, בעוד ש-q הוא מצביע קבוע ל-char, ו-s הוא מצביע קבוע ל-const char.

את p אפשר לשנות, אבל אי אפשר לשנות את הערך בזכרון שהוא מצביע עליו, דהיינו:

int a = 5;
p = &a; // legal
*p = 6; // illegal

לעומת זאת, את q אי אפשר לשנות, אבל אפשר לשנות את הערך בזכרון שהוא מצביע עליו, כלומר (נניח ש-a,b הם משתנים מטיפוס int):

char * const q = &a; // ok
q = &b; // illegal
*q = 6; // legal - equivalent to a = 6

ו-s הוא שניהם - אי אפשר לשנות את המקום שהוא מצביע אליו, וגם את הערך שיושב במקום הזה.

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

[omfir]

פשששש איזה הקלה,תודה שניצל!

[omfir]

אם כבר עסקינן במצביעים אז נתקעתי בעוד בעיה מעצבנת..

[

[omfir]

typedef struct 
{ 
 int day; 
 int month; 
 int year; 
}Date;    /* Date of birth */ 
typedef struct 
{ 
 int serial_num; 
 char full_name[LEN]; 
 Date *pDate; 
}Person;   /*New Person for list */
void First(const char *names[MAX],const int dates[MAX][COLS],int counter)
[size=15px]1)איך אני עובד עם מצביע שמצביע למבנה אחר(הרי מה שכתבתי לא עובד).[/size]
[size=15px]2)איך מטיפוס מבנה של Person אני מגיע לערך הInt של day מצורה שונה ממה שכתבתי בקוד.[/size][/i]
[/quote]

[שניצל]

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

[omfir]

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

הרי לpDate אני יכול לגשת רק ע"י המערך

arr.pDate

אבל,איך אני מאתחל את המצביע pDate להקצאה דינמית?.

ליצור מצביע נוסף בפונקציה?,אם כן אז הטיפוס שלו יהיה מבנה?.

לזה אני מתכוון-

Person *A;
A=(*Person) malloc(MAX*sizeof(A));

ואז איך אני מיישם את זה לpDate?arr.pDate=&A?.אתה יכול בבקשה להסביר לי בצורה טיפלה יותר מפורטת?

[שניצל]

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

מצביע שיושב בתוך struct הוא בדיוק כמו כל מצביע אחר, ואפשר לשים בו את התוצאה של malloc.

[omfir]

סבבה.

שניצל,יש אפשרות שתראה לי פחות או יותר איך לעשות את זה?,אני פשוט מנסה ולא הולך לי..

[שניצל]

arr[i].pDate = (Date*)malloc(sizeof(Date));