אני רוצה נגיד לשלוח לפונקציה שרשור. הנה מה שאני מתכוון:

ההצהרה:

int f(char* str);

השליחה:

char c='a';
f(c + ".k");

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

אתה חייב להשתמש ב strcat ב C.

[עריכה]

נראה לי שטעיתי בפונקציה, רק רגע..

[עריכה ב']

נראה לי שאין ב string.h פונקציה שעושה מה שאתה רוצה בדיוק.

strcat עושה את זה בידיוק.

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

הפונקציה תעתיה את המחרוזת השניה אל סוף הראשונה.

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

אני משתמש בBORLAND

אני לא צריך שתעתיק לי לסוף הראשון, אני צריך לתחזיר מחרוזת חדשה משורשרת..

עשיתי אותה כבר..

דרך אגב איך אני יודע שהתוכנית לא תעלה על המחרוזת בעתיד (אני מחזיר מצביע)

תיצור פונקציה שמשתמשת בMALLOC כדי להקצות את הזיכרון ובSTRCPY וSTRCAT או SPRINTF כדי להעתיק את המידע. שים לב שעבור 3 הפונקציות האחרונות, כדאי להשתמש במקבילות שלהן עם הפוסטפיקס _s כדי להיפתר מהWARNING במקרה הזה.

הסיומת _s קיימת (למיטב ידיעתי) רק ב-Visual C, ולא ב-borland.

אגב, להבא:

http://www.cppreference.com/stdstring/index.html

גרסאות _s קיימות רק אצל גרסאות מסויימות של visual studio.

אם אני מבין מה שאתה רוצה, אתה מעוניין פונקציה שמקבלת מחרוזות A ו-B ומחזירה מחרוזת חדשה שהיא שרשור של A+B, נכון?

char* Concat( const char* a, const char* b)
{
  if ( a == NULL || b == NULL ) return NULL;
  char *new_str = malloc( strlen(a) + strlen(b) + 1 );
  if ( new_str == NULL ) return NULL;
  strcpy( new_str, a);
  strcat( new_str, b);
  return new_str;
}

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

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

חשבתי יותר על הכיוון הזה

char* strshr(char c, char* str)
{
	char* string;
	int i;

	string[0]=c;

	for(i=1;i<=strlen(str);++i)
		string[i]=str[i-1];
	string[i+1]='\0';
	return(string);
}

זה נועד למשהו מאוד ספציפי (אות ומחרוזת שני תווים).

אני יכול לסמוך על זה שהתוכנית לא תעלה על המקום הזה?

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

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

זה נועד למשהו מאוד ספציפי (אות ומחרוזת שני תווים).

אני יכול לסמוך על זה שהתוכנית לא תעלה על המקום הזה?

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

בהתחלה לכלום. אבל אחרי זה אני מציב לתוכו ערכים..(לא יהיה מצב בתוכנית שלי שישלחו NULLים). איך אני משפר את זה?

לבנתיים זה עובד לי.

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

לא כי אני צריך להחזיר את זה ולא לשמור את זה בפרמטר..

בכלל הגדרת מצביע לתו אחד

אני לא רוצה שהוא יצביע לאותו תו.. רק שיעתיק את ערכו.

אבל אתה לא מציב לתוכו עריכם.

הגדרת את string כשהוא מצביע ל-char. כרגע יש בו ערך אקראי, כלומר הוא מצביע למקום (כנראה) לא קיים בזכרון.

כשאתה מנסה לגשת אליו ככה:

string[0]

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

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

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

ב. שהפונקציה תקבל פרמטר נוסף מטיפוס *char, שמצביע למערך שכבר הוקצה מראש.

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

למה אני לא יכול להגדיר מערך של CHARים אלה רק להקצות? ונגיד שאני מציב בו ערך ראשוני או משהו.

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

תודה על הסבלנות ;D

אתה יכול להגדיר מערך של char ככה:

char string[10];

אבל יש לך כמה הגבלות:

א. הגודל שלו חייב להיות קבוע וידוע מראש, כלומר הקוד הזה לא תקין:

int n = 10;
char string[n];

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

char* myfunc() {
 char result[10];
 // some code here
 return result;
}

אההה בגלל זה, זה לא עבד לי ככה LOL

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