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

[assaf990]

ואז על המערך בגודל הרצוי אני יעשה מה שארצה..

ניסיתי כך ויש לי הודעות שגיאה:

void array(int m)
{
	int array[m]={0};

}

[Boomerang]

מה אתה רוצה לעשות עם המערך הזה?

ב- C/C++ הפרמטר של גודל המערך צריך להיות קבוע בזמן קומפילציה.

כדי להקצות זיכרון אתה יכול להשתמש בפונקציות ממשפחת malloc (של C) או באופרטור new (של C++).

[assaf990]

לבנות מערך מהצורה הזו

1 בריבוע

2 בריבוע

3 בריבוע

.

.

.

N בריבוע

פחות חשוב:

ובגדול השאלה שלי היא זו:

נתונה כותרת הפונקציה check הבאה:

int check(int a[], int n, int m)

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

ידוע שהמערך a ממוין בסדר לא יורד.

הפונקציה עונה על השאלה הבאה:

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

השלם את גוף הפונקציה.

[Boomerang]

איך בדיוק m קשור לעסק?

מותר לך לשנות את המערך? אם כן - מראה לי שאתה יכול לעשות את זה בלי מערך נוסף.

[assaf990]

צירפתי קובץ וורד שיסביר

[attachment deleted by admin]

[Boomerang]

טוב, בדרך הקלה אתה באמת צריך להשתמש במערך בגודל m.

אין לי מושג איך לימדו אתכם לעשות את זה (new או malloc), אבל אבל בעצם יש לך מערך בגודל n שאתה יכול להשמש בו (אם m גדול מ- n אז יש לך חיים עוד יותר קלים)

[שניצל]

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

דרך ראשונה היא לעשות לולאה חיצונית שעוברת מ-1 עד m, ובודקת עבור כל ערך אם הריבוע שלו מופיע במערך a (באמצעות עוד לולאה).

הדרך הזו לא יעילה - (O(n^2, אבל היא אינה דורשת זכרון.

הדרך השנייה היא להקצות מערך בוליאנים בגודל m, כך:

bool *b = new bool[m];

ולאפס את כולו. אח"כ עוברים על a, ומסמנים את התאים שעוברים עליהם - נניח, אם מופיע ב-a המספר 9, נסמן true בתא השלישי ב-b (תא מספר 2, כמובן, כי הספירה מתחילה מ-0).

אח"כ אתה צריך לבדוק שכל התאים ב-b מכילים true.

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

delete b;

[BURTON]

אני חושב ששימוש ב-eval יהיה פיתרון טוב

[שניצל]

אה....

מה?

[Holy]

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

דרך ראשונה היא לעשות לולאה חיצונית שעוברת מ-1 עד m, ובודקת עבור כל ערך אם הריבוע שלו מופיע במערך a (באמצעות עוד לולאה).

הדרך הזו לא יעילה - (O(n^2, אבל היא אינה דורשת זכרון.

הדרך השנייה היא להקצות מערך בוליאנים בגודל m, כך:

bool *b = new bool[m];

ולאפס את כולו. אח"כ עוברים על a, ומסמנים את התאים שעוברים עליהם - נניח, אם מופיע ב-a המספר 9, נסמן true בתא השלישי ב-b (תא מספר 2, כמובן, כי הספירה מתחילה מ-0).

אח"כ אתה צריך לבדוק שכל התאים ב-b מכילים true.

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

delete b;

אם כבר אז

delete[] b;

[שניצל]

צודק, טעות שלי.

[BURTON]

אה....

מה?

תעשה חיפוש בגוגל לפונקציה eval :

[שניצל]

אני אחזור ואומר:

מה?

אני יודע מה זו הפונקציה eval... רק חבל שהיא לא קיימת ב-C++.

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

[BURTON]

אתה יכול להוריד ספרייה שמוסיפה את הפונקציה ל-C++

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

[Boomerang]

אתה יכול להוריד ספרייה שמוסיפה את הפונקציה ל-C++

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

עכשיו אני -

מה?!

אתה בטוח שאתה יודע על מה אתה מדבר?

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

ב- C++ אתה לא יכול בשום אופן להגדיר על ה- stack מערך בגודל שלא קבוע בזמן הקומפילציה.

אבל כמו שכבר אמרו קודם - אין שום בעיה להקצות אותו על ה- heap בעזרת new או malloc.