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

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

המטרה ההתתחלתית היא לקלוט סדרה של מספרים int-ים ולא אחד אחרי השני אלא "במכה" ולכן הייתי חייב את ה-while...

הסיבה שהשתמשתי ב-scanf ולא ב-getchar היא כי ב-getchar לפעמים הוא נשאר עם הערך הקודם בקריאה חוזרת, וככה אני נמנע מזה בוודאות.

אשמח אם אוכל לקבל הסבר מה לא בסדר...

תודה !!

#include <stdio.h>
#define N 2 

int main()
{
 int matrix[N][N];
 int i=0, j=0,l,c; 
 char num;


while((num=scanf("%c",&num)) != (EOF))
 { 
  matrix[i][j] = num;
  i++;
  j++;
 }


for(l = 0; l < N; l++)
 {
  for(c = 0; c < N; c++)
   printf("%d\t", matrix[l][c]); 

  printf("\n");
 } 

return 0;
}

num=scanf("%c",&num)

למה יש לך פה פעמיים num?

האם לא אמורים לומר :

num=scanf("%c",&num)

על אותו משקל של:

ch = getchar()

??

או שהכוונה היא שב-

scanf("%c",&num)

אני כבר מכניס לתוכן הכתובת של num את הערך הנקלט ולכן אני לא צריך את num שנית ?

בכל אופן, ניסיתי לפני כן גם:

scanf("%c",&num)

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

למה אתה קורא עם %c ולא עם %d?

למה אתה מקדם את i ואת j ביחד? אתה צריך למלא מספרים רק באלכסון המטריצה או בכל התאים?

למה אתה קורא עם %c ולא עם %d?

כי זה מטיפוס char, וחלק מהמניפולציות (שיהיו) זה לתת למשתמש אופציה להכניס תו כדי שאוכל לתת לו הודעת שגיאה שאני כותב.

למה אתה מקדם את i ואת j ביחד? אתה צריך למלא מספרים רק באלכסון המטריצה או בכל התאים?

בכל התאים... להכניס את זה ללולאה כפולה ?

כי זה מטיפוס char, וחלק מהמניפולציות (שיהיו) זה לתת למשתמש אופציה להכניס תו כדי שאוכל לתת לו הודעת שגיאה שאני כותב.

אם אתה קורא באמצעות c%, אז num יכיל את ערך ה-ASCII של התו שהמשתמש הכניס. על מנת לאפשר לו להכניס מספר אתה חייב להשתמש ב-d%.

אם אתה רוצה לבדוק את תקינות הקלט, יש דרכים יותר טובות לעשות את זה (קודם כל, הדרך הכי פשוטה היא לבדוק את ערך ההחזרה של ה-scanf).

בכל התאים... להכניס את זה ללולאה כפולה ?

כן.

שיניתי:

#include <stdio.h>
#define N 2 

int main()
{
 int matrix[N][N];
 int l,c,i=0, j=0;
 char num;


while((scanf("%d",&num)) != (EOF))
 { 

  for(i = 0; i < N; i++)
  {
  for(j = 0; j < N; j++)

   matrix[i][j] = num;

  } 

 }


for(l = 0; l < N; l++)
 {
  for(c = 0; c < N; c++)
   printf("%d\t", matrix[l][c]); 

  printf("\n");
 } 

return 0;
}

אבל אני מקבל warning:

format '%d' expects type 'int *' , but argument 2 has type 'char *'

כמו כן הערכים עדיין לא תקינים..

אני מכניס לו:

4 3 2 1 ומקבל :

4 4

4 4

תחשוב על המבנה של הלולאות שלך.

האזהרה שהוא נותן לך היא כי אכן num הוא מסוג char. אם אתה רוצה לקלוט מספר, זה צריך להיעשות לתוך int.

תחשוב על המבנה של הלולאות שלך.

עברתי על המבנה כמה פעמים ולא מצאתי מה לא בסדר' date=' סה"כ שתי לולאות, הראשית על השורות והמשנית על העמודות, וכ"א רצה עד N כי הסדר הוא NxN.

האזהרה שהוא נותן לך היא כי אכן num הוא מסוג char. אם אתה רוצה לקלוט מספר, זה צריך להיעשות לתוך int.

אם אני אשנה ל-int אני אפגע בתוכנית שלי לטווח ארוך...

המטרה שלי היא לבנות מספר פונק', כאשר אחת אחראית לקלט המטריצה, אחרת אחראית לבדיקה האם הקלט תקין (נקלטו int-ים בלבד) ובמידה ולא תקין היא תוציא הודעה רלוונטית לכל סוג שגיאה, בנוסף פונק' שתחשב האם סכום האלכסון והשורות זהה, ואחת מדפיסה. אני עדיין לא יודע אם לשלב את הקריאה לפונק' ההדפסה מהפונק' לבדיקת השגיאות ובכך לחסוך טעויות עתידיות מהuser שיכתוב ל-main בעתיד, או שנהוג להפעיל את בדיקת השגיאות מה-main ואת ההדפסה לאחריה גם מה-main ??

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

יש לך שלוש לולאות. מה, ה-while היא לא לולאה?

כמו שאמרתי, אם אתה רוצה לאפשר בדיקות קלט, אז אתה צריך קוד יותר מורכב מזה, או לכל הפחות להשתמש בערך ההחזרה של ה-scanf.

הזזתי את הסוגר המסולסל ;D אבל יש כאן בעיה אחרת שהוא מדפיס לי מטריצה עבור כל ערך של int בקלט כלומר אם הקלט הוא

4 3 2 1 הוא ידפיס:

1 1

1 1

2 2

2 2

3 3

3 3

4 4

4 4

השאלה אם יש דרך יותר טובה לתכנן את זה אחרת ?

בסה"כ בניתי את קוד ההדפסה כדי לבדוק תקינות הקוד שקולט תווים באופן בסיסי למטריצה, ברור שאם זה היה עובד אז הייתי כותב את הפונק' שתקלוט את המטריצה ותריץ עליה בדיקה בסיסית של קלט תקין...

השאלה אם ניתן לבצע את זה אחרת או שהכיוון נכון ?

הזזת איזה סוגר מסולסל לאן? לא הבנתי מה עשית.

הזזת איזה סוגר מסולסל לאן?

#include <stdio.h>
#define N 2 

int main()
{
 int matrix[N][N];
 int l,c,i=0, j=0;
 char num;


while((scanf("%d",&num)) != (EOF))
 { 

  for(i = 0; i < N; i++)
  {
  for(j = 0; j < N; j++)

   matrix[i][j] = num;
  }



for(l = 0; l < N; l++)
  { 
  for(c = 0; c < N; c++) 

   printf("%d\t", matrix[l][c]); 

  printf("\n");
  }


}
return 0;
}

בהתחלה הזזתי את הסוגר אבל שכחתי שה-main ממשיך לעבוד גם אחרי ה-EOF (לחיצה על CTRL-D) אז החזרתי בחזרה ואני לא יודע מה הבעיה...

#include <stdio.h>
#define N 2 

int main()
{
 int matrix[N][N];
 int l,c,i=0, j=0;
 char num;


while((scanf("%d",&num)) != (EOF))
 { 

  for(i = 0; i < N; i++)
  {
  for(j = 0; j < N; j++)

   matrix[i][j] = num;
  }
 }


for(l = 0; l < N; l++)
  { 
  for(c = 0; c < N; c++) 

   printf("%d\t", matrix[l][c]); 

  printf("\n");
  }



return 0;
}

תנסה להסביר לי מה עושה הלולאה הראשונה שלך (לולאת הWHILE).

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

הלולאה קולטת תו לתוך פרמטר מסוג char בשם num. הקליטה עבור כל תו רצה על לולאות for שתפקידן לרוץ על המערך הדו מימדי איבר איבר ולהכניס למטריצה לפי הסדר את האיברים שנקלטים.

הלולאה מסתיימת כאשר הגענו לסוף הקובץ (קלט סטנדרטי) ולחצנו על CTRL-D תחת לינוקס / יוניקס...

התחימה של ה-while במקום המתאים, והמבנה שלה לקלוט תווים עד סוף הקובץ (עד אשר המשתמש לוחץ CTRL-D) אמורה להיות טובה, ולמרות זאת אני לא עולה על הבעיה...