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

קוד:

#include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld = '9';    char num[2];    strcpy(num, ld);    printf("%s\n", num); }

המשתנה ld הוא char והפונקציה strcpy מצפה למחרוזת. לא הצלחתי למצוא דרך לעשות את ההמרה הזו למרות שבתחילה חשבתי שמדובר במשהו פשוט.

Anonymous :

אני מנסה להבין את הנושא של עיבוד טקסט והקצאות זיכרון דינאמיות ב-C, אבל נתקלתי בבעיה של המרה בין טיפוסי נתונים. למשל הקוד הבא: קוד: #include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld = '9';    char num[2];    strcpy(num, ld);    printf("%s\n", num); } המשתנה ld הוא char והפונקציה strcpy מצפה למחרוזת. לא הצלחתי למצוא דרך לעשות את ההמרה הזו למרות שבתחילה חשבתי שמדובר במשהו פשוט.

אני לא מאמין שאני עונה כאן.

קוד:

#include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld = '9';    char *num = malloc(2);    strncpy(num, ld, 2);    printf("%s\n", num); }

על הנייר זה אמור לעבוד (לא ניסיתי).

כן, זה לא עובד וניסיתי גם דברים כאלה .

קוד:

#include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld = '9';    char num[2];    strncpy(num, &ld, 1);    printf("%s\n", num); }

זה האק סביר בשביל שזה יעבוד. כאמור (על ידך) הפוקנציה strcpy מצפה למחרוזת, שזה בעצם מערך של char שבתא האחרון יש null. בגלל שאתה מייצג את ld כ char, אתה צריך להעביר את המצביע לתא הראשון במחרוזת (יש רק תא אחד, אז זה בעצם המצביע לchar) ובגלל שאין לך null בסוף המערך, אתה צריך להשתמש ב strncpy בשביל להגביל להעתקה של char אחד, כי אין לו null שיגיד לו מתי להפסיק.

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

קוד:

#include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld[2] = "9";    char num[2];    strcpy(num, ld);    printf("%s\n", num); }

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

מאוד פשוט: מחרוזת היא מערך של תווים שהתו האחרון שלו הוא 0. במקרה שלך:

קוד:

#include <stdio.h> #include <string.h> #include <stdlib.h> int main(void) {    char ld = '9';    char num[2];    num[0]=ld;    num[1]=0    printf("%s\n", num); }

או שיטה כללית יותר להמרה של כל דבר למחרוזת

קוד:

char ld='9'; char str[2]; snprintf(str,sizeof(str),"%c",ld));

זכרון. עבודה עם מחרוזות snprintf הוא ידידך הטוב ביותר

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

אתה חייב לשים null בסוף המחרוזת אחרת הוא ידפיס לך ג'בריש אחרי התו.
משהו כזה:

קוד:

num[1]='\0'

חוץ מזה למה לך להשתמש ב- strcpy פשוט תעשה num[0]=ld
וזהו.

אסף.

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

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

Anonymous :

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

תשמע, ניהול מחרוזות ב־C הוא לא מסובך אם אתה יכול להניח מגבלות על אורך המחרוזות. לדוגמה, אורך שם הקובץ עם 255 תווים (זו ד"א מגבלה אמתית).
להניח ששם של מישהו לא ארוך מ־100 תווים ועוד.

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

אבל **זכור** להשתמש ב־snprint במקום sprintf, להשתמש ב־strncpy במקום strcpy... כדי להבטיח שהקוד שלך יהיה בטוח מ־buffer overflow.

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

קוד:

char *file_read(const char *name) {    FILE *fp = fopen(name, "r");    char *pa = (char *) malloc(1);    char line[RSIZE-1];    int count = 0;    while (fgets(line, RSIZE, fp)) {       pa = realloc(pa, count += strlen(line));       strcat(pa, line);    }    return pa; }

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

ואני לא חושב שיש סיכוי לגלישת חוצץ בדוגמא הזו עם strcat לכן זה אני חושב שזה בטוח.

Anonymous :

ואני לא חושב שיש סיכוי לגלישת חוצץ בדוגמא הזו עם strcat לכן זה אני חושב שזה בטוח.

נכון, בדומה ספציפית לא... שוב, כשאתה יודע מה אתה עושה, לך על זה.

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

בכל אופן... אני הייתי כותב את זה כך:

קוד:

char *file_read(const char *name) {    char *ptr=NULL;    FILE *f=fopen(name,"r");    if(!f) return NULL;    fseek(f,SEEK_END,0);    size=ftell(f);    fseek(f,SEEK_SET,0);    if((ptr=calloc(size+1))==NULL)       goto error_exit;    if(fread(ptr,1,size,f)!=size)       goto error_exit;    fclose(f);    return ptr; error_exit:    fclose(f);    free(ptr);    return NULL; }

fseek יותר מהיר מ-fstat...?

ארתיום :

Anonymous : ואני לא חושב שיש סיכוי לגלישת חוצץ בדוגמא הזו עם strcat לכן זה אני חושב שזה בטוח. נכון, בדומה ספציפית לא... שוב, כשאתה יודע מה אתה עושה, לך על זה. לגבי הדוגמה שלך. נראה שזה די בסדר (במבט ראשון). מה שכן, לא חייבים להשתמש ב־gets אלא fread ועוד. בכל אופן... אני הייתי כותב את זה כך: קוד: char *file_read(const char *name) {    char *ptr=NULL;    FILE *f=fopen(name,"r");    if(!f) return NULL;    fseek(f,SEEK_END,0);    size=ftell(f);    fseek(f,SEEK_SET,0);    if((ptr=calloc(size+1))==NULL)       goto error_exit;    if(fread(ptr,1,size,f)!=size)       goto error_exit;    fclose(f);    return ptr; error_exit:    fclose(f);    free(ptr);    return NULL; }

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

ארתיום :

Anonymous : ואני לא חושב שיש סיכוי לגלישת חוצץ בדוגמא הזו עם strcat לכן זה אני חושב שזה בטוח. נכון, בדומה ספציפית לא... שוב, כשאתה יודע מה אתה עושה, לך על זה. לגבי הדוגמה שלך. נראה שזה די בסדר (במבט ראשון). מה שכן, לא חייבים להשתמש ב־gets אלא fread ועוד. בכל אופן... אני הייתי כותב את זה כך: קוד: char *file_read(const char *name) {    char *ptr=NULL;    FILE *f=fopen(name,"r");    if(!f) return NULL;    fseek(f,SEEK_END,0);    size=ftell(f);    fseek(f,SEEK_SET,0);    if((ptr=calloc(size+1))==NULL)       goto error_exit;    if(fread(ptr,1,size,f)!=size)       goto error_exit;    fclose(f);    return ptr; error_exit:    fclose(f);    free(ptr);    return NULL; }

זה כבר לא קונצנזוס ש goto זה קקה?

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

ציטוט:

זה כבר לא קונצנזוס ש goto זה קקה?

ממש לא. goto משמש אותך מצויין בכל הנושא של מימוש RAII. ואני אסביר בקצרה.

תסתכל בקוד הזה:

קוד:

int copy_file(char *in,char *out) {    /* Init resource handlers */    void *buffer=NULL;    FILE *f1=NULL,*f2=NULL;    int result=0; /* Error */            /* Start Processing */    if((f1=fopen(in,"r"))==NULL)       goto exit;    if((f2=fopen(out,"w"))==NULL)       goto exit;    if((buffer=malloc(BUFFER_SIZE))==NULL)       goto exit;    int n;    while((n=fread(buffer,1,BUFFER_SIZE,f1))>0)       if(fwrite(buffer,1,n,f2)!=n)          goto exit;    result = 1; /* OK */ exit:    /* Free resources */    if(f1) fclose(f1);    if(f2) fclose(f2);    free(buffer);    return result;    }

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

זאת השיטה המקובלת ב־C לעבוד עם משאבים. היא מבטיחה שחרור מרוכז של כל המשאבים האפשריים. זאת שיטה מסודרת ומגנה בפני memory leaks, זאת שיטה שמחליפה try/finally או ctor/dtor בשפות אחרות.

זאת ההצדקה היחידה והחשובה שקיום goto. כמובן אסור לעשות איתו לולאות ושאר דברים מוזרים. אבל הוא תחליף מצויין ל־try/throw/catch/finally בשפה ללא תמיכה מובנית בזה. בפועל, throw זה אותו goto רק שלפעמים הרבה יותר גרוע.

אגב, את השיטה הזו למדתי מ־coding style של linux kernel (אגב, מסמך מאוד מעניין ודי מצחיק)

ארתיום :

ציטוט: זה כבר לא קונצנזוס ש goto זה קקה? ממש לא. goto משמש אותך מצויין בכל הנושא של מימוש RAII. ואני אסביר בקצרה. תסתכל בקוד הזה: קוד: int copy_file(char *in,char *out) {    /* Init resource handlers */    void *buffer=NULL;    FILE *f1=NULL,*f2=NULL;    int result=0; /* Error */            /* Start Processing */    if((f1=fopen(in,"r"))==NULL)       goto exit;    if((f2=fopen(out,"w"))==NULL)       goto exit;    if((buffer=malloc(BUFFER_SIZE))==NULL)       goto exit;    int n;    while((n=fread(buffer,1,BUFFER_SIZE,f1))>0)       if(fwrite(buffer,1,n,f2)!=n)          goto exit;    result = 1; /* OK */ exit:    /* Free resources */    if(f1) fclose(f1);    if(f2) fclose(f2);    free(buffer);    return result;    } הוא עובד 100% בכל מקרה של שגיאה אפשרית. אם יש בעיה כלשהי, הוא יוצא. ומשחרר כל משאב שהוקצה, זכרון, קובץ ועוד. זאת השיטה המקובלת ב־C לעבוד עם משאבים. היא מבטיחה שחרור מרוכז של כל המשאבים האפשריים. זאת שיטה מסודרת ומגנה בפני memory leaks, זאת שיטה שמחליפה try/finally או ctor/dtor בשפות אחרות. זאת ההצדקה היחידה והחשובה שקיום goto. כמובן אסור לעשות איתו לולאות ושאר דברים מוזרים. אבל הוא תחליף מצויין ל־try/throw/catch/finally בשפה ללא תמיכה מובנית בזה. בפועל, throw זה אותו goto רק שלפעמים הרבה יותר גרוע. אגב, את השיטה הזו למדתי מ־coding style של linux kernel (אגב, מסמך מאוד מעניין ודי מצחיק)

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

בבקשה: http://www.kernel.org/doc/Documentation/CodingStyle

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

ארתיום :

בבקשה: http://www.kernel.org/doc/Documentation/CodingStyle אגב, קח את מה שלינוס כותב בקלות... לא חייבים להסכים עם כל מה שהוא אומר.

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

strncpy היא פונקציה מסוכנת כי במקרה של הגעה לגבול היא מעתיקה עד התווית האחרונה והמחרוזת שלך נשארת בלי NULL בסוף. snprintf עדיפה, לפיכך, והעובדה שמקרה כזה היא מחזירה את מספר התוויות *שהיו מועתקות* אילו לא היתה מגיעה לגבול, היא לפעמים שימושית.
באשר לgoto, דווקא יש לזה תחליף סביר ב-C, הנה הוא :

קוד:

int copy_file(char *in,char *out) {    /* Init resource handlers */    void *buffer=NULL;    FILE *f1=NULL,*f2=NULL;    int result=0; /* Error */     do {    /* Start Processing */    if((f1=fopen(in,"r"))==NULL)       break;    if((f2=fopen(out,"w"))==NULL)       break;    if((buffer=malloc(BUFFER_SIZE))==NULL)       break;    int n;    while((n=fread(buffer,1,BUFFER_SIZE,f1))>0)       if(fwrite(buffer,1,n,f2)!=n)          break ;    result = 1; /* OK */ } while (0) ;    /* Free resources */    if(f1) fclose(f1);    if(f2) fclose(f2);    free(buffer);    return result;    }

יש הרואים בזה סגנון רע אבל זה בהחלט עושה את העבודה.

אני לא חושב שזה יותר טוב מה-goto. שם זה גם מאוד ברור.

ותיקון קטן: כדאי גם לבדוק את ערכו של buffer לפני שמשחררים אותו.

צפריר :

ותיקון קטן: כדאי גם לבדוק את ערכו של buffer לפני שמשחררים אותו.

ציטוט מ־man 3 free

ציטוט:

If ptr is NULL, no operation is performed

לא צריך לבדוק את זה.

ארתיום :

צפריר : ותיקון קטן: כדאי גם לבדוק את ערכו של buffer לפני שמשחררים אותו. ציטוט מ־man 3 free ציטוט: If ptr is NULL, no operation is performed לא צריך לבדוק את זה.

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

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

פינגווין אדום :

strncpy היא פונקציה מסוכנת כי במקרה של הגעה לגבול היא מעתיקה עד התווית האחרונה והמחרוזת שלך נשארת בלי NULL בסוף. snprintf עדיפה, לפיכך, והעובדה שמקרה כזה היא מחזירה את מספר התוויות *שהיו מועתקות* אילו לא היתה מגיעה לגבול, היא לפעמים שימושית. באשר לgoto, דווקא יש לזה תחליף סביר ב-C, הנה הוא : קוד: int copy_file(char *in,char *out) {    /* Init resource handlers */    void *buffer=NULL;    FILE *f1=NULL,*f2=NULL;    int result=0; /* Error */     do {    /* Start Processing */    if((f1=fopen(in,"r"))==NULL)       break;    if((f2=fopen(out,"w"))==NULL)       break;    if((buffer=malloc(BUFFER_SIZE))==NULL)       break;    int n;    while((n=fread(buffer,1,BUFFER_SIZE,f1))>0)       if(fwrite(buffer,1,n,f2)!=n)          break ;    result = 1; /* OK */ } while (0) ;    /* Free resources */    if(f1) fclose(f1);    if(f2) fclose(f2);    free(buffer);    return result;    } יש הרואים בזה סגנון רע אבל זה בהחלט עושה את העבודה.

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

אסף.

האם זה יותר קריא? האם זה פחות מבלבל?

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

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

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

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

אסף