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

קוד:

typedef void* Element;
typedef struct list_rec* List;

קוד:

void removeTop (List list) {
    if ((!list)||(!list->n_elem)) {
        return;
    }
    list->lm_free(list->elem[list->n_elem-1]); 
    //assert (!list->elem[list->n_elem-1]);
    list->n_elem--;
}

קוד:

typedef int     (*cmpFunc)(Element,Element);
typedef Element (*cpyFunc)(Element);
typedef void    (*printFunc)(Element);
typedef void    (*freeFunc)(Element);

struct list_rec {
    Element     elem[MAX_LIST_SIZE];
    int         n_elem;
    cmpFunc     lm_cmp;
    cpyFunc     lm_cpy;
    printFunc   lm_print;
    freeFunc    lm_free;
};

קוד:

Element charCopy (Element e) {
    char *newChar=NULL;
    newChar=(char*)malloc(strlen((char*)(e))-1);
    assert (newChar);
    strcpy(new,((char*)(e)));
    return newChar;
}

קוד:

void charFree (Element e1) {
    if (e1) {
        free (e1); ///CRASH RIGHT AFTER THIS
    }
}

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

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

אם Element הוא *void האם סביר לבצע עליו strlen או strcpy?

נניח ש Element הוא אכן מחרוזת (רצף תוים ובסופו null) - למה אתה מוריד 1 מתוצאת strlen כאשר אתה מקצה שטח להעתיק עליו את האלמנט? אולי התכוונת להוסיף 1 לטובת ה null בסוף המחרוזת?

האם הקוד המצורף עובר קומפילציה? נראה לי שלא.

עובר קומפילציה מצוין...אני עושה casting ל-char* לפני שאני מבצע strlen ושאר פקודות על string, ככה שלא צריכה להיות עם זה בעיה.
לגבי ה"1-" - מסתבר שזאת היתה הבעיה או ככה זה נראה לפחות...

זה עובר קומפילציה?

קוד:

 
Element charCopy (Element e) {
	char *newChar=NULL;
	newChar=(char*)malloc(strlen((char*)(e))-1);
	assert (newChar);
	strcpy(new,((char*)(e)));
	return newChar;
}

כן, למה שלא יעבור?

1. הפונקציות מחרוזת, מניחות מערך עם NULL בתא האחרון של המחרוזת...
2. זה שמשהו עובר קומפילציה לא אומר שהוא אמור לעבוד
3. לא נהוג לתת INTים לתנאי
4. פעם הבאה תוסיף את כל הקוד הרלוונטי...
5. C זה שפת תכנות נוראית

ציטוט:

במקור נכתב על ידי hellfrost 1. הפונקציות מחרוזת, מניחות מערך עם NULL בתא האחרון של המחרוזת... אכן, זאת גם היתה הבעיה 2. זה שמשהו עובר קומפילציה לא אומר שהוא אמור לעבוד אף פעם לא אמרתי דבר כזה 3. לא נהוג לתת INTים לתנאי על איזה תנאי אתה מדבר? 4. פעם הבאה תוסיף את כל הקוד הרלוונטי... 5. C זה שפת תכנות נוראית אחלה...

קוד:

if ((!list)||(!list->n_elem))

אין לך איזה קומפיילר של C++?

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

אני ממליץ לך בחום לקרוא על
generic programming
iterators
ואלא אם כן אתה בקורס באוניברסיטה והקורס דורש C אני מציע לך בחום לעבור לC++

ציטוט:

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

1. שטויות. הן לא מניחות שיש תו '\0' בסוף המחרוזת, הן מניחות סה"כ שקיים תו כזה במקום כלשהו במחרוזת. וזאת לא בדיוק הנחה, אלא יותר תוצאה מכך שאין לפונקציה דרך סטנדארטית לדעת האם התו קיים במחרוזת מבלי שתהיה סיכון לגשת לזיכרון שלא שייך להקצאה של המחרוזת.

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

C pogrammers never die. They are just cast into void.

1. כשאני אומר בסוף המחרוזת אני לא מתכוון בתא האחרון במערך, אלה בסוף הטקסט כלומר:
"abc" הופך ל:
[a,b,c,\0]

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

5. אני אולי לא מתכנת בC, בעיקר כי אני לא מזוכיסט, אבל יצא לי לכתוב בכמה שפות, ולתחזק בעוד כמה שפות, מPASCAL ולאחרונה F#, ככה שאני חושב שאני יכול להשוות. בכל מקרה בכל שפת תכנות אפשר לכתוב כל דבר, בכל שפה שטורינג אישר לפחות, השאלה זה איך. נניח לC++ יש יתרון עצום על C בזה שהיא מאפשרת תכנות ג'נרי, גם תכנות OOP כמובן, מה שהופך בניית ADTים למשהו הרבה יותר פשוט וטבעי, וגם אופרטורים זה נחמד...

ציטוט:

במקור נכתב על ידי hellfrost אני אולי לא מתכנת בC, בעיקר כי אני לא מזוכיסט, אבל יצא לי לכתוב בכמה שפות, ולתחזק בעוד כמה שפות, מPASCAL ולאחרונה F#, ככה שאני חושב שאני יכול להשוות. בכל מקרה בכל שפת תכנות אפשר לכתוב כל דבר, בכל שפה שטורינג אישר לפחות, השאלה זה איך. נניח לC++ יש יתרון עצום על C בזה שהיא מאפשרת תכנות ג'נרי, גם תכנות OOP כמובן, מה שהופך בניית ADTים למשהו הרבה יותר פשוט וטבעי, וגם אופרטורים זה נחמד...

בהחלט, מנגנון הג'נריות של C++ הוא עצום(אפשר לראות את זה ב-STL, וכמובן הטכניקה של template meta-programming שבוסט השתלטתה עליה) חוץ מזה אני חושב שהפיצ'רים שלעצמם הם סתם משעממים, החיבור בניהם הוא מה שהופך את שפת C++ לחזקה. C++ תמיד היתה חזקה בנושא של Multi-paradigm programming. אם השפה שלך מספקת לך N פיצ'רים אבל מונעת ממך לתקשר ביניהם או להרכיב אחד את השני, אז זה די חלש, כי זה מונע ממך בעצם לשלב ולעשות עם זה דברים מתוחכמים יותר בקלות.

There are only two kinds of languages: the ones people complain about and the ones nobody uses

1. אני חושב שאני מבין איך strlen עובדת.

5. הבעיה שלי עם הנקודה הקודמת שלך היא פשוטה, יש תחומים שעדיין מפתחים לרוב עם C.
במערכת ההפעלה שבעזרתה כתבת את תגובה, סביר להניח שיש בה יותר קוד C מאשר C++.
ומה ב-embedded programming? הרי לא תחום קטן ... ורוב הקוד שתראה בתחום הוא ב-C.

עכשיו בנימה אחרת, ברור שהייתי מעדיף ליישם את רוב ה-ADT שהבחור ילמד בקורס ב-C++.
אלך רחוק יותר ואומר שרוב הדברים שאני כיום מפתח אני בוחר בשפה שמספקת לי יותר כלים מאשר C.

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

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

C pogrammers never die. They are just cast into void.

ציטוט:

במקור נכתב על ידי scripter 5. הבעיה שלי עם הנקודה הקודמת שלך היא פשוטה, יש תחומים שעדיין מפתחים לרוב עם C. במערכת ההפעלה שבעזרתה כתבת את תגובה, סביר להניח שיש בה יותר קוד C מאשר C++. ומה ב-embedded programming? הרי לא תחום קטן ... ורוב הקוד שתראה בתחום הוא ב-C.

אני חושב שה-embedded world הולך להיות התחום הגדול הבא של C++, בעיקר בגלל העוצמה ש-C++ מעניקה לך על ידי שימוש ב-templates, אבל זה די תלוי, הסיבה שבדרך כלל אנשים בוחרים לתכנת בשפת C במקום ב++C היא בעיקר בגלל שיש קומפיילרים ממש גרועים ל-C++, במקרה כזה זו באמת בחירה חכמה לתכנת ב-C. אך יש קומפיילרים טובים מאוד ל-C++ שמאפשרים לך אפילו ליצור קוד יותר טוב מאשר אם היית מתכנת ב-C

ציטוט:

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

כמו שאמרתי קודם, לא כותבים תוכנית רק על ידי שימוש ב-OO אלא משלבים בין כל הפרדיגמות שהשפה נותנת לך, וכאן ++C עוצמתית - תיכנות פרוצידורלי, תיכנות מונחה עצמים ותיכנות ג'נרי, אלו 3 מאוד גדולים, והשילוב בניהם הוא מה שמאפשר לך לכתוב תוכנית בצורה המתאימה והיעילה ביותר.

There are only two kinds of languages: the ones people complain about and the ones nobody uses

ציטוט:

ני חושב שה-embedded world הולך להיות התחום הגדול הבא של C++

אתה מדבר כאילו C++ שפה שהומצאה אתמול. ידידי, היא קיימת מעל 25 שנה ... 25 שנה היה ל-C++ זמן "לכבוש" את embedded.

ציטוט:

הסיבה שבדרך כלל אנשים בוחרים לתכנת בשפת C במקום ב++C היא בעיקר בגלל שיש קומפיילרים ממש גרועים ל-C++

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

ציטוט:

כמו שאמרתי קודם, לא כותבים תוכנית רק על ידי שימוש ב-OO אלא משלבים בין כל הפרדיגמות שהשפה נותנת לך, וכאן ++C עוצמתית - תיכנות פרוצידורלי, תיכנות מונחה עצמים ותיכנות ג'נרי

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

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

C pogrammers never die. They are just cast into void.

http://stackoverflow.com/questions/...2245362#2245362

אם כבר, strlen סופר כמה בתים יש עד 0\, לא כמה תווים... עיין ערך multibyte...

נמאס לכם לזכור סיסמאות? לחצו כאן!

לא מסכים. למיטב זכרוני זה sizeof(char)

אפשר ללכת לסטנדרט לבדוק....

ואתה טוען שיש מקום שבו sizeof(char) != byte ?

קוד:

$ grep CHAR_BIT /usr/include/limits.h
#  define CHAR_BIT      8

ולא לשכוח, זה חייב להיות char ולא wide char מכל סוג שהוא, כי הרי:

קוד:

STRLEN(3)                        Linux Programmer's Manual                       STRLEN(3)



NAME
       strlen - calculate the length of a string

SYNOPSIS
       #include <string.h>

       size_t strlen(const char *s);

[..]

CONFORMING TO
       SVr4, 4.3BSD, C89, C99.

SEE ALSO
       string(3), wcslen(3), wcsnlen(3)

נמאס לכם לזכור סיסמאות? לחצו כאן!

http://www.open-std.org/JTC1/SC22/W.../docs/n1256.pdf

זה נראה לי המסמך העדכני והכוללני...

6.5.3.4 The sizeof operator
Constraints

3 When applied to an operand that has type char, unsigned char, or signed char,
(or a qualified version thereof) the result is 1. When applied to an operand that has array
type, the result is the total number of bytes in the array.88) When applied to an operand
that has structure or union type, the result is the total number of bytes in such an object,
including internal and trailing padding

.

7.21.6.3 The strlen function
Synopsis
1 #include <string.h>
size_t strlen(const char *s);
Description
2 The strlen function computes the length of the string pointed to by s.
Returns
3 The strlen function returns the number of characters that precede the terminating null
character.


7.1.1 Definitions of terms
1 A string is a contiguous sequence of characters terminated by and including the first null
character. The term multibyte string is sometimes used instead to emphasize special
processing given to multibyte characters contained in the string or to avoid confusion
with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
character. The length of a string is the number of bytes preceding the null character and
the value of a string is the sequence of the values of the contained characters, in order.

חלק מזה חדש לי כן, C זה לא ה WEPON OF CHOICE שלי...

נדגיש את החלק החשוב, shall we?

ציטוט:

במקור נכתב על ידי hellfrost The length of a string is the number of bytes preceding the null character

נמאס לכם לזכור סיסמאות? לחצו כאן!

עד כמה שאני מבין את הסטנדרט, char חייב לכסות בדיוק את הטווח של 256 ערכים (0 עד 255 ללא סימן, 128- עד 127+ עם סימן). באופן פרקטי זה אומר שגודלו הוא 8 ביטים לפחות - אבל מותר שיהיה יותר. נובע מזה שמבחינה פיזית char עלול לתפוס 16 ביטים למשל, אבל תחום הערכים שבו מכסה רק את 127 או 255 התוים המוכרים (ASCII למיניו) וממילא wide char או unicode או utf8 וכדומה אינם נכללים.

בשביל להסתיר את הבעייה של אורכי תוים חובה אצלנו להשתמש במאקרו T_ סביב כל תו או מחרוזת, ככה שהקבועים הופכים למחרוזות 8 ביטים או 16 ביטים ע"פ פרמטר בשעת קומפילציה. כנ"ל כל פונקציות המחרוזות - אנחנו עוקבים אחרי השמות של מיקרוסופט כגון tcscpy במקום strcpy גם בקוד שמיועד ללינוקס או סביבות אחרות.

כן, מותר יותר ביטים לפי הסטנדרט. char הוא בייט אחד בהגדרה בכל מקרה (ולא משנה כמה ביטים זה יוצא - למרות ש 8 הוא מספר מקובל ברובן המוחלט של הפלטפורמות בעולם). לכן, כיוון ש strlen מקבל char, הוא יספור את מספר הבתים (ולכן, למשל, מחרוזת עברית שמקודדת ב utf-8 ואורכה 100 תווים, ממש לא תחזיר 100 שתעשה עליה strlen. כמדומני שהמספר שתקבל בחזרה יהיה 200...)

נמאס לכם לזכור סיסמאות? לחצו כאן!

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

שמת לב שאמרתי "מחרוזת עברית" ?

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

זו הייתה כל הנקודה שלי...

נמאס לכם לזכור סיסמאות? לחצו כאן!

אני חושב שאם תקח מחרוזת עברית ב ISO-8859-8 (שזה ASCII עברי) ותכניס למערך wchar_t הרי שבכל התוים הרחבים יהיה חצי עם אות עברית וחצי שני מאופס. במקרה כזה strlen יחזיר תמיד אפס או אחד (תלוי אם הייצוג בזכרון הוא ביג אנדיאן או ליטל אנדיאן).

ומוסכם שאין שום שימוש למידע הזה...

אבל אמרתי בפירוש utf-8...

נמאס לכם לזכור סיסמאות? לחצו כאן!