זקוק לעזרה, לולאות While וSwitch Case בC.

[Stoned Junglist]

הבעיה שלך היא בלולאה הפנימית: נגיד והמשתמש מכניס תו תקין בין 0 ל 9 ו error נשאר n אבל c לא שווה ל \n ואתה נתקע בלולאה אינסופית.

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

השאלה היא האם אתה רוצה לקלוט רק ספרה אחת או מס' שלם? ומה אתה רוצה לעשות אם נקלט תו לא תקין (לקלוט חדש, לעשות משהו אחר)?

אני רוצה לקלוט ספרה אחת.

אבל- במקרה והמשתמש מקליט יותר מספרה אחת לשלוח אותו לקלוט מחדש, ובמקרה של תו לא תקין לקלוט מחדש.

בנוסף, אם הוא נכנס לאחד מהcasים ( 1 , 2, 3) אז שיפעיל את מה שבפנים ויבקש קלט חדש לאחר שיבצע את מה שבתוך הCASE.

בקיצור, הדרך היחידה לסיים את הלולאה היא במקרה והמשתמש יקליד 4.

תודה.

עריכה- קצת ערכתי את הפונקציה , אבל שוב חזרתי לשתי באגים קטנטים:

1) זה קולט יותר מתו אחד , אבל מתייחס רק לתו הראשון...=עבור 23

lol2lol3error

2) זה משום מה עושה לולאה על הERROR's וגורם לזה להדפיס יותר מפעם אחת..

#include <stdio.h>
int main()
{
 char c,error='y',e='y';
 int selection=0;
 while(e=='y'||error=='y')
 {
 error='0';
 selection=0;
 scanf("%c",&c);
 e='n';
 error='n';
 if(c>='0' && c<='9')
  selection=10*selection+c-48;
 else
  error='y';
 switch(selection)
 {
     case 1:printf("lol1");e='y';break;
     case 2:printf("lol2");e='y';break;
     case 3:printf("lol3");e='y';break;
     case 4:printf("lol4");e='n';break;
     default:printf("error\n");e='y';break;
 }
 }
}

[k-o-b-y]

הבעיה היא כנראה בגלל שכשאתה מכניס תו ואז לוחץ על האנטר, נקלטים בעצם שני תווים: התו שהכנסת ו \n (התו לירדת שורה). בגלל שהקלט מתבצע ל buffer (שלא מתנקה אחרי קריאה ל scanf/getchar), בפעם השניה שהלולאה מתבצעת נקלט התו \n שנשאר מהפעם הקודמת ולכן מודפס עוד error. אתה יכול לקרוא על זה ולראות את הפתרון לזה כאן:

http://www.gidnetwork.com/b-60.html

[Stoned Junglist]

הבעיה היא כנראה בגלל שכשאתה מכניס תו ואז לוחץ על האנטר, נקלטים בעצם שני תווים: התו שהכנסת ו \n (התו לירדת שורה). בגלל שהקלט מתבצע ל buffer (שלא מתנקה אחרי קריאה ל scanf/getchar), בפעם השניה שהלולאה מתבצעת נקלט התו \n שנשאר מהפעם הקודמת ולכן מודפס עוד error. אתה יכול לקרוא על זה ולראות את הפתרון לזה כאן:

http://www.gidnetwork.com/b-60.html

תודה רבה.

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

לפי הכתבה הוספתי את c!='\n' לתנאי של הWHILE , ושינתי את הקליטה לgetchar() .

אולי כדאי לאתחל את המשתנה בסוף הלולאה?

[k-o-b-y]

ניסית להחליף את השורה:

scanf("%c",&c);

ב:

c = getchar();
while (getchar() != '\n');

?

כי מה שהלולאה אמורה לעשות זה לנקות את ה buffer של הקלט ולכן אחרי ה-2 שקלטת ה-3 וה-\n אמורים "להתנקות".

[Stoned Junglist]

ניסית להחליף את השורה:

scanf("%c",&c);

ב:

c = getchar();
while (getchar() != '\n');

?

כי מה שהלולאה אמורה לעשות זה לנקות את ה buffer של הקלט ולכן אחרי ה-2 שקלטת ה-3 וה-\n אמורים "להתנקות".

תודה רבה.!

ממ יש לי בעיה קטנטונת.

בתוכנית אחרת- אני צריך לקלוט מספרים עד @, אך כל רווח מפריד בין מספר למספר אחר (67 78), ופה הבעיה שלי כי למרות שעשיתי IF לרווח, התוכנה לא מקשיבה ומחברת את הרווח =\. איך אני מצליח להדפיס מספר ראשון בנפרד ומספר שני בנפרד?

#include <stdio.h>
#include <math.h>
int main()
{
 double sum=0,num=0,count=0,num1=0,num2=0; 
 char ch,error;
 do
 {
  ch=getchar();
  if(ch<'0'||ch>'0')
  {
  error='n';
  num=num*10+ch-48;
  printf("%.2lf\nnum\n",num);
  }
  else if(ch=='0')
  {
  error='n';
  num=num*10+0;
  printf("%.2lf\nnum\n",num);
  }
  else if(ch==0x20)
  {
  error='n';
  num=0;
  ch=48;
  }
  else
  {
  error='y';
  printf("error");
  }
 sum=num1+sum;
 }
 while(ch!='@'||error=='y');
 printf("%.2lf\nsum\n",sum);
}

[k-o-b-y]

יש לך בעיה בif הראשון: כל עוד הוא לא '0' הוא יכנס אליו, מה שאומר שגם רווח יכנס לשם, גם \n, גם @ והם גם יתווספו לסכום.

גם אין צורך להתייחס בנפרד ל '0' הרי ה ascii שלו הוא 48 ככה ש ch-48 יוצא 0 ואתה לא מוסיף כלום ל num.

אז בסה"כ תחליף את התנאי הראשון ב ch<='9'&&ch>='0' ותוותר על ה else if שבודק את ה 0.

עוד משהו קטן זה שאתה מוסיף ל sum את num1 ולא את num למרות שאתה לא מציב כלום ב num1.

אבל יש בעיה אחרת: כרגע אחרי כל ספרה שאתה קולט את מוסיף את המס' ל sum מה שגורם לזה שהסכום לא יצא נכון, כי לדוגמה אם המשתמש הכניס את המס' 75 אתה בהתחלה מוסיף 7 ואז 75 לסכום. אתה צריך להוסיף את num לסכום רק כשהגעת לתו שהוא לא ספרה (מה שאומר שסיימת לקלוט את המס' הנוכחי).

[Stoned Junglist]

יש לך בעיה בif הראשון: כל עוד הוא לא '0' הוא יכנס אליו, מה שאומר שגם רווח יכנס לשם, גם \n, גם @ והם גם יתווספו לסכום.

גם אין צורך להתייחס בנפרד ל '0' הרי ה ascii שלו הוא 48 ככה ש ch-48 יוצא 0 ואתה לא מוסיף כלום ל num.

אז בסה"כ תחליף את התנאי הראשון ב ch<='9'&&ch>='0' ותוותר על ה else if שבודק את ה 0.

עוד משהו קטן זה שאתה מוסיף ל sum את num1 ולא את num למרות שאתה לא מציב כלום ב num1.

אבל יש בעיה אחרת: כרגע אחרי כל ספרה שאתה קולט את מוסיף את המס' ל sum מה שגורם לזה שהסכום לא יצא נכון, כי לדוגמה אם המשתמש הכניס את המס' 75 אתה בהתחלה מוסיף 7 ואז 75 לסכום. אתה צריך להוסיף את num לסכום רק כשהגעת לתו שהוא לא ספרה (מה שאומר שסיימת לקלוט את המס' הנוכחי).

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

עכשיו הבעיה אצלי היא שהתוכנית צריכה לגמור לקלוט קלט ברגע שch=='@' שהיא חיברה את המספרים עכשיו זה לא מממש הולך ככה כי התוכנה רואה את @ כERROR משום מה, וגם קולטת את ה/n ואז למעשה מביאה לי 2 ERRORים ולא מסיים את התוכנית ולמעשה מבקש עוד קלט חדש.

להלן הקוד:

#include <stdio.h>
int main()
{
 double sum=0,num=0,count=0;
 char ch,error;
 do
 {
  ch=getchar();
  if(ch<='9'&&ch>='0')
  {
  error='n';
  num=num*10+ch-48;
  }
  else if(ch==0x20)
  {
  sum=num+sum;
  printf("%.2lf\n",sum);
  error='n';
  num=0;
  ch=48;
  }
  else
  {
  error='y';
  printf("error");
  }
 }
 while(ch!='@'||error=='y');
}

דוגמא= קלט:@ 65 45 (משמאל לימין)

45.00

110.00

errorerror(קו התוכנה מבקש קלט חדש, לולאה אינסופית)

====

[k-o-b-y]

מה שקורה זה עבור כל תו שהוא לא ספרה ולא רווח הוא נכנס ל else האחרון ומדפיס "error", גם אם התו הוא @.

כמה דברים:

- אין צורך להציב כל פעם 'n' ב error מספיק להציב בו 'n' לפני הלולאה ופשוט להציב 'y' כשיש שגיאה.

- אין צורך להציב 48 ב ch הרי זה ידרס גם ככה בתחילת הלולאה הבאה כי את מציב את getchar() ב ch.

- בקשר לתנאי של הלולאה: כמו שהלולאה כתובה כרגע, הבדיקה אם ch!='@' בתנאי של הלולאה מיותרת, הרי גם במקרה שנקלט @ הוא עובר דרך ה else האחרון. אבל התנאי עצמו בעייתי, הוא אמור היה להיות משהו כמו ch!='@' && error='n', הרי אתה רץ כל עוד אין שגיאה, לא כל עוד יש שגיאה.

- גם כשנקלט @ אתה צריך להוסיף לסכום את המס' הנכחי, יכול להיות ש @ היה צמוד למס' האחרון (למשל 65 70@).

- עדיף להדפיס את הסכום רק כשנקלט @ ולא הייתה שגיאה, ולא אחרי כל מס'.

- יש לך משתנה מיותר בשם count של השתמשת בו.

סידרתי את הקוד קצת אחרת, תנסה את זה:

double sum=0,num=0;
char ch, shouldEnd = 'n';
do
{
	ch=getchar();

	if(ch<='9' && ch>='0')
		num=num*10+ch-48;
	else 
	{
		sum += num;
		if(ch==0x20)
			num=0;
		else 
		{
			shouldEnd='y';
			if (ch == '@')
				printf("%.2lf\n",sum);
			else
				printf("error\n");
		}
	}
}
while(shouldEnd == 'n');

[Stoned Junglist]

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

לדוגמא : a 24 52 @

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

בעיה נוספת: היא שבמקרה של -13 13 14 @ הוא יכתוב לי ERROR , בגלל התו - , אז אינני יכול לקלוט למעשה מספרים שלילים. =\

[k-o-b-y]

לגבי המצב של הקלט שגוי, פשוט תכניס את השורה shouldEnd='y'; לתוך if (ch == '@') כדי שהלולאה תסתיים רק במקרה של קליטת @. אם אתה רוצה לאפס לגמרי את הכל כשיש שגיאה אז ב else האחרון, איפה שאתה מדפיס את ה "error", תאפס את המשתנים שאתה רוצה.

לגבי ה '-' (מינוס) צריך להתייחס לזה במיוחד, בשני מובנים:

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

- בזמן ההוספה של ספרה חדשה: אתה יכול לעשות את זה בכל דרך שתרצה. אפשרות אחת למשל היא בזמן שאתה מוסיף ספרה, אתה בודק אם המס' שלילי (בעזרת המשתנה שהגדרת). אם הוא חיובי אתה מכפיל את num ב 10 ומוסיף (ch-48), בדיוק כמו שאתה עושה עכשיו. אבל אם המס' שלילי אתה צריך להכפיל בעשר ולחסר ממנו (ch-48). לדוגמה, נגיד והמס' צריך להיות שלילי (קלטת מינוס) וקלטת את הספרה 5. num הוא 0, תכפיל אותו ב10 ותחסר 5 תקבל -5. נגיד והספרה הבאה היא 7, הכפלת -5 ב 10 קיבלת -50, חיסרת 7 תקבל -57.

אפשרות אחרת להשאיר את num כרגיל בזמן ההוספה של הספרות ורק בסיום הקליטה של המס' לבדוק אם הוא שלילי (בעזרת המשתנה שהגדרת). במידה וכן אז תחסר את num מ sum (במקום להוסיף) או תכפיל את num ב -1 לפני ההוספה ל sum.

[Stoned Junglist]

תודה על הערות הבונות =].

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

להלן הפונקציה אם אתה יכול לתקן את הטעות הקטנה :-[

הוספתי תנאי שהוא יחבר רק את הסוכמים של מספרים שיש בהם 3. (כלומר ב35 ו45 ו3 הוא יביא סכום של 38, וזה פועל בשליליות גם(כלומר -13 ו3, ו -13 ו-3))

#include <stdio.h>
int main()
{
 double sum=0,num=0;
 char ch, shouldEnd = 'n',num3='n',isNegative;
 do
 {
 ch=getchar();
 if(ch<='9' && ch>='0')
 {
 num=num*10+ch-48;
 if(ch=='3')
 {
  num3='y';
 }
 }
 else
 {
 if(ch==0x20)
 {
  if(num3=='y')
  {
  if(isNegative=='n')
   sum += num;
  else if(isNegative=='y')
   sum=sum+(num*-1);
  }
  num3='n';
  num=0;
  isNegative='n';
 }
 else
 {
  if (ch == '@')
  {
  shouldEnd='y';
  printf("%.2lf\n",sum);
  }
  else if(ch=='-')
  {
  isNegative='y';
  }
  else
  {
  printf("error\n");
  num=0;
  sum=0;
  }
 }
 }
 }
 while(shouldEnd == 'n');
}

[k-o-b-y]

אתה צריך דרך לדעת האם המס' הנוכחי "ריק". להשוות ל0 לא יהיה מספיק מכיוון שגם המשתמש יכול להכניס 0.

דרך אפשרית לפתור את זה היא להפוך את המשתנה isNegative למשתנה שמציין את ה"מצב" של המספר, נגיד ונקרא לו state. ערך 'n' יציין שהמס' הנוכחי שלילי, 'p' יציין חיובי ו 'e' למשל שהמס' ריק/עדיין לא נקלט (עבור "empty"). למרות שאם למדת על enum הקוד יהיה קריא יותר לדעתי עם שימוש ב enum.

שני דברים נוספים:

- כרגע בקוד שלך אם המשתמש מכניס את ה @ צמוד למס' האחרון הוא לא ילקח בחשבון, רק מספרים שאחריהם יש רווח נחשבים. אני חושב שעדיף לקחת בחשבון את המס' גם במקרה שה @ צמוד למס' האחרון.

- במידה ויש שגיאה אתה רוצה קלט חדש לגמרי מהמשתמש. הבעיה כרגע היא שבמידה והמשתמש מכניס למשל 22a33@ ברגע שהלולאה מגיעה ל a מודפס error, אבל בקריאה להבאה getchar() יקלט אוטומטית 3 כי ה33 נשאר ב buffer ולכן כשיש שגיאה צריך לנקות אותו בעזרת לולאה.

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

double sum=0,num=0;
char ch, shouldEnd = 'n',num3='n', state='e', hadError='n';
do
{
 ch=getchar();
 if(ch<='9' && ch>='0')
 {
  num=num*10+ch-48;
  if(state=='e')
   state='p';
  if(ch=='3')
   num3='y';
 }
 else if (ch=='-')
 {
  if(state == 'e')
   state='n';
  else
   hadError = 'y';
 }
 else
 {
  if(num3=='y')
  {
   if(state=='p')
    sum += num;
   else if(state=='n')
    sum -= num;
  }

  if (ch == '@')
  {
   shouldEnd='y';
   printf("%.2lf\n",sum);
  }
  else if(ch != 0x20)
    hadError = 'y';

  num = 0;
  state = 'e';
  num3='n';
 }

 if(hadError == 'y')
 {
  while (getchar() != '\n');
  printf("Error, start over:\n");
  sum = 0;
  hadError = 'n';
 }
}
while(shouldEnd == 'n');

[Stoned Junglist]

דבר ראשון: תודה רבה כל הכבוד, מהיום אני אלמד להשתמש ביותר משתני עזר =].

והקטע עם ה'מצב' זה חכם מאוד . תודה.

אבל ממ בדקתי קצת ושכחנו את המקרה שזה יהיה 3.22 ו4.304 נגיד..

אז הכנתי if בתוכנית, שברגע שהוא מגיע לנקודה הוא קולט עוד מספר ומחבר אותו, אך הפונקציה מאכזבת ולא יוצאת לי טוב, ובדקתי את כל הקצוות ולא מצאתי את פשר הבעיה. הוספתי math.h בשביל הPOW (לעלות בחזקת משו).

#include <stdio.h> 
#include <math.h> 
int main()
{
 double sum=0,num=0,z,count=0;
 int dotnum=0;
 char ch, shouldEnd = 'n',num3='n', state='e', hadError='n',dot='n';
 do
 {
 ch=getchar();
 if(ch<='9' && ch>='0')
 { 
  num=num*10+ch-48;
  if(state=='e') 
   state='p'; 
  if(ch=='3')
   num3='y'; 
  if(dot=='y')
  {
  num=num*10+ch-48;
  count++;
  }
 }
 else if (ch=='-')
 { 
  if(state == 'e')
   state='n'; 
  else
   hadError = 'y';
 } 
 else if(ch=='.')
 {
 dot='y';
 dotnum=num;
 num=0;
 } 
 else
 {
  z=pow(10,count);
  if(num3=='y')
  {
  if(dot=='y')
  {
   if(state=='p')
    sum=num/z+sum+dotnum;
   else if(state=='n')
    sum=sum-num/z-dotnum;
   }
  else
  {
   if(state=='p')
    sum += num;   
   else if(state=='n')
    sum -= num;
  }
  } 
  if (ch == '@')
  {
   shouldEnd='y';
   printf("%.2lf\n",sum);
  }
  else if(ch != 0x20)
  hadError = 'y';
  num=0;
  state='e';
  num3='n';
  dot='n';
  count=0;
  z=0;
 }
 if(hadError == 'y')
 {
  while (getchar() != '\n');
  printf("Error, start over:\n");
  sum = 0;
  hadError = 'n';
 } 
 }
 while(shouldEnd == 'n');
}

דוגמא לבדיקות שלי:

קלט-3.1 5@

4.10פלט-

==

קלט-3002 1.23 45@

3025.33פלט-

==

קלט- -32 -2.3 42@

-37.30=פלט

[k-o-b-y]

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

כשקלטת ספרה, בתוך התנאי if(dot=='y') אתה לא צריך שוב להוסיף את הספרה ל num. פשוט תמחק את השורה num=num*10+ch-48; כי מה שקורה כרגע זה שכל ספרה אחרי הנקודה אתה מוסיף פעמיים. זה אמור לעבוד.

אבל אפשר לפשט את זה ככה שלא תצטרך משתנה בנפרד לחלק שאחרי הנקודה. במקום המשתנה count תחזיק משתנה שכשתכפיל בו את הספרה תקבל את המספר שאתה רוצה להוסיף לnum. זאת אומרת שהערך ההתחלתי שלו יהיה 0.1. נגיד והמספר הוא כרגע 8. קלטת נקודה ואז 9. תכפיל את 9 ב 0.1 ותוסיף ל num ותקבל 8.9. אחרי כל ספרה אתה מחלק את המשתנה ב 10 ככה שאחרי שקלטת 9 הוא יהיה 0.01. נגיד והספרה הבאה היא 2, תכפיל את 2 ב 0.01 ותוסיף ל 8.9 תקבל 8.92.

תנסה את זה:

double sum=0,num=0, multiplier;
 char ch, shouldEnd = 'n',num3='n', state='e', hadError='n',dot='n';
 do
 {
 ch=getchar();
 if(ch<='9' && ch>='0')
 {
  if(dot=='y')
  {
   num += (ch-48)*multiplier;
   multiplier /= 10;
  }
  else
   num=num*10+ch-48;

  if(state=='e') 
   state='p'; 
  if(ch=='3')
   num3='y'; 
 }
 else if (ch=='-')
 {  
  if(state == 'e')
   state='n';  
  else
   hadError = 'y';
 }  
 else if(ch=='.')
 {
  if(state == 'e' || dot == 'y')
   hadError = 'y';
  else
  {
   dot='y';
   multiplier=0.1;
  }
 } 
 else
 {
  if(num3=='y')
  {
   if(state=='p')
    sum += num;   
   else if(state=='n')
    sum -= num;
  } 
  if (ch == '@')
  {
   shouldEnd='y';
   printf("%.2lf\n",sum);
  }
  else if(ch != 0x20)
   hadError = 'y';

  num=0;
  state='e';
  num3='n';
  dot='n';
 }

 if(hadError == 'y')
  {
  while (getchar() != '\n');
  printf("Error, start over:\n");
  sum = 0;
  hadError = 'n';
  } 
 }
 while(shouldEnd == 'n');

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

[Stoned Junglist]

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

תודה רבה! =]

ממ יש לי דבר קטנטן אחרון לשאול.. =]

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

int main()
{
 char c,hadError='n',shouldEnd='n';
 int selection=0;
 do
 {
 selection=0;
 c = getchar();
 if(c>='1' && c<='4')
  selection=10*selection+c-48;
 else
  {
  if(c=='\n')
  {
   if(hadError=='n')
   {
   if(selection==1)
   {
   printf("lol1");
   shouldEnd='n';
   }
   if(selection==2)
   {
    printf("lol2");
    shouldEnd='n';
   }
   if(selection==3)
   {
    printf("lol3");
    shouldEnd='n';
   }
   if(selection==4)
   {
    printf("lol4");
    shouldEnd='y';
   }
   else
   {
   shouldEnd='n';
   hadError='y';
   }
   }
  }
  else
   hadError='y';
  }
 if(hadError == 'y')
 {
  while (getchar() != '\n');
  printf("Error\n");
  selection=0;
  hadError = 'n';
 }
 }
 while(shouldEnd=='n');
}

להלן הקוד, עשיתי בדיוק כמו שמתואר לעשות, אבל יש לי בעיה.

במקרה של מספר זוגי או תו לא נכון (a,-.[, 45 , 65 וכו') הוא מחזיר ERROR ומבקש לקלוט שוב, וזה טוב.

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

תודה רבה.

ולכן אני צריך לתקן את הפונקציה, אך לא מצאתי איפה =\