שמתי לב ש-NULL מוגדר באופן הבא:

קוד:

#define NULL ((void *)0)

רציתי לדעת למה דווקא ההגדרה הזו, ומהו סוג ה-casting שבוצע על המספר 0 ?
האם זה הופך את NULL למצביע על התא שכתובתו 0, או למצביע שערכו הוא 0 (וכתובתו לא ידועה כביכול) ?

נניח ויש לי את הפונקציה Check_Something הבאה:

קוד:

#define NULL ((void *)0)

int main(void)
{
   // code ...

   if (Check_Something() == NULL)
      // bla bla...
}

char Check_Something()
{
    return NULL;
}

מה יהיה הערך שיוחזר מהפונקציה Check_Something ?
האם הוא יהיה NULL או שיתבצע עליו casting ל-char (כפי שצפוי) ?
אם יתבצע עליו casting ל-char, מה יהיה ערכו (מה הוא יהיה שווה) ?

נזכרתי בשאלה קטנה נוספת:
האם קיים אופרטור השוואה מסוג כמו:

קוד:

if (num1 === char2)

??

הכוונה היא לאופרטור השוואה שמשווה גם את סוג המשתנה (אם הוא int או char וכו'..)

תודה!

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

בקשר לפונקציה. לפני הומפילציה יהיה של של preporcessing והקוד שלך יהפוך ל:

#define NULL ((void *)0)

int main(void)
{
// code ...

if (Check_Something() == ((void *)0))
// bla bla...
}

char Check_Something()
{
return ((void *)0);
}

אני מאמין שהערך שיוחזר יהיה 0 או \0 (הכוונה לסוף מחרוזת.)

מה זאת אומרת אופטור שמשווה את סוג המשתנה? אתה מתכוון למשהוא כמו === ב PHP? אם כן אז לא קיים אופרטו כזה עד כמה שידוע לי.

ציטוט:

במקור נכתב על ידי eXtruct לגבי NULL פעם ראשונה רואה את הגגדרה הזאתי, עד כמה שידוע לי NULL מוגדר כ 0 או 0L.

למה הכוונה ב-0L

?

ציטוט:

במקור נכתב על ידי eXtruct מה זאת אומרת אופטור שמשווה את סוג המשתנה? אתה מתכוון למשהוא כמו === ב PHP? אם כן אז לא קיים אופרטו כזה עד כמה שידוע לי.

כן, כמו ב-PHP.

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

תודה!

0L = המספר 0 בפורמט ארוך (LONG)

הראל

NULL מוגדר כ0 ב C++,
בC הוא מוגדר כמו שהוא ציין מצביע לכתובת 0.

בפונקציה Check_Something שהראת הקומפילר ימיר את המצביע NULL למספר בין 0 ל 255, המספר לא חייב להיות 0! אך ברוב המערכות הוא כן יהיה ולכן נגיד והייתה משנה את הבדיקה שלך ל

קוד:

 if (Check_Something() == 0)

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

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

קוד:

char *abc = 0

וקומפילר רואה שהצבת 0 בהקשר של מצביע וכבר בזמן קימפול (ורק אז) משנה את הערך לערך ה
null. וככה זה בכל מקרה שבוא הקומפיילר יראה 0 בהקשר של מצביע. ולכן NULL מוגדר כ

קוד:

(void *) 0

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

קצת קוד להמחשה:

קוד:

char *abc, *k = 0, i = 0, p = NULL;
abc = 0;	 //abc points to null (abc is a null pointer)
abc = NULL;  //abc still points to null
abc = k;	 //abc still points to null
abc = p;	 //abc could be pointing to null
abc = i;	 //abc could be pointing to null

ההצבה הראשונה ל abc תציב בו את הערך המיוחד של null (לא חובה שערך זה הוא 0) מכיוון שהקומפילר מזהה 0 בהקשר של מצביע (abc הוא מצביע) והוא יחליף את ה0 בערך המיוחד.
ההצבה השניה גם כן תציב את הערך המיוחד כפי שנאמר קודם. ההצבה השלישית גם כן תציב את הערך המיוחד מכיוון שהמצביע k גם כן מכיל את הערך המיוחד הזה. ההצבה הרביעית אינה בהכרח תעבוד כמו השאר מכיוון שהערך של null יכול להיות גדול יותר מ255 ולכן הוא לא יכנס במלואו ל p. בעצם ההצבה הרביעית תעבוד רק במקרה שבוא הערך המיוחד הזה קטן מ256 ההצבה האחרונה גם אינה בהכרח תעבוד מכיוון שi הוא לא מצביע, יוצב בו בו הערך 0 ולא הערך של null כי זה לא בהקשר של מצביע ואז הערך (אפס) יוצב ב abc ואם במערכת מצביע לכלום (null) מוגדר כערך שונה מאפס ההצבה לא תעבוד כרצוי.

קוד הבא הוא תקין ויפעל כצפוי - הערך X יודפס:

קוד:

char *do_something() { return 0; }
if (do_something() == 0) {
	if (do_something() == NULL) {
		if (do_something()) { //Compiler see this as: if (do_something() == 0)
			printf("X");
		}
	}
}

עכשיו נחזור למקרה ההוא:

קוד:

 if (Check_Something() == 0)

ונגיד שאתה מריץ אותה במערכת שבה הnull הוא לא 0 אלא 190,
הפונקציה מחזירה NULL אשר שווה למצביע לכתובת 190, אשר מומר ל char ולכן הפונקציה תחזיר
190, הקומפילר רואה השוואה ל0 אבל בהקשר של char ולכן הוא לא ממיר את ה0 לערך של null
והקוד לא יפעל כמתוכנן. אך אם נשנה את הפונקציה כך שתחזיר מצביע הכל יפעל כראוי כי הקומפילר
יחליף את הערך 0 לערך של null מכיוון שזה בהקשר של מצביע.

קצת ארוך יצא, אז מקווה שהבנת למרות זה.

Error: Keyboard not found

Press F1 to continue

כבר אי אפשר לערוך ורציתי להוסיף שNULL ב C++ שונה מNULL ב C
char a = NULL;
ב C++ יהיה שווה ל0,
ב C יהיה שווה לערך המיוחד null, שלא חובה יהיה שווה ל0 מאותן סיבות שפירטי למעלה.

Error: Keyboard not found

Press F1 to continue

ציטוט:

במקור נכתב על ידי maind NULL מוגדר כ0 ב C++, בC הוא מוגדר כמו שהוא ציין מצביע לכתובת 0.

C ו-C++ זה לא אותה השפה?
שמתי לב שיש להם תחביר דומה (אם לא בדיוק אותו הדבר), ועד כמה שהבנתי - Cpp זו הרחבה של שפת C?

כל השאר אני חושב שהבנתי!

מלבד השורה הבאה:

קוד:

if (do_something()) { //Compiler see this as: if (do_something() == 0)

למה הקומפיילר מתרגם את זה למשפט-אמת אחר?

אני מניח שבמקרה זה, כל תנאי ה-if המקוננים הם דומים בתוצאתם, בכל המקרים.

כדי לבדוק שהבנתי נכון, אתקן את הקוד שכתבתי:

קוד:

#define NULL ((void *)0)

int main(void)
{
   if (Check_Something() == NULL)
      // bla bla...

   return 0;
}

char *Check_Something()
{
    return 0;
}

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

תודה על הפירוט!

התכוונתי ל:

קוד:

//Compiler see this as: if (do_something() != 0)

אתה לא אמור להחזיר מהפונקציה ערך רגיל כמו 1. הגדרת שהפונקציה מחזירה מצביע, אז אתה צריך להחזיר מצביע למשהו או מצביע לכלום - להחזיר NULL או 0. כמו ש malloc לדוגמא מחזיר מצביע לזכרון אשר הוקצה או מצביע לכלום (null pointer) אם הוא ניכשל כי אין זיכרון פנוי.

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

קוד:

#include <stdio.h>
#include <string.h>


char *GetSecondLine(char *str, int &error) {
	int i, z;
	error = 0;
	if (*str == '\0') { error = 1; return NULL; }
	z = strlen(str); z--; 
	for (i = 0; i < z; i++, str++) { 
		if (*str == '\n') return ++str;
	}
	error = 2;
	return NULL;
}

int main() {
	char buf[] = "Hello World\nHow are you?";
	char *SecLine = NULL;
	int error = -1;
	SecLine = GetSecondLine(buf, error);
	switch (error) {
		case 1: 
			puts("Error: empty input string!\n");
			break;
		case 2: 
			puts("Error: No second line!\n");
			break;
		case 0: 
			printf("Second line: %s\n", SecLine);	
			break;
	}
	return 0;
}

Error: Keyboard not found

Press F1 to continue

תודה, הבנתי!

ציטוט:

במקור נכתב על ידי maind זה מכיוון שבשפה יש מה שנקרא null pointer זה ערך יחודי למצביע מסוג מסוים (כן יכול להיות שלסוגים שונים הערך הוא שונה) שמסמל שהמצביע מצביע אל כלום, שאין מצב שהוא יצא שווה לערך של מצביע אחר מאותו סוג. והערך הזה לא חייב להיות 0. אבל כשאתה כותב משהו בסגנון הבא: קוד: char *abc = 0 וקומפילר רואה שהצבת 0 בהקשר של מצביע וכבר בזמן קימפול (ורק אז) משנה את הערך לערך ה null. וככה זה בכל מקרה שבוא הקומפיילר יראה 0 בהקשר של מצביע. ולכן NULL מוגדר כ קוד: (void *) 0 הקומפילר רואה 0 בהקשר של מצביע וממיר אותו לערך המיוחד הזה של null. קצת קוד להמחשה: קוד: char *abc, *k = 0, i = 0, p = NULL; abc = 0; //abc points to null (abc is a null pointer) abc = NULL; //abc still points to null abc = k; //abc still points to null abc = p; //abc could be pointing to null abc = i; //abc could be pointing to null ההצבה הראשונה ל abc תציב בו את הערך המיוחד של null (לא חובה שערך זה הוא 0) מכיוון שהקומפילר מזהה 0 בהקשר של מצביע (abc הוא מצביע) והוא יחליף את ה0 בערך המיוחד. ההצבה השניה גם כן תציב את הערך המיוחד כפי שנאמר קודם. ההצבה השלישית גם כן תציב את הערך המיוחד מכיוון שהמצביע k גם כן מכיל את הערך המיוחד הזה. ההצבה הרביעית אינה בהכרח תעבוד כמו השאר מכיוון שהערך של null יכול להיות גדול יותר מ255 ולכן הוא לא יכנס במלואו ל p. בעצם ההצבה הרביעית תעבוד רק במקרה שבוא הערך המיוחד הזה קטן מ256 ההצבה האחרונה גם אינה בהכרח תעבוד מכיוון שi הוא לא מצביע, יוצב בו בו הערך 0 ולא הערך של null כי זה לא בהקשר של מצביע ואז הערך (אפס) יוצב ב abc ואם במערכת מצביע לכלום (null) מוגדר כערך שונה מאפס ההצבה לא תעבוד כרצוי. ... ונגיד שאתה מריץ אותה במערכת שבה הnull הוא לא 0 אלא 190, הפונקציה מחזירה NULL אשר שווה למצביע לכתובת 190, אשר מומר ל char ולכן הפונקציה תחזיר 190, הקומפילר רואה השוואה ל0 אבל בהקשר של char ולכן הוא לא ממיר את ה0 לערך של null והקוד לא יפעל כמתוכנן. אך אם נשנה את הפונקציה כך שתחזיר מצביע הכל יפעל כראוי כי הקומפילר יחליף את הערך 0 לערך של null מכיוון שזה בהקשר של מצביע. קצת ארוך יצא, אז מקווה שהבנת למרות זה.

אפשר לראות קישורים ומקורות שמדברים על זה שיש יישות שהיא "null pointer" שונה מאפס?
אני מסתכל באתר של סטרוסטרופ ואני רואה את זה:

Should I use NULL or 0?

In C++, the definition of NULL is 0, so there is only an aesthetic difference. I prefer to avoid macros, so I use 0. Another problem with NULL is that people sometimes mistakenly believe that it is different from 0 and/or not an integer. In pre-standard code, NULL was/is sometimes defined to something unsuitable and therefore had/has to be avoided. That's less common these days. If you have to name the null pointer, call it nullptr; that's what it's going to be called in C++0x. Then, "nullptr" will be a keyword.

ואת זה:

NULL - zero. 0. 0 is an integer. 0 can be implicitly converted to every pointer type. See also: nullptr. TC++PL 5.1.1, D&E 11.2.3.

nullptr - C++0x keyword for the null pointer. It is not an integer. It can be assigned only to pointers.

ובקיצור, היום (לפני C++0x), פוינטר-null מיוצג על ידי NULL ששקול ל-0 ששקול לכל ביטוי מהצורה:

(type*)0

בגלל ההמרה האוטומטית של 0 לכל טיפוס פויינטר (כולל פויינטר לפונקציה וכו').

אני אנסה למצוא את TCP++L ואת התקן כדי להציץ גם שם, אבל בינתיים זה נשמע לי מאוד מוזר.




עריכה:
אז בדקתי מה התקן אומר:

...

כעגגכ
ב-TC++PL מצאתי אמירה מוזרה:

Note that using the integer 0 as the terminator would not have been portable: on some implementations, the integer zero and the null pointer do not have the same representation. This illustrates the subtleties and extra work that face the programmer once type checking has been suppressed using the ellipsis.

דגכגד

התקן אומר:

4.10 Pointer conversions [conv.ptr]

1 A null pointer constant is an integral constant expression (5.19) rvalue of integer type that evaluates to
zero. A null pointer constant can be converted to a pointer type; the result is the null pointer value of that
type and is distinguishable from every other value of pointer to object or pointer to function type. Two null
pointer values of the same type shall compare equal. The conversion of a null pointer constant to a pointer
to cv-qualified type is a single conversion, and not the sequence of a pointer conversion followed by a qual-
ification conversion (4.4).

ומצד שני TC++PL אומר ש:

Note that using the integer 0 as the terminator would not have been portable: on some implementations, the integer zero and the null pointer do not have the same representation. This illustrates the subtleties and extra work that face the programmer once type checking has been suppressed using the ellipsis.

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

In pre-standard code, NULL was/is sometimes defined to something unsuitable and therefore had/has to be avoided. That's less common these days.

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

תודה על הדיוק!

אז לסיכום, כפי ש-maind כתב - null אכן לא חייב להיות מצביע ל-0 בקומפיילרים שונים (אף שהם לא תיקניים ע"פ C99).
כי הרי טכנית הקומפיילרים האלו קיימים וסביר להניח שמשתמשים בהם (כמו הקומפיילר ש- Borland משתמש בו, שמשתמשים בו בבתי ספר לצערי).

במקרים שבהם null מצביע לערך השונה מ-0, כיצד אפתור את הבעיה הראשונית שבהודעתי הראשונה באשכול?
האם ייחוס אוטומטי למשתנה ע"י & יהיה הפיתרון העדיף ביותר? (בדומה לקוד שכתב maind בתגובתו: http://www.fresh.co.il/vBulletin/sh...467#post3093292 )

פשוט תחזיר 0 במקום את המאקרו NULL וזהו.

אבל לא בכל הקומפיילרים null מיוצג ע"י מצביע ל-0...

ציטוט:

במקור נכתב על ידי maind ונגיד שאתה מריץ אותה במערכת שבה הnull הוא לא 0 אלא 190, הפונקציה מחזירה NULL אשר שווה למצביע לכתובת 190,

לכן כנראה אצטרך לעשות מצביע ל-190 ...

או שלמרות זאת כל הקומפיילרים מחשיבים מצביע ל-0 כ-null ?

ציטוט:

A null pointer is a pointer in a computer program that does not point to any object or function. In C, the integer constant 0 is converted into the null pointer at compile time when it appears in a pointer context, and so 0 is a standard way to refer to the null pointer in code. However, the internal representation of the null pointer may be any bit pattern (possibly different values for different data types), and has no particular association with zero. (Note that on most common architectures, the null pointer is represented internally by the integer 0, so C compilers on such systems perform no actual conversion.)

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

Error: Keyboard not found

Press F1 to continue

לא קונה את זה.

הייתי אומר שב-x86 כל כתובת בין 0 ל-4GB חייבת להיות חוקית. במקרה הזה, לא משנה מה ידפיס הקוד הבא, אנחנו בבעיה:

קוד:

union oh_my_god {
	void* p;
	int i;
} omg;

omg.p = 0;
printf("%d\r\n", omg.i);

בכל מקרה, נראה כאילו ייקחו כתובת לגיטימית, ויאנסו אותה להיות "לא חוקית".

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

טוב, אני אחזור על זה לאט.

ב-protected mode על 386 והלאה כתובת מורכבת מ-48 ביט - 16 ביט שמשמשים ב-segment selector ו-32 ביט שמשמשים כ-offset. מהם נוצרת כתובת לוגית באורך 32 ביט שמצביעה ל-PDE, ל-PTE ולבייט ספציפי בתוך ה-page. כל מספר בן 32 ביט עשוי לציין כתובת לגיטימית. כל מספר בין 32 ביט עשוי לציין כתובת לגיטימית. הארכיטקטורה הזו לא שמה הגבלות על כתובות מהבחינה הזו. טווח הזיכרון הוא 4GB ולא 4GB-1.

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

בדרך-כלל, זה לא פועל כל כך טוב. לדוגמה, הפונקציה getch מחזירה int, כדי שתוכל להחזיר כל char אפשרי + EOF. כדי להחזיר כל 32 ביט אפשרי + "כתובת לא ואלידית" צריכים יותר מ-32 ביט, אבל זה לא המצב.

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

אני מניח שאתה מתכוון לכך שכפועל יוצא מהגדרת NULL כ 0 יוצא שהכתובת 0 היא כתובת לא חוקית למרות שתאורטית אפשר היה להשתמש בה.
אני לא רואה בזה בעיה כי נראה לי שממילא טווח הכתובות הבסיסי בזיכרון משמש את ה kernel / BIOS ולכן הן ממילא לא חוקיות עבור תוכניות.

הראל

הפתעה הפתעה כאן, דרייברים ל-NT מקובל לכתוב ב-C וזו ההמלצה של MS, לדוגמה.

בכתובת ם ב-PC-י נמצאת ה-IDT, ולא רק שאני עשוי לרצות לכתוב אליה, אני גם יודע שזה אפשרי, ומשתמשים בזה כל הזמן. לדוגמה - קיומם של TSR-ים אפשרי בין השאר בזכות זה.

העניין איננו מיוחד לאפס. בכל מקרה ייקחו כתובת מסוימת אחת, וישתמשו בה כדי לציין "כתובת בלתי חוקית", ולא ברור לי איך מחליטים את זה. ב-user mode זה בסדר שזה יהיה אפס, כי אין הרשאות לשם בדרך-כלל, ואז חוטפים AV/GPF/segfault וכו' מה שטוב לנו. אבל ב-kernel mode אני דווקא רוצה לכתוב לשם.
אז מה נעשה? נגיד flag בקומפיילר שב-kernel-mode מניח לדוגמה, שכל הגישות לזיכרון חייבות להיות aligned, ואז משתמש בכתובת אי-זוגית כלשהי בשביל זה? זה בסדר, עד השלב שבו נרצה קומפיילר שיעבור גם עם כתובות לא מיושרות.

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

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

Error: Keyboard not found

Press F1 to continue

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

קוד:

int f(T *p, int i) {
   if ((p == NULL) || (i < 0)) return INVALID_ARG;
   ...
}

לא נעים...

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

An integer constant expression with the value 0, or such an expression cast to type
void *, is called a null pointer constant.55) If a null pointer constant is converted to a
pointer type, the resulting pointer, called a null pointer, is guaranteed to compare
unequal to a pointer to any object or function.

שוב, לא כל כך טוב. המימוש עלול להיות כזה ש-p מצביע לכתובת ה"לא חוקית", p2 מצביע לאלמנט במערך שנמצא אחד לפני p, וההשוואה הבאה תתפקד לא נכון:

קוד:

if (p == p2+sizeof(T))

לא?

קוד:

int f(T *p, int i) {
if ((p == NULL) || (i < 0)) return INVALID_ARG;
...
}

קבעת שהכתובת היא חוקית (שתשתמש בה) ולכן אתה לא אמור לבצע את הבדיקה הזאת
אלא רק את הבדיקה של i .

קוד:

if (p == p2+sizeof(T))

המקרה הזה לדעתי יתפקד נכון, בגלל שהמשפט:
null pointer, is guaranteed to compare
unequal to a pointer to any object or function.
הם אומרים זאת בגלל שהאופרטור & בחיים לא יחזיר NULL,
ולכן אין מצב שתקבל את הערך NULL בלי הצבה ידנית למצביע.

הקומפילר לא עוצר אותך לעשות

קוד:

unsigned char *c = 1; c--;
*c = 5;

המערכת הפעלה עוצרת אותך, אבל מקרים שאתה דיברת עליהם שום דבר לא יעצור אותך, לא?

Error: Keyboard not found

Press F1 to continue

האם הקוד הבא תיקני?

קוד:

int i = 300;

*i = 10;  // Setting value 10 in address 300
*(++i) = 11; // Setting value 11 in address 301
// and so on ...

כי אם כן, אז יהיה אפשרי להתייחס לכתובת 0 בזיכרון מבלי שתיווצר הגדרה אוטומטית של NULL, כפי ששמתי לב שזה בעייתי טיפה.

אם אני לא טועה הקוד הבא לא יתקמפל.. או יביא לשגיאת זמן ריצה.
הרעיון הוא שמצביע הוא סוג מיוחד אשר מוגדר בצורה של
type* ptr;
רק זה מצביע לעומת משתנה רגיל שמוגדר כ
type name;
משתנה רגיל הוא משתנה עם כתובת קבוע שלא ניתנת לשינוי (אם אני לא טועה). בשביל לקבל ערך של תשמנה רגיל משתמשים רק בשם שלו:
name = 10;
עכשיו הערך בתא שבו נמצא name יהיה 10. אם תרצה לקבל כתובת של name תצטרך לרשום משהוא כמו
printf("%x", &name); (הערה %X מדפיס מספר בצורה הקסה דצימלית)

מצביע לעומת זאת הוא לא משנה הוא כשמו מצביע, הוא לא יכול להכיל ערך משלו כי אין לו כתובת בזכרון (לא בדיוק נכון.. הוא תופס זכרון [2בתים נראה לי בלי קשר לטיפוס]). בשביל לפנות לכתובת של מבציע כותבים פשוט את השם שלו:
ptr = &name
בשורה הזאתי PTR מצביע על הכתובת שבו יושב name. כעת פניה הבאה:
*ptr = 10;
תשנה את הערך שאליו PTR מצביע, כלומר את name. כמו כן כבר בטח הבנת בשביל להתייחס לערך של מצביע יש להתשמש בכוכבית לפני השם.
זה קצת מסובך..

ציטוט:

במקור נכתב על ידי eXtruct מצביע לעומת זאת הוא לא משנה הוא כשמו מצביע, הוא לא יכול להכיל ערך משלו כי אין לו כתובת בזכרון (לא בדיוק נכון.. הוא תופס זכרון [2בתים נראה לי בלי קשר לטיפוס]). בשביל לפנות לכתובת של מבציע כותבים פשוט את השם שלו: ptr = &name בשורה הזאתי PTR מצביע על הכתובת שבו יושב name. כעת פניה הבאה: *ptr = 10; תשנה את הערך שאליו PTR מצביע, כלומר את name. כמו כן כבר בטח הבנת בשביל להתייחס לערך של מצביע יש להתשמש בכוכבית לפני השם.

אולי התכוונת שהפנייה:

קוד:

*ptr=10;

תשנה את הערך של המשתנה הרגיל name ל-10? (וכמו כן ישתנה הערך של המצביע ל-10, אבל עדיין המצביע והמשתנה name יצביעו לאותה הכתובת שלא הישתנתה בעיקבות הקוד הנ"ל).

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

תודה!

כן לזה בדיוק התכוונתי.
כעיקרון "הצבת" ערך למצביע משה את הערך של המשתנה אליו אותו מצביע מצביע.

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

תודה על התיקון!

אני רגיל להשתמש במצביע מסוג char ולכן שכחתי שזה אמור לקפוץ 2 או 4 בתים.

כפי ששמתי לב באתר c-faq, יש בעיה להשתמש במצביע ל-0 כאשר ה-0 הוא קבוע (כנראה הכוונה כאן ל-0 שכתוב בקוד עצמו).
הנה המקור לבעיה כולל פתרונות: http://c-faq.com/null/accessloc0.html

אתה לא יכול להשתמש באופרטור
* על משתנה שהוא לא מצביע.

אני יכול לחשוב על כמה דרכים להכניס את הערך 0 למצביע, אפשר כך:

קוד:

char *pointer;
memset(&pointer, 0, sizeof(char *));

או כך:

קוד:

char *pointer = 1; 
pointer--;

נגיד ואתה צריך מסיבה מסויימת להכניס לכתובת של הזכרון
300 את הערך
10
ולכתובת
301 את הכתובת
11

תעשה משהו כזה

קוד:

char *ptr = 300;
*ptr = 10;
*(++ptr) = 11;

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

קוד:

xdata at 0x0300 unsigned char data[2];
data[0] = 10; 
data[1] = 11;

שאומר המערך יאוכסן פיזית בכתובת
0x0300
אבל זה כבר מחוץ לסטנדרט.

Error: Keyboard not found

Press F1 to continue

ציטוט:

במקור נכתב על ידי maind נגיד ואתה צריך מסיבה מסויימת להכניס לכתובת של הזכרון 300 את הערך 10 ולכתובת 301 את הכתובת 11 תעשה משהו כזה קוד: char *ptr = 300; *ptr = 10; *(++ptr) = 11;

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

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

קוד:

type *p = value;

value תלוי ב-type כמובן. אם ה-type הוא char אז ה-value יכול להיות 'A'.

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

ד"א, הגבתי לבחור מעליך והוספתי קישור לאתר c-faq עם דרכים נוספות להגדרת מצביע לכתובת 0 ממש: http://c-faq.com/null/accessloc0.html
(ללא היפוכו האוטומטי ל-Null pointer)

תודה!

קוד:

char *a = 300;

מגדיר את המצביע a שמצביע לסוג char
ומאתחל את הכתובת של המבציע ל 300.


כאשר תרצה לשנות את מה שהמצביע מצביע אליו תשתמש באופרטור
* לצד השם של המצביע לדוגמא:

קוד:

*a = 'B';

מה שיציב בזיכרון בכתובת 300 את הערך 'B'

כידי לשנות את הכתובת של המבציע אחרי שהגדרת אותו
אתה עושה זאת על ידי שם המצביע ובלי שימוש ב *
לדוגמא

קוד:

 a = 400;

אשר משנה את הכתובת של המצביע ל 400 או

קוד:

 a++;

אשר מוסיף לכתובת 1

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

קוד:

char b = 'B';
char *p = &b; //returns a "char *" which points to b

עכשיו p מצביע לכתובת בה מאוכסן המשתנה b ולכן:

קוד:

printf("%c", *p);

ידפיס .B

האופרטור & מחזיר מצביע מהסוג שהעברת אליו
והמצביע שהוא מחזיר מצביע אל המשתנה שהעברת.

Error: Keyboard not found

Press F1 to continue

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

הסיבה לבילבול היא שמידי פעם ראיתי את השימוש במשפט כמו הבא:

קוד:

*ptr = 300;

בשני מובנים שונים.

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

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

הדרך היא להגדיר את הפונקציה Check_Something ש"תחזיר" ערך מסוג void

ולכן כך היא אולי תוכל להחזיר ערכים מכל המינים והסוגים, כולל null pointer וגם char אם אני לא טועה...?

דוגמא:

קוד:

#define NULL ((void *)0)

int main(void)
{
   // code ...

   if (Check_Something() == NULL)
      // bla bla...
}

void Check_Something()
{
     if (/*foo*/)
       return NULL;
     else
       return '1';
}

ד"א, יכול להיות שאני בכלל לא צריך להגדיר את NULL בקוד שלי, והמילה "NULL" מובנת אוטומטית ע"י הקומפיילר?

ברוב הקומפיילרים כבר יש הגדרה של NULL ואתה לא צריך להגדיר מחדש.

יש איזה קוד פרה-קומפילציה שבודק אם ההגדרה NULL קיימת?

קוד:

#ifndef NULL //If null is not defined...
printf("Null is not defined");
#endif

#ifdef NULL //If null is defined...
printf("Null is defined");
#endif

Error: Keyboard not found

Press F1 to continue

למה לך להחזיר NULL או 1?
תחזיר 1 או 0 ותעשה בדיקה

קוד:

if (Check_Something())

Error: Keyboard not found

Press F1 to continue

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

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

אתה סתם ממלא את הראש בדברים שכרגע אתה לא צריך..
NULL זה ערך אפס, מצביע לא מאותחל שלא מצביע לכלום. ככה בדיוק צריך להתייחס אליו.
דוגמא:
אתה מנסה להקצות מקום ופונקציה מחזירה לך פוינטר ל NULL, אז ההקצאה נכשלה, בדיקה פשוטה
if(ptr == NULL)
printf("Error out of memory!");

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

ציטוט:

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

תן דוגמא לפונקציה כזאת, ואז נמצא פתרון...

Error: Keyboard not found

Press F1 to continue

אתן לך דוגמא מ-PHP

קוד PHP:

 function getName($id)
{
  // Fetching the user name with SQL query, depending on the id...
  /* bla bla code... */

 if (!$user_name) // If didn't return a result (if $user_name is not a string...)
    return null; 
} 


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

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

קוד PHP:

 char *getName(int id)
{
/* MySQL code */
   if (any error occured) {
    return NULL
   }
} 


הראל

הנה, זו דוגמא לפונקציה שאני מניח שהיא די שימושית..

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

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

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

הראל

ציטוט:

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

כן אבל בהחזרת NULL מהפונקציה שמוגדרת כמצביע מסוג char, אתה כביכול מחזיר את הערך הבא:

קוד:

(char *)((type *)0)

שזה מצביע מסוג char למצביע null ...
האם כאן לא מתבטלת ההגדרה של Null?

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

Error: Keyboard not found

Press F1 to continue

לא הבנת כנראה את המשמעות של type, הכוונה היא שאת type אתה מחליף בסוג המשתנה הרלוונטי, לכן אתה מחזיר למעשה:

קוד PHP:

 (char *)0 


הראל

ציטוט:

במקור נכתב על ידי rlsf לא הבנת כנראה את המשמעות של type, הכוונה היא שאת type אתה מחליף בסוג המשתנה הרלוונטי, לכן אתה מחזיר למעשה: קוד PHP:  (char *)0

דוקא כן הבנתי

כידוע ההגדרה של NULL היא:

קוד:

(type *)0
// "type" may be: char, int, short, long, float, double, struct etc.

וכאשר אני כותב:

קוד:

char *test() { return NULL; }

זה שקול לכתיבת:

קוד:

char *test() { return (char *)0; }

או שקול לכתיבת:

קוד:

char *test() { return (int *)0; }

או באופן כללי יותר, שקול לכתיבת:

קוד:

char *test() { return (type *)0; }

וכפי שאני מבין זאת, הנ"ל שקולים לכתיבת:

קוד:

(char *)((type *)0)

כאשר type יכול להיות אחד מהבאים: int, short, char, long וכו'...

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

קוד:

*(test()) // equals NULL

לפי מה ששניכם אמרתם (אתה ו-maind), הבנתי לא נכון.
אז באיזה שלב טעיתי?

ההסקה האחרונה שלך לא נכונה, אתה מחזיר מצביע ל type כלשהו, ולא מצביע למצביע ל type כלשהו.
אגב, ב C משתמשים ב void * כדי לציין מצביע כללי ככה שנכון יותר לומר ש NULL הוא הפניה כללית למצביע כלשהו ריק אבל לא מצביע למצביע ריק.
אם אתה רוצה להסתכל על זה במבנה של שפת C, זה כנראה יהיה תיאור מתאים:

קוד PHP:

 (char *)0 = (void *)0 != (char *)((char *))0 


הראל

אהה הממ רגע, אחרי שאני כותב את התחביר הבא:

קוד:

(type *)var_name

אז למעשה כשאכתוב var_name, אקבל את הכתובת שהמצביע מצביע עליה?

ואז כשאני כותב:

קוד:

type *func_name() { return NULL; }

הביטוי NULL זה כתובת ריקה, ולאחר-מכן כשמתבצע ה-casting של הפונקציה, זה נהפך למצביע לכתובת ריקה שזה למעשה NULL !

כלומר:

קוד:

return NULL; // equals to "return 0;"

ואז מתבצע casting של הפונקציה בצורה הבאה:

קוד:

(type *)0

שזה למעשה ה-NULL שמוכר לנו!

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

הבנתי, תודה!

ניסיתי לעבוד עם ערכי NULL בצורות שונות.

זה הקוד שכתבתי והרצתי, וקיבלתי תוצאות מענינות:

קוד:

#include "stdafx.h"
#include <stdio.h>
#include <conio.h>

using namespace System;

#define myNull (void *)0 

int test(int);
char my(void);

int main(array<System::String ^> ^args)
{
	// Function

	printf("Checking NULL values via my():\n\n");

	if (my()==NULL)
		printf("We have a null!\n");
	else
		printf("BLAT\n");
	
	if (my() == '\0')
		printf("We have a terminate string char as null!\n");
	else
		printf("BLAT\n");

	if (my()== 0)
		printf("We have a 0 integer!\n");
	else
		printf("BLAT\n");

	if (!my())
		printf("We have a false expression!\n");
	else
		printf("BLAT\n");

	// Direct

	printf("\n\nChecking NULL values directly:\n\n");

	if (NULL == '\0')
		printf("We have a terminate string char as null!\n");
	else
		printf("BLAT\n");

	if (NULL == 0)
		printf("We have a 0 integer!\n");
	else
		printf("BLAT\n");

	if (NULL == ((void *)0))
		printf("We have a pointer to 0 as Null!\n");
	else
		printf("BLAT\n");

	if (!NULL)
		printf("We have a false expression!\n");
	else
		printf("BLAT\n");



	
	printf("\n\n NULL is (with my()):\nString:%s\nDecimal:%d\nFloat:%f\nChar:%c\n  Hex:%x\nPointer address:%p", my(), my(), my(), my(), my(), my());

	printf("\n\n NULL is (directly):\nString:%s\nDecimal:%d\nFloat:%f\nChar  :%c\nHex:%x\nPointer address:%p", NULL, NULL, NULL, NULL, NULL, NULL);

	printf("\n\n myNull is (via #define):\nString:%s\nDecimal:%d\nFloat:%f\nChar:%  c\nHex:%x\nPointer address:%p", myNull, myNull, myNull, myNull, myNull, myNull);

	_getch();
	return 0;
}

char my(void) { return NULL; }

בכל תנאי ה-if שבקוד יצא פסוק אמת (כלומר, לא היה כתוב "BLAT" אפילו פעם אחת.)

את הקוד כתבתי וקימפלתי עם התוכנה Visual Studio 2005, שזו תוכנה של מייקרוסופט כפי שידוע.
האם הקומפיילר שלה עומד בתקן ANSI C 99 ?

יש לי כמה שאלות על הדברים בקוד:

מה מכיל הקובץ "stdafx.h" ?
-------------------------
האם חובה לכתוב:

קוד:

using namespace System;

?
מה זה עוזר?
-------------------------
בהצהרה על הפרמטרים של הפונקציה main כתוב:

קוד:

array<System::String ^> ^args

הקוד הזה לא מוכר לי בכלל, Visual Studio הוסיף את זה בעצמו.
מה זה עושה בדיוק?
-------------------------
למה הפונקציה getch נחשבת לא-תקינה(deprecated)?
למה דווקא כדאי להשתמש בפיתרון של scripter שבאשכול ה-FAQ ?


תודה!

לא קשור ל-C99 ואפילו לא ל-C++‎ "רגיל".

זה רע?

מה זה managed C++ ?

הבנתי ש-C ו-C++ זה פחות או יותר אותו הדבר, רק ש-++C זה הרחבה של C (משהו בסיגנון..)

זה נראה לך קוד CPP רגיל:

קוד PHP:

 int main(array<System::String ^> ^args) 


מה זה System::String ומאיפה צצו כל ה-^^^^^ האלה?

ציטוט:

במקור נכתב על ידי rtasjugythh זה נראה לך קוד CPP רגיל: קוד PHP:  int main(array<System::String ^> ^args)  מה זה System::String ומאיפה צצו כל ה-^^^^^ האלה?

זה מה ששאלתי :|

איזו תוכנה מריצה קוד C רגיל, לפי תקן ANSI C 99 ?

אף אחד לא תומך ב-C99 לחלוטין, וכנראה שגם לא יתמכו בעתיד הקרוב.
סטטוס התמיכה ב-C99 ב-GCC לדוגמה: http://gcc.gnu.org/c99status.html

אז אילו תוכנות תומכות ב-C89/C90 מלבד תוכנות בסיגנון Borland .... ?

כל הקומפיילרים הגדולים, C89 מכונה גם בדר"כ ANSI C, ונתמכת ב GCC, VS ועוד.

הראל