מה היא עושה?

(ככה כתוב בספר

void reverse(char*)
{
	int c,i,j;

	for(i=0, j=strlen(s)-1; i<j; i++. j--)
	{
		c= s[i];
		s[i]=s[j];
		s[j]=c;
	}
}

void itoa(int n, char *s)
{
	int i, sign;

	if((sign =n)<0)
	{
		n=-n;
		i=0;
		do
		{
			s[i++] = n%10+'0';
		}
		while(n/=10)>0;

		if(sign<0)
		{
			s[i++]='-';
			s[i]='\0';
			reverse(s);
		}
	}
}

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

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

הבעיה ב-itoa של הספריה הסטנדרטית היא שהיא משתמשת ב-buffer סטטי עבור המחרוזת, ולכן לא בטוחה ל-multithreading.

...זה אמור להיות תלוי מימוש, לא?

כלומר אם המפתחים של קומפיילר מסוים (שכולל חבילה סטנדרטית משלו, אני מניח) רוצים, הם יכולים לעשות את הפונקציה thread-safe.

אני אמורה לכתוב אותה בשפת MIPS, ולכן רציתי להבין כיצד היא פועלת.

למה צריך את reverse?

...זה אמור להיות תלוי מימוש, לא?

כלומר אם המפתחים של קומפיילר מסוים (שכולל חבילה סטנדרטית משלו, אני מניח) רוצים, הם יכולים לעשות את הפונקציה thread-safe.

לא בקלות. הפונקציה מקבלת int ומחזירה מצביע למחרוזת סטטית. זה כבר מקשה על מימוש MT-safe. באופן עקרוני אני מניח שאפשר להשתמש ב-thread local storage או בשיטה דומה על מנת לוודא ש-itoa יכולה להקרא בו זמנית ממספר thread-ים, אבל אני ממש מסופק שמישהו עושה את זה. באופן מעשי itoa היא פשוט לא mt-safe. על snprintf שמעתם?

שירה: צריך את reverse כי הלולאה בונה את המחרוזת בסדר הפוך: מהספרות הנמוכות אל הגבוהות ולבסוף את הסימן.

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

ITOA לא מחזירה פשוט את הפוינטר ששלחו לה?

ד.א. אני חושב שכבר לא משתמשים בה(או שזו הייתה ATOI?).

לא מבינה איך זה עובד!

כתבתי תכנית שתשתמש בפונקציות הנ"ל:

void main()
{
	char string[10];

	ita(123,string);

	cout<<string;

	getche();
}

ועברתי עליה עם דיבגר, אבל זה עושה

 sign =n

(בIF) ואז יוצא מהפונקציה ITOA

אשמח להסבר

כמו שאמרתי, יש באגים בפונקציה.

(ספציפית, היא תעבוד רק אם n הוא שלילי...)

הנה גרסה מתוקנת:

void reverse(char* s)
{
	int c,i,j;

	for(i=0, j=strlen(s)-1; i<j; i++. j--)
	{
		c= s[i];
		s[i]=s[j];
		s[j]=c;
	}
}

void itoa(int n, char *s)
{
	int i, sign;

	if((sign =n)<0)
	{
		n=-n;
	}
	i=0;
	do
	{
		s[i++] = n%10+'0';
	}
	while(n/=10)>0;

	if(sign<0)
	{
		s[i++]='-';
	}
	s[i]='\0';
	reverse(s);
}

ITOA לא מחזירה פשוט את הפוינטר ששלחו לה?

ד.א. אני חושב שכבר לא משתמשים בה(או שזו הייתה ATOI?).

נכון, היא מחזירה את הפוינטר ששלחו לה (חשבתי שהייתי ברור כשאמרתי "מחזירה את אותו המצביע").

תגדיר "לא משתמשים בה"... אני יודע שהקומפיילר של VS2005 דורש להשתמש ב-_itoa במקום itoa, או בגרסה הבטוחה שלו, _itoa_s (שמונעת buffer overflow).

כמובן שאם אתה עובד ב-C++, אז הפתרון העדיף (מבחינת השפה, לא מבחינת פשטות) הוא להשתמש ב-stringstream.

התכוונתי לDEPRACATED.

התבלבלתי בין itoa לבין פונקציה אחרת. מצטער.

מה שכן, היא לא פורטבילית. itoa אינה חלק מ-ANSI C אלא תוספת.

לפחות תמיד יש את sprintf או snprintf (עדיף).