אם sizefo (int) = 4

אז זה אומר שכל מספר int ייכנס במערך char באורך 5? (האחרון ל- null)

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

int a = 123465;
char str [5];
itoa(a, str, 10); //error

אתה בטוח שיש פונקציה itoa ? אני יודע שיש atoi אבל לא להפך. תבדוק.

SIZEOF מחזיר את הגודל בבתים.

sizeof(int) מחזיר 4, מכיוון שהגודל של INT הוא 4 בתים(32 ביטים שנשמרים בזיכרון).

המספר המקסימאלי הוא 2^32 = 4 גיגה.

אתה צריך מחרוזת שיכולה להכיל מס תווים שמציין 4 גיגה, כלומר, 10. עוד מקום אחד ל\0 הופך ל- 11.

ד.א. לא כדאי להשתמש בITOA. תשתמש בsprintf.

ד.א. אתה לא משתמש נכון בפונקציה. הפרמטר האחרון הוא של הבסיס שאתה רוצה להמיר אליו - 2, 10, 16.

int a = 123465;
char str[11];
itoa(a, str, 10);

או

int a = 123465;
char str[11];
sprintf(str, "%d", a);

במקרה הזה מספיקה לנו גם מחרוזת באורך 7(כולל ה\0), מכיוון שהמספר 123465 בעל 6 ספרות. לא תמיד זה המספר, ולכן לקחתי את המקרה הגרוע ביותר. אם ידוע לך שהמספר יהייה תמיד בעל X ספרות או פחות, תגדיר את המחרוזת שלך כך שתהייה באורך X+1.

אני מבולבל

אם INT זה 4 בתים אז מדוע זה לא כולל את המקרה הגרוע ביותר? מדוע לא מספיק מערך של 5 char? כלומר לא הבנתי את היחס בין העובדה ש גודל של INT הוא 4 בתים ובין המקרה הגרוע ביותר של INT שזה 2^32.

במילים אחרות: ולמה המספר הכי גדול ב INT הוא צריך לתפוס 4 גיגה? או למה אני צריך מערך גדול שיתפוס לי 4 גיגה היינו את כל האופציות של INT?

וגם לא הבנתי מדוע עדיף להשתמש ב sprintf (אגב, בשני הפונקציות נותן לי הקומפיילר "אזהרה" שלא השתמשתי בסינטאקס הנכון)

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

sizeof(char)

אתה צריך לשמור מס ספרות כמספר הספרות שיש במספר(בבסיס עשרוני), ולכן אתה צריך לדעת כמה ספרות יכולות להיות במספר שלך.מספר הספרות הכי גדול הוא 10(4,000,000,000+ זה גיגה). כלומר, אנחנו צריכים לשמור 10 charים, כל אחד מהם ייצג ספרה במספר.

כפי שנשרשם בתראד אחר, צריך להשתמש בSTRINGSTREAM:

int myNumber = 123465;
stringstream ss;
ss<<myNumber;

const char *str = ss.str().c_str();

הבנתי את ההסבר

כעת לא ברור לי: אז מדוע גודל של int הוא רק 4 בתים ולא כגודל המספר הכי גדול?

דבר שני: לא הבנתי את עניין ה STRINGSTREAM. מדוע חובה להשתמש בו? מה רע ב sprinf לבדו?

שני דברים:

א) stringstream הוא type safe - תמיד יופעל הקוד המתאים לטיפוס שצוין. לא ניתן לקלוט קלט לטיפוס הלא נכון.

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

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

4 בתים = 32 ביטים בייצוג בינארי. כלומר, 32 ספרות.

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

המידע נשמר במחשב בבסיס בינארי, ואני מעוניינים לראות אותו בבסיס עשרוני.

אתה יכול לכתוב את הייצוג הבינארי למחרוזת, ואז תצטרך 33 תאים(לא לשכוח את ה\0 בסוף).

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

http://www.drpaulcarter.com/

באתר ה זה יש TUTORIAL מצויין ו 20 העמודים הראשונים הם דברים שכל מתכנת חייב לדעת.

לא הבנתי איך ממירים מ float ל char[] וההפך.

...מסתכלים על הת'רד שפתחת לפני שבוע?

http://hwzone.co.il/community/index.php?topic=274997.0

שניצל אחי הסתכלתי, והתוצאות:

א. יש שם הצעה לא בטוחה להמרה ( מתכון לבאגים)

ב. לא מוסבר איך ממרים מ char[] ל float

לכן אני מבקש עזרה

תנסה את זה:

#include <stdio.h>

void main()
{
  float f;
  char* p = "1.234";
  sscanf(p,"%f",&f);
  printf("%f",f);
}

זה מוסיף כמה אפסים "מיותרים" 1.234000 במקרה הזה.

אסף - ואללה, צודק. יש רק מ-float ל-char[].

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

הפתרון של ktbnus יעבוד, אגב.