אני צריך לקלוט מהמשתמש גודל של מערך, ואז לקלוט ממנו מספרים עד לגודל המערך

איך אני עושה את זה ב C? (אני רגיל לג'אווה ששם זה לא בעיה)

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

תודה

ב C יש פונקצייה בשם malloc, שאמורה להקצות זיכרון, ופונקצייה בשם free שמשחררת אותו.

malloc מקבלת גודל זיכרון שאותו היא צריכה להקצות, ומחזירה מצביע מסוג void* לאיזור המוקצה.

free משחררת את הזיכרון (אותה פעולה שה Garbage Collector עושה בשבילך ב Java), ואני לא יודע אם היא מקבלת פרמטרים.

שים לב ש-malloc מקבלת את גודל המערך המוקצה בבתים. על מנת להקצות מערך של int, צריך לכפול בגודל של int. כלומר, בשביל להקצות מערך של int בגודל n, יש לעשות:

int *p;
p = (int*)malloc(n * sizeof(int));

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

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

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

מה? איך הבנת את זה ממה שכתבתי?

אחרי שאתה מקבל את n אתה יוצר את המערך בדיוק כמו שרשמתי.

יש עוד פתרון שלמדתי בזמנו ב-JAVA.

זה נקרא רשימה מקושרת... לא זוכר C אז לא אוכל להסביר (לא מונחה עצמים ממה שזכור לי), אבל זה הרעיון:

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

אתה שומר את הכתובת של ה"תא" הראשון ובעצם כדי לחלץ את המידע אתה עובר עליו בלולאה...

נניח אני רוצה להכניס את המילה "בוקר"

אובייקט 1:

תו = ב'

כתובת הבאה = אובייקט 2

אובייקט 2:

תו = ו'

כתובת הבאה = אובייקט 3

אובייקט 3:

תו = ק'

כתובת הבאה = אובייקט 4

אובייקט 4:

תו = ר'

כתובת הבאה = null

הבנתי תודה.

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

היתרון העיקרי של רשימה מקושרת הוא האפשרות להוסיף ולהוריד איברים באמצע הרשימה ביעילות.

בכל מקרה, אם אתה יודע מראש את גודל הרשימה שלך (כמו במקרה שלך - גודל הרשימה מתקבל מהמשתמש בתחילת התכנית) עדיף להשתמש במערך מוקצה דינמית.

ובלי קשר, תמיד טוב להכיר מבני נתונים שונים (רשימה דינמית, רשימה מקושרת, עצים בינארים, טבלאות האש...)

אז אם הבנתי נכון...

אחרי שהמשתמש הכניס n , אני עושה לולאה עד ש i מגיע ל n-1 ומבקש מהמשתמש להכניס ערך ל p ?

צריך לבדוק אם אחרי ההכנסה של n אם הוא שווה ל NULL?

ואז ברגע שאני מסיים להשתמש בתא במערך אני צריך לעשות לו free?

שים לב שכשאתה כותב בפורום i בתוך סוגריים מרובעים זה מתורגם לכתב מוטה... עדיף לכתוב קוד בתוך טג קוד.

אחרי שהמשתמש הכניס n , אני עושה לולאה עד ש i מגיע ל n-1 ומבקש מהמשתמש להכניס ערך ל p ?

כן.

צריך לבדוק אם אחרי ההכנסה של n אם הוא שווה ל NULL?

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

ואז ברגע שאני מסיים להשתמש בתא במערך אני צריך לעשות לו free?

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

free(p);
scanf("%d", &p[0]);

זה big no no.

כמובן אחרי ש-p משוחרר מותר להקצות עבורו זכרון חדש בעוד malloc.

אני מציע לך לקרוא קצת על הקצאה דינמית ב-C.

באופן כללי כשאתה עושה malloc אתה מקצה זיכרון על ה-heap בגודל שאתה מגדיר.

כשאתה מבצע

int *array = (int*)malloc(n*sizeof(int));

אתה בעצם מקצה n תאים בזיכרון כשכל אחד הוא בגודל int (כלומר 4 בייט). malloc מחזירה לך מצביע לאיבר הראשון.

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

לכל מצביע כזה מערך של int למשל. אח"כ יש לבצע free לכל אחד מהמצביעים במערך ואז למצביע הראשון.

את בדיקת ה-NULL אתה מבצע רק פעם אחת אחרי ביצועי ה-malloc.

תודה רבה!

אוקיי אז עשיתי תכנית וכמעט הכל עובד טוב

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

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

אני פונה לפונקציה כך:

printf("%d",my_scalar(v,u,n));

כאשר u ו v הם המערכים ו n זה גודל המערך

למה זה יכול להיות?

תעלה את כל הקוד.

עדיין לא טיפלתי ב NULL...

#include <stdio.h>

#include <stdlib.h>

int my_scalar(int v[],int u[],int n){

  int i;

  int scalar=0;

  for(i=0;i<=n-1;i++){

   scalar+=v[i]*u[i];

  }

  return scalar;

}

int main(){

  int c=0;

  int i=0;

  int n=0;

  printf("enter the array size\n");

  scanf("%d",&n);

  int *v= (int*)malloc(n*sizeof(int));

  int *u= (int*)malloc(n*sizeof(int));

  printf("enter the first vector numbers\n");

  while(i!=n){

   v[i]=scanf("%d",&c);

   i++;

  }

  printf("enter the second vector numbers\n");

  i=0;

  while(i!=n){

   u[i]=scanf("%d",&c);

   i++;

  }

  printf("the scalar=");

  printf("%d",my_scalar(v,u,n));

  free(u);

  free(v);

  return 0;

}