העברת מערך כפרמטר בלי אתחול משתנה:

אני מחפש לבצע משהו כזה:

קוד:

some_func( {0x01, 0x50, 0x41} );

במקום שאצטרך לעשות:

קוד:

char data[3] =  {0x01, 0x50, 0x41} ;
some_func(data);

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

אפשרי?

הפונקציה sprintf:

נניח יש לי את הקוד הבא:

קוד:

	float num1, num2;
	char *str;
	while(1)
	{
		my_func(&num1, &num2);
		
		sprintf(str, "Hi %5.2f World %5.2f !", num1, num2);
		
		puts(str);
		
		my_delay();
	}

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

כניסה לכתובת לא מוגדרת.
כניסה לכתובת לא מיושרת (misaligned address).

וזה קורה בפונקציה sprintf. אבל שוב לא יודע למה...

תודה מראש.

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

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

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

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

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

snprintf היא גרסא של sprintf שבודקת אורך ומחזירה את האורך הנדרש. אני לא בטוח שהיא קיימת בכל סביבה.

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

בנוגע ל- snprintf אבדוק, אבל יעזור גם פיתרון סטנדרטי במידה ומישהו מכיר.

תודה.

תמיד אתה יכול לספור מראש כמה תווים תצטרך המחרוזת להכיל, מהנקודה הזאת והלאה, נשארת עם malloc + sprintf.

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

הראל

ציטוט:

במקור נכתב על ידי rlsf תמיד אתה יכול לספור מראש כמה תווים תצטרך המחרוזת להכיל, מהנקודה הזאת והלאה, נשארת עם malloc + sprintf.

אוקי... חשבתי שיש דרך נוחה יותר.

בנוגע למשתנים אנונימיים - מה עם ++C ?

עד כמה שידוע לי, מתנהגת בדיוק כמו C מהבחינה הזאת, אבל אני לא מכיר אותה מספיק לעומק.

הראל

אוקי אז עוד שאלה על הדרך:

כתבתי:

קוד:

char data[3] = { ..., ..., ...};

func(&data);

//-----------

void func (char *data) { ... } 

והקומפיילר אומר משהו כזה:

ציטוט:

char(*)[3] incompatible with char*

מה זה משנה לקומפיילר מהו גודל הבלוק שהמצביע מסוג char מצביע אליו?

לבסוף עשיתי casting ועבד טוב, הקריאה נכתבה כך:

קוד:

func( (char*) &data);

ב C וגם ++C שם המערך הוא בעצם מצביע לאלמנט הראשון. לכן אתה יכול לכתוב:

קוד PHP:

 func(data); 


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

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

טוב תודה!