האם הקומפיילר מחשב בברירת מחדל ביטויים מתמטיים של literal numbers ?
לדוגמא:

קוד:

int num = 1 + 2; // should be converted to 3 by the compiler

או שהקומפיילר משאיר את זה למעבד לחשב בזמן אמת?

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

נ.ב. שפת C

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

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

תודה.

אותו הדין בנוגע למחרוזת שהוגדרה ע"י define ?

קוד PHP:

 #include <stdio.h>

#define TTT 1+2

int main() {
    int i = 11;
    printf("%d\r\n", i*TTT);
    return 0;
} 


התכוונתי למשהו כזה:

קוד:

#define STR "hello world"

int main(void) {
	printf("The text %s and the text %s are similar", STR, STR);
return 0; }

אז מה שצפוי לקרות (עד כמה שאני יודע) זה שה-precompiler יציב את המחרוזת כך:

קוד:

	printf("The text %s and the text %s are similar", "hello world", "hello world");

וזה יגרום, אני חושב, לטקסט "hello world" להופיע פעמיים בקובץ הבינארי. אלא אם הקומפיילר מבצע אופטימיזציה מסוימת?

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

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

1. אתה לא מעביר לפונקציה מחרוזות, אלא מצביעים (char*‎), לכן זה מאוד הגיוני שתעביר פעמיים מצביע לאותו נתון, ולא תשכפל את הנתון פעמיים.
2. זה לא קשור ל-define בשום צורה האופטימיזציה הזו אמורה לקרות גם אם היית כותב את המחרוזות ישר. כמובן שאם יש לך מפתח קומפיילרים עצלן ברמות, אז ה-define כאילו מקל עליך א האופטימיזציה הזו, אבל ממילא אתה צריך לייצר את אזור ה-DATA של הבינארי שלך עם כל הקבועים, וכמעט לא עולה לך כסף למיין אותם ולראות שאין כפולים...

ציטוט:

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

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

ציטוט:

2. זה לא קשור ל-define בשום צורה

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

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

תודה לכם

ציטוט:

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

זו התשובה שחיפשתי...