שאלה קטנה בשפת c

ronib25

New member
שאלה קטנה בשפת c

היי. אני צריך לפתור את התרגיל שאצרף ואני לא מבין אותו כמו שצריך...אשמח לעזרתכם..
מה שעליי לעשות הוא לקלוט ל st כלומר למבנה...
ובסוף השאלה נאמר לי לקלוט ל st1 ו st2...
אני לא מבין איך לקלוט פעם לשם ופעם לשם...
יש מצב גדול שאני לא מבין את השאלה ולכן אשמח אם מישהו יוכל לפשט אותה טיפה...אין צורך לעזור בפיתרון כי הרכבתי פונ׳.. נשאר רק לקלוט מספרים ואני לא מבין כיצד...

 

BravoMan

Active member
בשום מקום בתרגיל לא נאמר לך לקלוט ל-st!

נתון לך מבנה מטיפוס SetABC.
למבנה זה איבר בודד מסוג int בשם st
&nbsp
בתרגיל מבקשים ממך ליצור 2 משתנים מטיפוס "מבנה SetABC", לקלוט לתוכם נתונים, ואז להשתמש בהם כפרמטרים כדי לבדוק את הפונקציות שבנית.
&nbsp
שים לב, שלמעט התחכמויות נדירות שלא משתמשים בהן באקדמיה, לעולם לא "קולטים למבנה", אלא תמיד קולטים לתוך איבר מסוים של המבנה!
 

ronib25

New member
כן, כן אני עשיתי ככה...אבל

אני אגיד לך מה הבעיה אצלי..
אני לא יודע היכן למקם בדיוק מערך של כל האותיות האנגליות...
אני הרכבתי את כל הפונ׳ והן עובדות ואני אפילו מקצר עכשיו עם itoa...
הבעיה שאני מגיע למספרים דצימליים ובכל פונ׳ אני צריך להדפיס גם את ה abc לפי המספר הבינארי.. עכשיו כאן הבעיה וזה בתכלס כל מה שנשאר...הפונ׳ קולטת מהמבנה. והמספרים בשום מצב לא מגיעים למבנה, הם פשוט מוחזרים מכל פונ׳ למיין...
אם אתה רוצה אני אעלה את הקוד כדי שתראה...יכול להיות שאני אומר משהו אחד ובפועל קורה משהו אחר...אך רק אם תרצה לזרוק מבט :)
 

ronib25

New member
זה הקוד.. יכול להיות שאמרתי משהו אחד ורשום כאן משהו אחר...

כמו כן אני עובד עדיין על הורדת הפונ׳ של ההפיכה לבינארי, ובמקומה אני אשתמש ב itoa...כרגע עדיין לא סיימתי אז הקוד הוא עם הפונ׳...
יש שם גם הגדרת קבוע מיותרת..
קוד:
# include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define SIZE (sizeof(int)*8)

typedef struct SetABC
{
	unsigned int st;
} SetABC;

int BinariNumber(st1);//function that becomes number to bunari number
void PrintSet(SetABC st);//seif 1
int SetABCUnionABC(SetABC st1, SetABC st2);//seif 2
int SetABCIntersectABC(SetABC st1, SetABC st2);//seif 3
int SetABCMinusABC(SetABC st1, SetABC st2);//seif 4

void main()
{
	int num = 0, i = 0, second, third, fourth;
	SetABC st1, st2;
	unsigned int num1, num2;
	printf("Enter the first number: ");
	scanf("%d", &(st1.st));
	printf("Enter the second number: ");
	scanf("%d", &(st2.st));
	num1 = BinariNumber(st1.st);
	num2 = BinariNumber(st2.st);
	printf("\nThe letters that belongs to original numbers are:\n");
	PrintSet(st1);
	PrintSet(st2);
	second = SetABCUnionABC(st1, st2);//seif 2
	printf("(%d)\n", second);
	third = SetABCIntersectABC(st1, st2);//seif 3
	printf("(%d)\n", third);
	fourth = SetABCMinusABC(st1, st2);//seif 4
	printf("(%d)\n", fourth);



	getch();
}
int BinariNumber(st1)
{
	int i = 1, DecNum = st1;
	int Binary = 0;

	while (DecNum > 0)
	{
		Binary = ((DecNum % 2) * i) + Binary;
		DecNum /= 2;
		i = i * 10;
	}
	return Binary;
}

void PrintSet(SetABC st)//seif 1
{
	char ABC[27] = "abcdefghijklmnopqrstuvwxyz";
	int i = 0, num;
	num = BinariNumber(st);
	while (i != 26)
	{
		if ((num % 2) != 0)
			printf("%c", ABC[i]);
		num = num / 10;
		i++;
	}
	printf("\n");
}
int SetABCUnionABC(SetABC st1, SetABC st2)//seif 2
{
	unsigned int c = 0;
	unsigned int *a = &st1, *b = &st2;
	c = *a | *b;
	printf("\nOR:\n");
	return c;
}
int SetABCIntersectABC(SetABC st1, SetABC st2)//seif 3
{
	unsigned int c = 0;
	unsigned int *a = &st1, *b = &st2;
	c = *a & *b;
	printf("\nAND:\n");
	return c;
}
int SetABCMinusABC(SetABC st1, SetABC st2)//seif 4
{
	unsigned int c = 0;
	unsigned int *a = &st1, *b = &st2;
	c = *a ^ *b;
	printf("\nXOR:\n");
	return c;
}
 

BravoMan

Active member
לא ראיתי בשום מקום בתרגיל שביקשו ממך מערך אותיות...

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

ronib25

New member
אז כיצד אני יכול לפתור זאת ?

האם הפיתרון של משחקים עם קודי אסקי זאת דרך הפיתרון שכביכול צריך ?
יש לי עוד שאלה שאני לא מבין למה משהו לא עובד בקוד:
יש לי מספר בינארי שמיוצג על ידי unsigened int עכשיו אני בודק את החלק האחרון ע״י מודולו 2 ומסיק מסקנות... עכשיו בגלל שאני צריך להשתמש באופרטור << אז אני עשיתי number>>=number+1 והוא באמת מזיז הכל בביט 1 ימינה אבל גם כופל ב5 ואני לא מבין למה (אני פשוט כל פעם מחלק חזרה ב 5 וזה נפתר, והמעקב מצביע שהשורה הזו היא הבעייתית..) יש לך אולי הסבר למקרה הזה ??
 

BravoMan

Active member
לא יודע מה זה "משחקים עם קוד ASCII".

אם אתה רוצה להזיז את המספר רק מקום אחד, למה אתה מזיז את המספר בעצמו ועוד אחד?
&nbsp
מה שכתבת יזיז כל פעם כמות ביטים שונה, ואין בזה שום הגיון.
האופרטור << מקבל 2 אופרנדים: השמאלי "מה להזיז" (במקרה שלך משתנה number), הימני "בכמה להזיז" (במקרה שלך 1).
&nbsp
אני רואה שניסת להתחכם ולהשתמש ב-=<<.
אם אינך בטוח איך להשתמש באופרטור נכון, עדיף שתשמש בצורה הארוכה יותר, ותעשה זאת נכון.
קיצורים מבלבלים לא יוסיפו לך ניקוד בתרגיל, עדיף שתלך על בטוח!
 

ronib25

New member
אם אני אגדיר למשל את...

את ABC כך :
char ABC='a' ואז פשוט בהדפסה אדפיס C% ואעשה ABC+i-k כלומר משחק מספרי שכזה...זה יותר אפשרי מאשר מערך שלא התבקשתי לעשות ??
גם בהקשר להודעה הקודמת אני לא יכול לערוך, זה מה שהתכוונתי number>>number+1
ונניח המספר לפני היה 1101, אז הוא הופך להיות 0550 כלומר מוזז וגם מוכפל. מאיפה מגיע הכפל ?
 

BravoMan

Active member
אתה אפילו לא חייב את המשתנה.

אני לא בטוח מה זה i-k במקרה שלך (מודה, אצלן מכדי לקרוא את כל הקוד של התרגיל שלך), אבל טכנית כן:
אתה יכול להדפיס כל אות ע"י הדפסת 'a' + כמות המקומות ש-"זזים" מ-a.
למשל, b יהיה a + 1 וכך הלאה.
&nbsp
לגבי הזזה - ראה הסבר בתשובה להודעה קודמת. הוא עדיין תקף כי הקוד שלך עדיין לא הגיוני.
 

ronib25

New member
הכוונה היא :

בדיוק מה שכתבת הגדרתי a ו i-k זה תוספת i זה אורך ו k זה הקטנה ב 1...
השאלה העיקרית שלי היא שאני לא מבין: אני מהפונ׳ של סעיף 2-4 מחזרים את המספר כלומר עשרוני...
אם אני מבין נכון אני צריך שוב לעשות את העבודה של פונ׳ מס׳ 1, אבל הבעיה היא שפונ׳ מס׳ 1 מקבלת רק מהמבנה...
איך אני יכול לפתור את זה??
 

BravoMan

Active member
פתרת לא נכון את התרגיל!

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

ronib25

New member
שאלונת

אני בכל פונ׳ מוצא מספר עשרוני...אני יכול בקלות בתוך כל פונ׳ להפוך לבינארי ולהחזיר..
אני לא כל כך מבין את השאלה לכן ארשום את השלבים שאני חושב שצריך לעשות ואשמח שתגיד לי איפה הבעיה אצלי...
אני קולט לתוך המבנה 2 מספרים st1 ו st2.
אני בmain שולח לפונ׳ מס׳ 1 ושם היא הופכת את המספר העשרוני לבינארי ומדפיסה על פי מה שדלוק (אמרת לא טוב %2 אז יתוקן ל & )
שלב 2 - אני שולח מה main את אותם המספרים מהמבנה ובתוך הפונ׳ מבצע or ומוחזר מספר עשרוני למיין ואני מדפיס אותו (יש לי כרגע בעיה עם הבינארי, אם אני אחזיר בינארי אז יהיה קל יותר)
שלב 3 - כמו 2 רק and
שלב 4- כמו 2 רק xor
הבעיה העיקרית היא שפונ׳ 1 מדפיסה רק כאשר אני שולח מתוך המבנה, ומה שקורה בפועל זה שהמספר חוזר בכלל ל main ומשם פונ׳ 1 לא תקלוט אותו בשום מצב על פי הפונ׳ שהתבקשתי לעשות...
&nbsp
 

ronib25

New member
לא כל כך הבנתי נקודה ממה שכתבת

אתה אומר ״בכל הסעיפים הפונקציה אמורה להחזיר את התוצאה בתוך המבנה.״
מה כוונתך ?
אני שולח מתוך המבנה והיא חוזר לmain כי ההוראה מגיע מה main.. האם זה בסדר ?
או שלא הבנתי אותך.
כמו כן סידרתי את זה שעכשיו המספרים שחוזרים הם בינאריים.
ועוד שאלה, איך במקום %2 אני יכול להשתמש ב & ?
מה שאני עושה הוא לבדוק כל פעם תו הכי ימני ובהתאם לכך יודע איזה אות אני צריך..
ובמקרה של & אני עושה בדיקה אחת במכה אחת, ואני לא יודע איזה אות אני צריך...לא ככה ?
 

BravoMan

Active member
הסתכלתי עכשיו בפונקציית ההדפסה שכתבת

ואתה לא עובד נכון עם מספר בייצוג בינארי!
&nbsp
מן הסתם, אני לא יכול לחזור על שיעור שיטות ספירה ע"ג בפורום, אז אנסה להסביר בקטנה את הבעיה:
&nbsp
אין "מספר עשרוני" ו-"מספר בינארי".
המספר תמיד נשאר אותו מספר, אבל יש לו ייצוג בינארי, וייצוג עשרוני.
&nbsp
בתרגיל, הייצוג העשרוני שהכי מוכר לבני אדם לא מעניין אותך.
גם המספר עצמו לא מעניין אותך.
&nbsp
ייצוג של כל דבר במחשב הוא מטבעו בינארי.
ביקשור ממך לנצל את הייצוג הבינארי הזה ולבדוק אלו סיביות דלוקות (1) ואלו לא (0).
&nbsp
לשם כך, ביקשו ממך להשתמש בפעולות על סיביות כגון << הזזה ו-& (and לפי סיביות).
&nbsp
כל הפונקציות שביקשו ממך לכתוב, מקבלות כפרמטר מבנה, שכולל בתוכו איבר אחד, שמכיל את הסיביות (זה בעצם מספר, אבל המספר לא מעניין אותך, רק הסיביות).
&nbsp
פונקציות שהתבקשת לכתוב בסעיפים 2 עד 4 גם מחזירות מבנה, שיש בו איבר אחד, שמכיל סיביות.
שוב - שים לב!
לא מעניין אותך הייצוג העשרוני של המספר שיש בתוך האיבר בתוך המבנה.
מעניינות אותך תמיד רק הסיביות שלו!
&nbsp
פשוט תסתכל איך כתובה כותרת הפונקציה בקוד שלך, ואיך היא כתובה בתרגיל:
תראה שמה שכתבת בקוד שלך שונה מהתרגיל, ועל זה אתה עלול לקבל 0 (או לפחות הורדה משמעותית בציון).
&nbsp
שנה את הכותרת, ושנה את ה-return בהתאם!
&nbsp
לגבי & - עכשיו שאתה יודע שמה שמעניין אותך זה סיביות, תשקיע קצת זמן ותחשוב איך הוא פועל, ואיך ניתן להשתמש בתוצאה שלו כדי לבדוק עם סיבית דלוקה או לא.
 

ronib25

New member
ראשית תודה על התגובה...

שנית אני ממש מצטער שאני לא מתבטא כמו שצריך...
תראה, אני תיקנתי את הפונ׳ למעלה..(לימדת אותי משהו חדש על מבנים)...
עכשיו השאלה שלי היא לגבי הreturn. אני צריך להחזיר מבנה..האם ניתן במקרה הספציפי הזה להגדיר בפונ׳ 2-4 מצביע למשל על st1 ולשמור כל פעם לתוכו...? כלומר האם אפשרי שיחזור מצביע ??
אני אוסיף קוד קצת יותר מעודכן.. כי הקודם כבר הפך ללא רלוונטי (גם זה דורש שיפוץ רב)
אך תיקנתי כמה דברים ממקודם (כרגע התוכנית מדפיסה את הabc על פי הדרישה של המספרים המקוריים שנקלטים, ובנוסף את הייצוג הבינארי שהיה עד כה לשם בדיקה שאני עובד נכון...- מה שאני צריך לעשות זה במקום להדפיס את הייצוג הבינארי, להחזיר אותו כמבנה לmain ולשלוח לפונ׳ 1 להדפסה ,שזאת עיקר הבעיה כרגע מבחינתי...)

קוד:
# include <stdio.h>
#include <stdlib.h>
#include <conio.h>

typedef struct SetABC
{
	unsigned int st;
} SetABC;

void PrintSet(SetABC st);//seif 1
SetABCUnionABC(SetABC st1, SetABC st2);//seif 2
SetABCIntersectABC(SetABC st1, SetABC st2);//seif 3
SetABCMinusABC(SetABC st1, SetABC st2);//seif 4

void main()
{
	int num = 0, i = 0, second, third, fourth;
	SetABC  st1, st2;
	char buffer[27], buffer2[27];
	printf("Enter the first number: ");
	scanf("%d", &(st1.st));
	printf("Enter the second number: ");
	scanf("%d", &(st2.st));
	itoa(st1.st, buffer, 2);//transmite to binary number
	itoa(st2.st, buffer2, 2);
	printf("\nThe letters that belongs to original numbers are:\n");
	PrintSet(st1);
	PrintSet(st2);
	second = SetABCUnionABC(st1, st2);//seif 2
	printf("(%d)\n", second);
	third = SetABCIntersectABC(st1, st2);//seif 3
	printf("(%d)\n", third);
	fourth = SetABCMinusABC(st1, st2);//seif 4
	printf("(%d)\n", fourth);
	getch();
}

void PrintSet(SetABC st)//seif 1 
{
	char ABC = 'a', buffer[27];
	int i = 0, k;
	unsigned int *p = &(st), t, num;
	num = *p;
	itoa(num, buffer, 2);
	i = strlen(buffer);
	if (i > 26)
		printf("The length of binary number too long for use the english ABC");//errore message
	else
	{
		k = i;
		while (k > 0)//while the place in the range of ABC
		{
			if (buffer[k - 1] & 1 == 1)//if the number is 1 so the bit works we shoud print the correct letter
				printf("%c", ABC + i - k);
			k--;//next place on the buffer
		}
		printf("\n");
	}
}
SetABCUnionABC(SetABC st1, SetABC st2)//seif 2
{
	char buffer[27];
	unsigned int c = 0, *a = &st1, *b = &st2, t;
	c = *a | *b;
	printf("\nOR:\n");
	itoa(c, buffer, 2);
	t = atoi(buffer);
	return t;
}
SetABCIntersectABC(SetABC st1, SetABC st2)//seif 3
{
	char buffer[27];
	unsigned int c = 0, *a = &st1, *b = &st2, t;
	c = *a & *b;
	printf("\nAND:\n");
	itoa(c, buffer, 2);
	t = atoi(buffer);
	return t;
}
SetABCMinusABC(SetABC st1, SetABC st2)//seif 4
{
	char buffer[27];
	unsigned int c = 0, *a = &st1, *b = &st2, t;
	c = *a ^ *b;
	printf("\nXOR:\n");
	itoa(c, buffer, 2);
	t = atoi(buffer);
	return t;
}
 

BravoMan

Active member
לא, אתה לא יכול להחזיר מצביע!

שוב - בתרגיל אמרו לך להחזיר מבנה - לא מצביע, לא unsigned int אלא מבנה SetABC.
&nbsp
אם זה מה שאמרו בתרגיל, זה מה שאתה חייב לעשות. אין פה צורך לחשוב על שום דבר, רק לציית.
אני יודע, זה נשמע חריף, אבל חשוב מאוד למלא את כל דרישות התרגיל אם רוצים לקבל את הציון המלא! כתבתי לך שאתה צריך לשנות לא רק את כותרת הפונקציה, אלא גם את מה שהיא מחזירה, אבל לא עשית זאת!
הפונקציות שלך עדיין מחזירות unsigned int, וזה פשוט לא נכון!
&nbsp
בנוסף, אני רואה שהחלטת להשתמש במצביעים ובפונקציה itoa.
לאף אחד מאלה אין שום קשר לתרגיל ואין שום סיבה שהם יהיו שם.
&nbsp
למעשה, אתה גם משתמש בצורה לא נכונה במצביעים: אתה לא יכול לקחת מצביע לטיפוס אחד (מבנה מסוג SetABC) ולהחליט שהוא בעצם מצביע לטיפוס אחר לגמרי unsigned int.
&nbsp
אבל זה בדיוק מה שאתה עושה בכל הפונקציות, ואני לא מבין מדוע?
האם אינך יודע כיצד לגשת לאיברים בתוך מבנה?
&nbsp
*גילוי נאות:
שפת C עצמה כן מאפשרת לעשות את מה שעשית, וזה אפילו יעבוד במקרה הזה כי פריסת המבנה בזיכרון ופריסת unsigned int בזיכרון יהיו זהים במחשב שאתה עובד עליו.
&nbsp
אבל, זה שמשהו אפשרי טכנית לא אומר שמותר לך לעשות אותו בתרגיל בקורס, ובטח לא אומר שהוא ראיון טוב שיעבוד תמיד. בקיצור - אל תעשה את זה!
 

ronib25

New member
יש לי שאלה:

בקשר למצביעים בפונ׳ 2-4. אמרת שאני לא יכול להשתמש במצביע מבחינה תאורטית כי זה unsigned int ושם זה מבנה...
אני יצאתי מנקודת הנחה שהמצביע מצביע על הכתובת שיש בתוך השדה שנשלח ובתוך הכתובת יש מספר שמוגדר כ unsigned int...
שאלה נוספת, אני מתקשה עם מבנים עדיין...הגדתי בתוך הפונ׳ 2 כרגע (גם 3ו4 בהמשך) struct SetABC stSecend שלשם אני אכניס את התוצאה של הפעולה של bitwise ואז אחזיר בעזרת return.. אך אי אפשר לבצע את הפעולה הבאה: stSec =st1|st2 למשל..
יכול להיות שאני יוצא טמבל, אבל אני לא מבין..אשמח אם יש לך אולי איזה קישור להפנות אותי לדוגמאות בהקשר של מבנים כדי שקצת אסתכל ואבין... :/
 

ronib25

New member
ממ אני חושב שסיימתי..אשמח אם תציץ בקוד

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

קוד:
# include <stdio.h>
#include <stdlib.h>
#include <conio.h>

typedef struct SetABC
{
	unsigned int st;
} SetABC;

void PrintSet(SetABC st);//seif 1
SetABCUnionABC(SetABC st1, SetABC st2);//seif 2
SetABCIntersectABC(SetABC st1, SetABC st2);//seif 3
SetABCMinusABC(SetABC st1, SetABC st2);//seif 4

void main()
{
	int num = 0, i = 0, second, third, fourth;
	SetABC  st1, st2, sec, three, four;
	char buffer[27], buffer2[27];
	printf("Enter the first number: ");
	scanf("%d", &(st1.st));
	printf("Enter the second number: ");
	scanf("%d", &(st2.st));
	printf("\nThe letters that belongs to original numbers are:\n");
	PrintSet(st1);
	PrintSet(st2);
	sec.st = SetABCUnionABC(st1, st2);//seif 2
	printf("(%d) ", sec.st);
	PrintSet(sec);
	three.st = SetABCIntersectABC(st1, st2);//seif 3
	printf("(%d) ", three.st);
	PrintSet(three);
	four.st = SetABCMinusABC(st1, st2);//seif 4
	printf("(%d) ", four.st);
	PrintSet(four);
	getch();
}

void PrintSet(SetABC st)//seif 1 
{
	char ABC = 'a', buffer[27];
	int i = 0, k;
	unsigned int *p = &(st), t, num;
	num = *p;
	itoa(num, buffer, 2);
	i = strlen(buffer);
	if (i > 26)
		printf("The length of binary number too long for use the english ABC");//errore message
	else
	{
		k = i;
		while (k > 0)//while the place in the range of ABC
		{
			if (buffer[k - 1] & 1 == 1)//if the number is 1 so the bit works we shoud print the correct letter
				printf("%c", ABC + i - k);
			k--;//next place on the buffer
		}
		printf("\n");
	}
}
SetABCUnionABC(SetABC st1, SetABC st2)//seif 2
{
	struct SetABC sec;
	sec.st = st1.st | st2.st;
	printf("\nOR:\n");
	return sec.st;
}
SetABCIntersectABC(SetABC st1, SetABC st2)//seif 3
{
	struct SetABC three;
	three.st = st1.st & st2.st;
	printf("\nAND:\n");
	return three.st;
}
SetABCMinusABC(SetABC st1, SetABC st2)//seif 4
{

	struct SetABC four;
	four.st = st1.st ^ st2.st;
	printf("\nXOR:\n");
	return four.st;
}
 

הפרבולה

New member
לדעתי יש לך טעות בהגדרה של הפונקציות

זה לא תואם את מה שביקשו
למשל רשמתה:
SetABCUnionABC(SetABC st1, SetABC st2)
וצריך להיות לפי התרגיל
SetABC UnionABC(SetABC st1, SetABC st2)

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