ראיתי פעם כזה דבר
void *pixels;
מה הכוונה פה בעצם? הרי void זה כלום, ריק, שום דבר אז איך אפשר ליצור משתנה מסוג void?
האם ניתן באותה צורה לכתוב גם (מבחינת סיטקסס ולוגיקה של התוכנה)
void anc;
void *func()
מה זה יבצע בעצם?

תודה מראש.

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

בברכה, נעם בריקמן

noam906@walla.co.il

סאשה הסוס, סוכן אוסינט.‏

Noam906
את זה אני יודע לכן כתבתי ספציפית void *finc()
אם כוכבית כלומר מצביע.

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

טיפוס VOID* הוא מצביע שיכול להצביע על כל דבר, בניגוד למצביע מסוג CHAR* , למשל, שיכול להצביע רק על טיפוס מסוג CHAR.

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


בכל מקרה - אתה צריך לזכור שמצביע בסה"כ מחזיק כתובת בזיכרון.

מקווה שההסבר והדוגמא עזרו.

כלומר אני יכול להגיד פונקציה ככה
void func(void *var);
ולזמן אותה ככה:

int abc;
func(abc);
וגם
char bcd;
func(bcd);
וגם
float cde;
func(cde);
וכל אלו יהיו חוקיים? וזה יעבוד רק במקרה והפונקציה יודעת לטפל בסוגי משתנים שונים, נכון?
אן כן אז למה void* עדיף על function overload?

כמו כן אני יכול לעשות גם ככה:

void *abc;
*abc = 10;
or
*abc = 's';
or
*abc = 3.1415;
וגם כל אלה יהיו חוקיים?

תודה שוב.

סורי טעות שלי :X
כלומר אני יכול להגיד פונקציה ככה

קוד:

 void func(void *var);
ולזמן אותה ככה:

 
int abc;
func(abc);
וגם
char bcd;
func(bcd);
וגם
float cde;
func(cde);

 
   void *abc;
*abc = (int *)10;
or
*abc = (char *)'s';
or
*abc = (float *)3.1415;

בסי אין overloaded functions והטיפוס void בא מסי.
void היה מעין template למשתנים בסי.
בסי++ כבר לא ממש משתמשים בvoid כי יש דברים אחרים כדי לעשות את העבודה.
תקנו אותי אם אני טועה

המנגנונים שקיימים עבור המפתח ב C++ אמורים לעזור לך להימנע משימוש במצביע VOID* בהינתן שבנית עץ הורשה נכון טוב.

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

אם אתה מגיע למצב ב C++ שאתה צריך VOID* אתה צריך אולי לשאול את עצמך האם הDESIGN שלך נעשה בצורה טובה ונכונה.

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

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

קוד PHP:

 void func(void *param) {
...
}

////////////////////////////////////////

char *str = "foobar";
func(str);

int x = 100;
func(&x); 


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

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=27/04/1986]

ציטוט:

במקור נכתב על ידי eXtruct סורי טעות שלי :X כלומר אני יכול להגיד פונקציה ככה קוד: void func(void *var); ולזמן אותה ככה: int abc; func(abc); וגם char bcd; func(bcd); וגם float cde; func(cde); וכל אלו יהיו חוקיים? וזה יעבוד רק במקרה והפונקציה יודעת לטפל בסוגי משתנים שונים, נכון? אם כן אז למה void* עדיף על function overload? כמו כן אני יכול לעשות גם ככה: קוד: void *abc; *abc = (int *)10; or *abc = (char *)'s'; or *abc = (float *)3.1415; וגם כל אלה יהיו חוקיים? תודה שוב.

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

קוד:

 void func(void *var);
ולזמן אותה ככה:

  int abc;
func(&abc);
וגם
char bcd;
func(&bcd);
וגם
float cde;
func(&cde);

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

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

מציע לך לקרוא את פרק מס' 5 ב K&R ואני בטוח שהכל יהיה הרבה יותר ברור אחרי שתקרא שם.

טעות שלי זה היה אמו להיות int *abc

danben אני מציע לך לא לשפוט אנשים מהר מידי יש לי מספיר ידע בסי ובמצביעים ואני כמו כל בן אדם רגיל רשאי לעשות טעות אז טעיתי כתבתי int abc במקום int *abc זה לא אומר שאני לא יודע את הנושא.
השאלה סך הכל הייתה איך אפשר ליצור טיפוס נתונים מצביע מסוג void כאשר void זה בעצם כלום, פשוט אני לא רגיל ליצור משהוא מכלום לכן שאלתי, זה לא אומר שאני לא יודע מה זה מצביע.

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

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

סרטוני הנהיגה שלי

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=29/04/1987]

ויש שימוש במצביעים כאלה.
פשוט היום פחות משתמשים ישירות ב-API של מערכת ההפעלה, יש כל מיני דברים שעוטפים את זה. כמו #Java, C וכו'...

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=27/04/1986]