כיום למחשב יש המון זיכרון.

אני כל הזמן מתאמת עם זה עם חברים בעבודה

אני דוגל לעבוד עם זיכרון סטטי אפילו גדול (100K) למרות שלא ממש צריך את כולו

וזה יותר מסובך במשתנים ביותר מימד אחד

איזה חוק אצבע נכון לגבי זה.

תוכנה כתובה ב C++

תודה לכל העונים.

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

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

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

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

VECTOR ב STL לא נותן לך אינדקס לפי מה שזכור לי ...

אבל בכל אופן יותר ממימד אחד זה כבר מסבך את כל הסיפור.

VECTOR ב STL לא נותן לך אינדקס לפי מה שזכור לי ...

מה הכוונה?

בכל מקרה מערכים ווקטורים רב מימדיים זה מסובך.

מחלקות הtemplate ב-C++ פשוט מצויינות ונוחות.

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

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

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

דברים שני לגבי STL בפרוייקטים קטנים זה אחלה, הוא מהיר, נוח אבל ב Real-Time זה יכול להוות את צוור הבקבוק, כי כשאתה מקצה ומשחרר מאות אובייקטים בפרקי זמן קטנים הזכרון נהיה fragmented בסופו של דבר, דרך אחת לפתור את זה זה להשתמש ב allocators שכל container מציע. בכל מקרה אני נוהג לעשות typedef ל stl containers ולכתוב containers משלי רק כשזה באמת מהווה צוואר בקבוק. בכל שאר הפעמים אני מסכים עם תגובות מעלי למה לא להשתמש בווקטור?

שניצל, משתנים סטטיים (static) לא נמצעים על המחסנית, הם נמצאים ב-BSS או ב-DATA (או במקום אחר, תלוי בפלטפורמה ובמה שאמרת ללינקר).

בכל מקרה הם לא קשורים לגודל ה-stack.

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

קצרה היריעה לפרט, ולכן הנה רק כמה נקודות (לחלוטין לא ממצה):

* הזכרון למשתנים סטטיים מוקצה ע"י מ"ה כאשר היא מקצה זכרון לתוכנית, ולכן אם התוכנית רצה, ההקצאה לא נכשלה.

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

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

* בד"כ לא ניתן לשים משתנים סטטיים בקוד שאמור לרוץ מתוך ROM.

* קיימות פלטפורמות בהן הפניה למשתנה סטטי לפעמים יותר יעילה מלפנות למשתנה על ה-stack. מצד שני גם ההיפך עלול להיות נכון.

* פונקציות שמשתמשות במשתנים סטטיים הן לא reentrant בד"כ, וגם לא multithread safe ללא סנכרון נוסף.

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

בד"כ בתוכנה מודרנית למחשב מודרני עדיף לא להשתמש במשתנים סטטים סתם ללא סיבה. הם מייצרים בעיות מפתיעות ומגבילים reuse.

שניצל, משתנים סטטיים (static) לא נמצעים על המחסנית, הם נמצאים ב-BSS או ב-DATA (או במקום אחר, תלוי בפלטפורמה ובמה שאמרת ללינקר).

בכל מקרה הם לא קשורים לגודל ה-stack.

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

int arr[100000];

לעומת

int *arr = new int[100000];

ולא על static.

אה. אני אדיוט.