אני מנסה לעשות דבר פשוט, אך מתקשה מפני ש C++ חדשה לי...

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

קוד:

int main()
{
	char string[] = "Hello";
	cout << strdup(string) << endl;
	return 0;
}
int strlen(char* str)
{
	int c = 0;
	while(*(str++) != '\0')
		++c;
	return c;
}
char* strdup(char* str)
{
	int len = strlen(str);
	int dlen = 2*len;
	char* dstr = new char[dlen];
	for(register int i = 0; i < dlen; i++)
		dstr[i] = str[i % len];
	return dstr;
}

והפלט הוא משום מה

ציטוט:

HelloHello²²²²▌▌ó0ף6לH☻

... אשמח לקבל עזרה.

אחרי הלולאה ב-strdup תוסיף את השורה הבאה:

קוד:

dstr[dlen]='\0';

אלפי תודות!

קוד:

[ursaminor]$ g++ testdup.cpp
[ursaminor]$ ./a.out
HelloHello

ראיתי את התשובה של RP, אבל לי זה לא קורה... אז למה זה קורה אצלך?

יכול להיות שאצלך במקרה בתו הבא בזיכרון יושב 0 (לא בלתי סביר בכלל), או שמערכת ההפעלה/קומפיילר דואג לזה.

כי כנראה שמור לך NULL בפוקס בתא האחד-אחרי-אחרון של המערך P:

שים NULL בסוף המחרוזת. אתה צריך גם לשחרר מתישהו זיכרון שהקצית.

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

לא, אין garbage collection ב-c++.

אז כך..
הנה לינק(2 שעורים) שממצאים פחות או יותר את עניין הזכרון בCPP.
http://www.cs.bgu.ac.il/~spl111/Pointers
http://www.cs.bgu.ac.il/~spl111/ConstDest

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

אתה לא יכול.
מה שאתה צריך זה לבנות קלאס string עם מתודה dupstring ושיהיה לו destructor שיקרא באופן אוטומטי ברקע שתצא מה-scope שבו הוגדר המשתנה.

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

קוד:

char *s=strdup(string);
cout<<*s<<"\n"<<;
delete [] s;

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

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

ציטוט:

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

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

מה גם שבאמת לא ממש הבנתי את כוונתו של RP..

ציטוט:

מה שאתה צריך זה לבנות קלאס string עם מתודה dupstring ושיהיה לו destructor שיקרא באופן אוטומטי ברקע שתצא מה-scope שבו הוגדר המשתנה.

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

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

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

קוד:

#include <iostream>
using namespace std;

int strlen(char* str)
{
	int c = 0;
	while(*(str++) != '\0')
		++c;
	return c;
}
char* strdup(char* str)
{
	int len = strlen(str);
	int dlen = 2*len;
	char* dstr = new char[dlen];
	for(register int i = 0; i < dlen; i++)
		dstr[i] = str[i % len];
	dstr[dlen]='\0';
	return dstr;
}
int main()
{
	char string[] = "Hello";
	char *s= strdup(string);
	cout << s << endl;
	delete [] s;
	return 0;
}

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

קוד:

int* mult(int fx[], int gx[])
{
	register int i, j;
	int res[] = {0, 0, 0, 0, 0};
	for(i = 2; i >= 0; --i)
		for(j = 2; j >= 0; --j)
			res[i + j] += fx[i] * gx[j];
	return res;
}

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

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

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

אנסה את הדרך השניה, תודה.

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

תקרא את שני הקשורים שכבר העלתי.
http://www.cs.bgu.ac.il/~spl111/Pointers
http://www.cs.bgu.ac.il/~spl111/ConstDest

עברתי על המקורות שנתת, (אגב תודה, זה באמת מעניין) ונתקלתי בקוד הבא:

קוד:

void ShapeCollection::Add(const Shape* shape)
{
    assert(Shape != 0);          // @pre
    if (0 == shape) return; // We could instead throw an exception
    shapes_.push_back(shape->Clone());
}

אני מבין מה assert עושה, אבל לא הבנתי מה בדיוק קורה פה.
care to explain please?

אני חושב שהשורה
if (0 == shape) return; //
הייתה אמורה להיות תחת הערה.. כלומר להסביר מה האסרט עושה, לדעתי פשוט מדובר בטעות..
כי אין סכוי שזה כלל יגיע לשורה הזו בגלל הassert.
מה שגם נאמר, שבמקום האסרט, והבדיקה, עדיף בכלל לזרוק אקספשין.

אה- אולי הבחור שכתב את הקוד הנ"ל לא סומך על assert.h והחליט ללכת על בטוח..

ציטוט:

במקור נכתב על ידי The_Equivocator אני חושב שהשורה if (0 == shape) return; // הייתה אמורה להיות תחת הערה.. כלומר להסביר מה האסרט עושה, לדעתי פשוט מדובר בטעות.. כי אין סכוי שזה כלל יגיע לשורה הזו בגלל הassert. מה שגם נאמר, שבמקום האסרט, והבדיקה, עדיף בכלל לזרוק אקספשין. אה- אולי הבחור שכתב את הקוד הנ"ל לא סומך על assert.h והחליט ללכת על בטוח..

גם אם כן, הוא בדק Shape != 0, ואני מניח שאין כוונה לבדוק את ה-type

אז בקיצור זו טעות בקוד ולא סתם משהו שלא ברור בכלל?

הוא בודק שהמצביע הוא לא NULL.

ציטוט:

במקור נכתב על ידי RP. הוא בודק שהמצביע הוא לא NULL.

תודה על המובן מאליו, אבל כמו שאתה רואה הוא רשם Shape ולא shape

אה זה, כנראה טעות...