נתון הקוד:

קוד:

#include <stdio.h>
#include <conio.h>
#include <string.h>
// here starts the functions

int main()
{
char s1[15];
char s2[15];
char s3[15];
printf ("enter 3 strings: ");
fgets(s1, 15, stdin);
fgets(s2, 15, stdin);
fgets(s3, 15, stdin);
strcat( s1, s2);
strcat( s1, s3);
printf ("%s ", s1);
getch();
return 0;
}

הוא אמור לקבל קלט של 3 מחרוזות מהמשתמש ולהדפיס , לדוגמא:
קלט מהמשתמש:
hello
world
again
פלט:
hello world again
משום מה התוכנית מדפיסה לי
hello
world
again

איפה טעיתי? הקוד הגיוני לא? קודם משרשר את 1 ו2 ואז את התוצר שלהם עם 3?

עכשיו מספר שאלות להבנה יותר מעמיקה:

קוד:

strcat( s1, s2, s3);

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

2. קוד אחר:

קוד:

char input[256];
int i;

fgets( input, 256, stdin );

for ( i = 0; i < 256; i++ )
{
    if ( input[i] == '\n' )
    {
        input[i] = '\0';
        break;
    }
}

אמור לתת שורה חדשה כל פעם שהמשתמש מכניס \n אבל זה לא עובד אלא מדפיס את \n כחלק מהסטרינג, מדוע?

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

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

5. כשמבקשים מהמשתמש להקליד 3 מחרוזות, אחת הדרכים היא ליצור 3 מחרוזות נפרדות. האם ניתן ליצור בדרך אחרת מחרוזת אחת דו מימדית 3 על *מס' תווים? האם זה נחשב ל-3 מחרוזות נפרדות?

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

Bad Spellers Unite!

הבעיה היא כיוון ש-fgets משאירה את התו של השורה החדשה, כלומר ברגע שהמשתמש לוחץ על Enter אז אמנם הקלט נפסק, אבל הפונקציה משאירה את התו הזה במחרוזת. אתה יכול פשוט להסיר אותו אם אתה רוצה (ע"י מציאת המקום האחרון במחרוזת והחלפת ה-\n ב-\0).

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

תודה על תשובה מהירה,

ניסיתי להסיר כמו שרשמת, בדומה לקוד שרשמתי למעלה, שממיר את \n ל\0 אבל זה לא פתר לי את הבעיה, מה שקורה עכשיו' בפלט מופיעה רק המילה הראשונה של המחרוזת ושתי המילים האחרות לא מופיעות.

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

לא מובן לי למה לא הודפסה השורה של s3 וs2 כי מילא, נגיד הצלחתי למחוק את התו הריק בסוף המחרוזת זה היה צריך להדפיס לי כמו בהתחלה את
s2
s3
לא?

לגבי חלק 2 של תגובתך,

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

Bad Spellers Unite!

איך ניסית להסיר? נראה לי שהבעיה שם.

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

קוד:

#include <stdio.h>
#include <conio.h>
#include <string.h>
// here starts the functions

int main()
{
char s1[15];
char s2[15];
char s3[15];
printf ("enter 3 strings: ");
fgets(s1, 15, stdin);
fgets(s2, 15, stdin);
fgets(s3, 15, stdin);
strcat( s1, s2);
strcat( s1, s3);
int i;
for ( i = 0; i < 15; i++ )
{
    if ( s1[i] == '\n' )
    {
        s1[i] = '\0';
        break;
    }
}
printf ("%s ", s1);
getch();
return 0;
}

יכול להיות שטעיתי אבל בלולאה התייחסתי רק למחרוזת הראשונה, כי מבחינתי כבר שירשרתי בה את שתי המחרוזות האחרות, יכול להיות שהתפיסה שלי שגויה?

קוד:

char input[256];
int i;
int x=1;
printf ("enter a string, to end press 'p'\n");
fgets( input, 256, stdin );
while (x!='p'){
      printf ("to end press 'p'.\n");
        scanf("%d", &x);
for ( i = 0; i < 256; i++ )
{
    if ( input[i] == '\n' )
    {
        input[i] = '\0';
        break;
            }
          }
        }

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

שיחקתי עם שתי השורות של:

קוד:

printf ("to end press 'p'.\n");
        scanf("%d", &x);

ניסיתי למקם אותם בכל מני מקומות בתוך לולאת הwhile וגם בfor אבל לא הצלחתי... לצערי.

עכשיו שאלה כללית,

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

Bad Spellers Unite!

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

קוד:

scanf("%s", s1)

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

קוד:

printf("used <strcat> on s1 and s2, the result is %s\n", s1)

למשל.

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

אלו דקויות קטנות, אל תתייאש.

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

ציטוט:

במקור נכתב על ידי fritz2 עוד בעיה, היא שהקצת רק 15 תווים למחרוזת, ואתה מנסה לדחוס יותר תווים (אל תשכח שגם רווח, גם שורה חדשה, וגם סיום מחרוזת הם תווים). נסה דרך פשוטה יותר עם קוד: scanf("%s", s1) צודק אבל קראתי שיש בעייתיות עם scanf בכל הנוגע למחרוזות והרבה יותר בטוח להשתמש בfgets גם בגלל שמצויין שם גודל המחרוזת. וצודק הייתה לי שם טעות וגלשתי מעבר למוקצב, אילו בעיות לדוגמא זה יוצר בתוכנה? על כל פנים, גם כשאני לא גולש מעבר למוקצה, (15) התוכנה עדיין לא עובדת, יש דרך לגרום לה לעבוד גם עם מה שעשיתי? והגדל את אורך המחרוזת הסופית לבערך 32 תווים רק ליתר ביטחון. כדי לדבג בצע הדפסה אחרי כל פעולה, וממש תרשום לעצמך מה ביצעת קוד: printf("used <strcat> on s1 and s2, the result is %s\n", s1) למשל. וכן, סי, ובעיקר סטרינגים שהם לא דאטה טייפ שמובנה בשפה, הם מקור לבעיות. גם באקדמיה (שם למדתי את השפה) מתקשים בדיוק בנושא הזה, כי סטרינג זה כבר עולם של פוינטרים ומערכים (הפונקציה strcat למשל, מחזירה פוינטר לchar). אלו דקויות קטנות, אל תתייאש.

לא מתייאש.
פשוט רוצה ללמוד בצורה טובה את החומר ולהצליח בבעיות, אני פשוט חושב שמקור החומר והתרגילים שלי שגויים, יש הצעות לדברים אחרים? ועברתי על לנקיית הפורום ובגוגל.
לא אכפת לי שיהיה באנגלית אבל לא טכני כמו מדי כמו המדריך של sun לjava.. אלא יותר user friendly

Bad Spellers Unite!

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

אני מתאר לעצמי שכבר קראת את זה, אבל הדוגמאות כאן מצויינות:
http://www.cprogramming.com/tutorial/c/lesson9.html

נסה לקמפל ככה:

קוד:

gcc -Wall <filename.c>

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

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

ציטוט:

במקור נכתב על ידי fritz2 שתי הפונקציות שקולות ברגע שאתה מקבל קלט מה stdin. אם הסטרינג נקלט כמו שצריך, אז scanf תחזיר אינטג'ר "1". אני מתאר לעצמי שכבר קראת את זה, אבל הדוגמאות כאן מצויינות: http://www.cprogramming.com/tutorial/c/lesson9.html נסה לקמפל ככה: קוד: gcc -Wall <filename.c> (בהנחה שאתה משתמש בשרת יוניקס כלשהו), וזה ידפיס לך את כל האזהרות מלבד השגיאות.

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

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

אגב הקוד שרשמת, gcc - wall מה זה אומר? זה קשור ללינוקס?

מצטער על החוסר ידע המובהק...

Bad Spellers Unite!

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

נחזור לסעיף הראשון, אתה לא יודע לעשות רקורסיות בסיסיות, פונקציות פשוטות מבלי לעשות טעיות סינטקטיות, ולוגיות, למה אתה חש צורך לקפוץ בכלל לספריות של מחרוזות?!
אתה בכלל מבין מה זה "מחרוזת", ז"א, איך בשפת C, מיוצגת מחרוזת?

ציטוט:

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

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

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


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

Bad Spellers Unite!

לא מדוייק.

קוד:

char *str1 = "Hello World";
char str2[SIZE];

אל המחרוזת הראשונה אתה יכול לגשת לקרוא, אבל לא לכתוב. כמו מערך str[0] ='H' אבל אתה לא יכול לשנות את התוכן שלה.
בהגדרת מחרוזת בתור מערך אתה חייב לציין כמה תווים אתה מקצה למערך (והוא יוכל לקלוט את מספר התווים שציינת + 1 עבור 0\). על מערך כזה אתה יכול לעשות מניפולציות.

מחרוזות דורשות גם ידע בניהול זיכרון (פונקציית malloc() למשל) ואריתמטיקה של פוינטרים.
a[i] = i[a], למשל. זו שטות גמורה להשתמש בזה, אבל זה נכון.

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

המחרוזת הראשונה שרשמת היא בעצם מצביע למחרוזת str1 והזנת את הערך שלה להיות "..."(מה שכתוב). לא? כי כשאתה כותב למצביע, אתה בעצם כותב ישירות לכתובת הזיכרון של מה שמוצבע? בעצם יכול לשנות תוכן. כי עם מצביע אתה יכול:
1. לראות כתובת בזיכרון של כל דבר.
2. להכניס ערך.
3. מקווה שאני לא מפשל יותר מדי.. מקסימום אצור מצביע לשם משתמש אחר ואף אחד לא יידע שזה אני


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

עדיין מנסה להבין:
a[i] = i[a]
הסבר יוערך מאוד.

מערך בשם a שיש לו כמות של i ערכים?
ואז מערך בשם i עם כמות ערכים של a?
מה ההגיון פה? אפשרי בכלל? ומה מתקבל מזה?

Bad Spellers Unite!

המשתנה הראשון שהגדרתי הוא מסוג מצביע ל-char, והוא מצביע לכתובת בה מאוחסן התו הראשון.
דוגמאות קוד לגישה:

קוד:

char *str1 = "abc";
printf("%s %s", str1, str1 +1);
Output: abc bc

שמת לב מה קרה? כשאמרתי לתוכנית להדפיס את str +1 המצביע קודם באחד, ואז זה החזיר את ערך המחרוזת עד הסוף.
כדי להדגיש עוד קצת:

קוד:

printf(%c %c", "abc"[1], *("abc" + 2));
Output: b c

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

כדי להגדיר מערך של אותיות (סטרינג) שתי ההגדרות הבאות שקולות:

קוד:

char s[] = {'a', 'b', 'c', '\0'};
char s[] = "abc";

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

קוד:

for (i = 0; i < SIZE; i++) printf ("%d ", a[i]);

for (i = 0; i < SIZE; i++) printf ("%d ", *(a + i));

int *pa = a; for (i = 0; i < SIZE; i++) printf ("%d ", *(pa++));

for (i = 0; i < SIZE; i++) printf ("%d ", i[a]);

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

קוד:

a[i] = *(a + i)
i[a] = *(i + a)

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

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

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

Bad Spellers Unite!

זה פשוט שקול לקוד הבא..

קוד:

const char str[12]={"Hello World"};

לא אחי. זה לא.
בדוק את זה: http://ideone.com/3Tl2k
וקרא כאן: http://c-faq.com/ptrs/index.html וכאן: http://c-faq.com/aryptr/index.html וכאן: http://c-faq.com/charstring/index.html

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

קוד:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
	char* str1="abc";
	char* str2="def";

	str1=str2;
	puts(str1); /* prints def */
	return EXIT_SUCCESS;
}

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

מאוד לא יעיל.
ברגע שהפנית את str1=str2 איבדת יכולת לגשת למחרוזת "abc" ואתה מבזבז זכרון.
מה שהיה עדיף שתעשה הוא

קוד:

strcpy(str1,str2);

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

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

ציטוט:

מאוד לא יעיל.

זה לא משנה, זו דוגמה שסותרת את מה שאמרתי מקדום, שישנה שקילות..

כהערת אגב..

קוד:

strcpy(str1,str2);

זה משהו שאתה לא יכול לעשות..

אתה טועה.

קוד:

prototype:	  char *strcpy (char *s1, const char *s2);

The string s2 is copied into s1 until (and including) the character '\0'
Whatever exists in s1 is overwritten
It is assumed that s1 has enough space to hold the result
The value s1 is returned

פשוט, קל ועובד יופי.

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

נו אז תקמפל ותריץ..

קוד:

int main(void) {
	char* s1="abc";
	char* s2="def";

	//prototype:	  char *strcpy (char *s1, const char *s2);
	strcpy(s1,s2);
	return 0;
}

עובד יופי, שכחת להוסיף כנראה שני דברים.

קוד:

#include <string.h>
...
...
...
printf("%s\n", s1);

Output: def

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

צר לי להגיד זאת, אך באופן מפתיע, אדון אקוויבוקטור צודק.
אצלך, במקרה, הקוד הזה עבד. לפי התקן, התוצאות הן undefined.
הנה, תראה מה קורה כאן: http://ideone.com/yoolD

הסיבה היא ש-string literals נשמרים (אולי) באזור סטטי של הזיכרון, שעשוי להיות read-only.
דוגמה נפוצה היא שקבועים כאלה נשמרים ב-‎.rodata (כלומר, read-only data), משתנים גלובאליים נשמרים ב-‎.data, והקוד נשמר ב-‎.code או ‎.text - כל אלה שמות של section-ים (או סגמנטים) ב-executable.

המשתנה s1 מצביע לזיכרון שהוא לקריאה בלבד, וכך גם s2. ברגע ש-strcpy מנסה לכתוב לזיכרון הזה, התוכנה עפה (על SIGSEGV בלינוקס, כמו בלינק, או על AV בווינדוס).

מצוין גם פה: http://c-faq.com/decl/strlitinit.html

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

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

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

זה אפילו יותר גרוע מתלוי-מכונה. הנה החלק הרלבנטי מהתקן:
http://stackoverflow.com/questions/...6143043#6143043

המשפט החשוב הוא:

The effect of attempting to modify a string literal is undefined.

ב-C יש מספר סוגים של התנהגות-שלא-מוגדרת-לגמרי. ההסברים עליהם כאן:
http://c-faq.com/ansi/undef.html

כשאומרים "תלוי-מכונה", הכוונה לדוגמה לגודל של unsigned long int. האם זה 32 ביט? האם זה 64 ביט? זה תלוי-מכונה, אבל זה צריך להיות מתועד על ידי הקומפיילר שבו אתה משתמש, וכל עוד אתה עובד במסגרת שהוגדרה לך, הכל יהיה בסדר.

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

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

Some compilers have a switch controlling whether string literals are writable or not (for compiling old code), and some may have options to cause string literals to be formally treated as arrays of const char (for better error catching).

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

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

הבנתי, תודה על ההסבר המפורט.

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

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

פשוט מאוד, כל פעם שאתה מתאחל פוינטר להצביע ל-string literal, תגדיר אותו כקונסט:

const char * str1 = "Hello";

עכשיו, לא תצליח לכתוב אליו בטעות: http://ideone.com/84IAp

הקוד לא מתקמפל, כי strcpy רוצה שהפרמטר הראשון (dst) יהיה char *‎, אבל אני מעביר אליו const char *‎. אם תקמפל את זה ב-C באתר שהבאתי תראה שהקוד עובר - זה באג מטומטם שמאפשר להמיר באופן שקוף מ-const ללא-const (למיטב זכרוני, באג בשפה ולא בקומפיילר). עדיין יש באג ב-C++‎ שלא מחייב אותך להגדיר את המצביע ככה, אבל אם תגדיר את המצביע ככה, לא תצליח להעביר אותו לפונקציה כמו strcpy בטעות.

אם אתה רוצה להעתיק מחרוזות (strcpy), לשרשר מחרוזות (strcat) או לעשות כל דבר אחר איתן שיש בו כתיבה ולא רק קריאה, כל מה שאתה צריך לעשות זה או

• להשתמש במערך אמיתי

או:

• להקצות זיכרון שניתן לכתיבה (באמצעות malloc).

הקוד הבא משתמש במערך, ועובד מצוין: http://ideone.com/h3PfC
הקוד הבא מקצה את הזיכרון דינאמית, וגם עובד מצוין: http://ideone.com/Y5P4i

אין בעיה במצביעים ל-char. הבעיה יכולה להיות רק במקום אליו הם מצביעים.
אם היית מגדיר משתנה בסגנון char * str1 = (char*)0x12345678 ומנסה לעשות אליו strcpy, היית מופתע שזה קורס?
זה פחות או יותר אותו דבר - המצביע שלנו הצביע לזיכרון שלא הקצנו ואסור לנו לכתוב אליו. אולי במקרה בכתובת 0x12345678 יש בלוק זיכרון שבדיוק הקצנו ב-malloc הקודם ולכן זה יפעל, ואולי לא...




בקשר לשאלה שהוספת:

מצביע ל-char ומערך של char-ים אלה דברים שונים.
לעומת זאת, כשמעבירים לפונקציה מערך של char-ים הוא מתנוון למצביע ל-char הראשון במערך.
הפרקים על מצביעים, מערכים ומחרוזות ב-c-faq.com יענו לך על כל השאלות האלה.

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

הבנתי. הסברים ודוגמאות מצויינים. תודה.

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

הדוגמה שנתתי מצוינת, כי היא מדגימה בצורה הפשוטה ביותר את העובדה הפשוטה שב-C מערך != מצביע, אפילו שיש אנשים שמתבלבלים וחושבים ש"מערך זה תמיד מצביע" או משהו כזה...

הדבר היחיד שיותר טוב מהדוגמה שלי הוא להפנות לסעיפים הרלבנטיים ב-ISO/IEC 9899:1990, אבל זה כבר לא דוגמה בכלל, אלא הגדרה.