לא מצליח לאתר את הטעות - הקצאות דינאמיות שפת C

[TheSlider]

היי חברים יש לי מטלה של שעורי הבית בהקצאות דינמאיות, אני לא מצליח לאתר טעות הסינטקס שלי:

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

1. . שילוב

כתבו פונקציה בעלת המפרט הבא:

int* arrange(int arr1[],int arr2[],int size1,int size2);

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

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

דוגמא:

מערכים:

1 4 8

2 5 9

0 0 7

פלט:

1 4 8 2 5 9 0 0 7

זהו הקוד שכתבתי:

#include <stdio.h>
#include <stdlib.h>
#define SIZEA 10
#define SIZEB 15

int* arrange(int arr1[],int arr2[],int size1,int size2)
{

	int* p=NULL;
	int i,j;

	p = (int *) mallco ((size1+size2) * sizeof(int));

	if (p != NULL)
	{
		for (i=0; i<=size1; i++)
			p[i]=arr1[i];
		for (j=0; i<=size2; i++)
			p[i+j]=arr2[j];
		for (i=0; i<=(size1+size2); i++)
			printf("%d",p[i]);
		return p;
	}
	else
		return NULL;
}

int main()
{
	int arr1[SIZEA]={3,6,3,3,95,34,21,32,456,12},arr2[SIZEB]={34,64,12,64,3,1,7,3,25,23,7,3,7,3,9};
	int i;

	arrange(&arr1,&arr2,SIZEA,SIZEB);
	printf("\n");

	return 0;
}

תודה רבה!

[AvIAToR]

1- כתבת "mallco" במקום malloc

2- ב-3 הלולאות אי השוויון צריך להיות חריף (קטן ולא קטן-שווה), על כן יש לך גלישה מחוץ לתחום המערכים!.

3- בלולאה השנייה שמת תנאי עצירה על i ואותו קידמת במקום j.

4- שאתה קורא לפונקציה שלחת מצביע למצביע למערך!. שם המערך הוא כבר מצביע לאיבר הראשון במערך, לכן תוריד את ה- & לפני ה- arr1/arr2.

5- מה עם שחרור זיכרון שהוקצה דינמית

חוץ מזה אתה מסודר.

[TheSlider]

AvIAToR תודה רבה על תשובתך המהירה!

זה עובד!

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

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

זה הקוד:

#include <stdio.h>
#include <stdlib.h>
#define SIZEA 10
#define SIZEB 15

int* arrange(int arr1[],int arr2[],int arr3[],int size1,int size2,int size3)
{

	int* p=NULL;
	int i,j,k;

	p = (int *) malloc ((size1+size2) * sizeof(int));

	if (p != NULL)
	{
		for (i=0; i<size1; i++)
			p[i]=arr1[i];
		for (j=0; j<size2; j++)
			p[i+j]=arr2[j];
		for (k=0; k<size3; k++)
			p[i+j+k]=arr3[k];
		return p;
	}
	else
		return NULL;
}

int main()
{
	int arr1[3]={0},arr2[3]={0},arr3[3]={0};
	int i=0;
	int* a;

	printf("Please enter 3 numbers for the first array\n");
	for (i=0; i<3; i++);
		scanf("%d\n",&arr1[i]);
	printf("\n");
	printf("Please enter 3 numbers for the second array\n");
	for (i=0; i<3; i++);
		scanf("%d\n",&arr2[i]);
	printf("Please enter 3 numbers for the third array\n");
	for (i=0; i<3; i++);
		scanf("%d\n",&arr3[i]);

	a=arrange(arr1,arr2,arr3,3,3,3);
	for (i=0; i<(9); i++)
			printf("%d",a[i]);
	free(a);
	printf("\n");

	return 0;
}

[שניצל]

א. יש לך ; מיותר בסוף כל for.

ב. המערך a הוא בגודל 6, לא 9.

[TheSlider]

תודה רבה זה עובד!

שאלה נוספת, אם יש לי מבנה

typedef struct stack_t
{
	int *items;
	int number_of_items;
	int max_size;

}stack;

ואני צריך לממש פונקציה כשזו הכותרת שלה:

stack create_stack(void);

מה זה אומר לגבי מה שהפונקציה מחזירה? הרי לפי כותרת הפונקציה, הפונקציה מחזירה מבנה או משהו כזה, לא?

[שניצל]

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

stack create_stack(void) {

 stack s;

 /* put some stuff into s */

 return s;
}

[TheSlider]

היי שניצל תודה רבה על תשובתך המהירה!

האם אני מגדיר מבנה בתוך כותרת הפונקציה, אז אני לא חייב להגדיר מבנה גם בתוך הפונקציה עצמה?

דבר נוסף, יש תרגיל הנקרא מחסנית.

זהו התרגיל:

2. מחסנית

נתון המבנה הבא המשמש לאחסון סדרת מספרים שלמים חיוביים:

typedef struct stack_t

{

int *items;

int number_of_items;

int max_size;

}stack;

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

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

• מספרים יוצאים מהמחסנית בסדר הפוך לסדר בו הוכנסו.

למשל, אם הוספנו למחסנית את הערך 1 , אחר כך את הערך 2 ולבסוף את הערך 3, ולאחר מכן שלפנו ערך מהמחסנית, הערך שייצא הוא 3. אם נוסיף כעת את הערך 1 ונשלוף שלושה ערכים, הערכים שייצאו הם 1,2,1 בסדר הזה.

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

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

stack create_stack(void);

void delete_stack(stack);

stack pop(stack s,int *result);

stack push(stack s,int item);

הפונקציה create_stack מקצה מערך באורך ראשוני 1 עבור המחסנית, ומאתחלת את שאר השדות בהתאם. הפונקציה delete_stack משחררת את המקום שהוקצה עבור המערך items. הפונקציה pop מוציאה מספר מהמחסנית, ומכניסה ערך זה למשתנה שהפרמטר result מצביע אליו (אם המחסנית ריקה pop תשים שם את הערך 1-). הפונקציה push מכניסה מספר למחסנית. ניתן להניח ש push תמיד תקבל מספר חיובי. על הפונקציות push ו- popלדאוג שהשדה number_of_items יישאר מעודכן. כתבו תכנית המדגימה את פעולת הפונקציות שכתבתם.

זהו הקוד שבניתי, לא מבין מדוע הוא לא עובר קומפילצייה?!

[code]#include <stdio.h>
#include <stdlib.h>

typedef struct stack_t
{
	int *items;
	int number_of_items;
	int max_size;

}stack;


stack create_stack(stack *miv)
{

	miv->items=(int*) calloc(1 * sizeof(int));
	miv->max_size=1;
	miv->number_of_items=1;

	return miv;
}

void delete_stack(stack miv)
{
	free(miv->items);
}

stack pop(stack miv,int *result)
{
	if (miv->number_of_items==0)
		*result=-1;
	else
		if (miv->number_of_items>0)
		{
			*result=miv->items[1];
			miv->number_of_items--;
		}
	return 0;
}

stack push(stack miv,int item);
{
	int* temp;
	int i;

	if (miv->number_of_items<=1)
	{
		temp=(int*) calloc((miv->number_of_items) * sizeof(int));
		for (i=0; i<miv->number_of_items; i++)
			temp[i]=miv->items[i];
		free (miv->items);
		miv->items=(int*) calloc(((miv->number_of_items)*2) * sizeof(int));
		for (i=0; i<miv->number_of_items; i++)
			miv->items[i]=temp[i];
		miv->items[0]=item;
	}

}

int main()
{

	return 0;
}

תודה רבה!

[שניצל]

זהו הקוד שבניתי, לא מבין מדוע הוא לא עובר קומפילצייה?!

איך אני אמור לדעת אם אתה לא רושם פה מהי הודעת השגיאה?

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

[TheSlider]

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

[שניצל]

realloc.

[TheSlider]

תודה באמת שימושי!

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

שאר השדות הם של המבנה שהוגדר עוד קודם והוא:

typedef struct stack_t
{
	int *items;
	int number_of_items;
	int max_size;

}stack;

השדות הם:

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

זאת הפונקציה שבניתי אבל היא נופלת בקומפילציה על החזרת של NULL למקרה שההקצאה הדינמית לא הצליחה.

איפה הטעות כאן?

stack create_stack(void)
{
	stack *s = (stack*)malloc( sizeof(stack) );
  if ( s == NULL )
		return NULL;

	s->items=((int*) malloc(1 * sizeof(int)));
	s->max_size=1;
	s->number_of_items=0;
	if ( s->items == NULL )
  {
    free(s);
   return NULL;
  }
	return s;
}

[שניצל]

למה אתה מקצה את s דינמית?

[TheSlider]

איך אני אמור להקצות אם לא כך?

אשמח להצעה אחרת שכן תעבוד

[שניצל]

סטטית, בדיוק כמו שהיית מקצה כל משתנה פרימיטיבי (int, float וכו').