הסבר קוד C++

[brokenn]

הסבר קוד C++

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

#include <stdio.h>
#include <stdlib.h>
int* func(int vec[],int n);
void main(){
int i, vec[10]={0}, *ptr, *ptr1;
int k=sizeof(vec)/sizeof(vec[0]);
ptr = func(vec ,k);
ptr1=ptr+k-1;
printf("in main :\n");
for(i=0; i<k; i++){
vec=*(ptr1-i);
printf("%3d, %3d\n",vec,*(ptr+i));
}
free((void *)ptr);
getch();
}

int* func(int vec[],int n){
int i,*ptr;
ptr=(int*)malloc(n*sizeof(int));
if(!ptr){printf("alloc failed"); getch();exit(1);}
for(i=0;i<n;i++){
vec=n-i;
*(ptr+i)=i*i;
printf("%3d, %3d\n",vec,*(ptr+i));
}
return ptr;
}

 

[freak2100]

הן סתם מנסים לבלבל אותך

תנסי בכל שורה להבין, לא רק טכנית מה קורה, אלא גם לוגית מה קורה.
למשל, בשורה הזו:

ptr1=ptr+k-1;

האם את מבינה לאן ptr1 מצביע? מה זה אומר? איך אפשר להשתמש בו?
ועוד לפני זה - מה מכיל ptr, מה זה k וכן הלאה...

 

[freak2100]

הם*

 

[brokenn]

זאת הבעיה שאני לא מבינה

 

[freak2100]

תתחילי ממה שאת כן יודעת

לאט לאט:
מה זה vect?
מה זה k?
מה קורה ל-ptr ול-vect אחרי הקריאה לפונקציה?

תעני על השאלות האלה, נמשיך משם.

 

[brokenn]

טוב אז ככה

k שווה לגודל של המערך vec בבתים חלקי גודל התא הראשון בבתים כלומר גודל int אחד שזה 10*4/4=10 שזה אורך המערך
vec - מערך בגודל 10 של int ואיתחולו לאפס
המצביע ptr מקבל את הכתובת שהפוקציהfunc מחזירה עם קריאה לה עם כתובת המערך vec ואורכו k .

 

[freak2100]

סבבה,

k הוא למעשה אורך המערך vec. לא משנה איזה טיפוס יהיה ב-vec, החישוב שם יעבוד.
איזה כתובת מחזירה הפונקציה func? מה יש בה?

 

[brokenn]

המשתנה ptr ב main

יצביע למקום הראשון במערך שהוקצה בפונקציה func .

 

[freak2100]

תפרטי

איך נראה המערך הזה? מה יש בו?
תנסי לצייר אותו, ואז לראות מה קורה בשורה של ptr1, לאן הוא מצביע.

 

[brokenn]

כבר גילו לי

שהוא מצביע לאיבר האחרון במערך אבל אני לא מצליחה להבין למה

 

[BravoMan]

משהו שאת צריכה להבין לגבי "חשבון מצביעים":

אם יש לך מצביע ל-int נגיד ככה:

int *ptr;

כשמוסיפים למצביע 1 המצביע למעשה זז 4 בתים, כגודל הטיפוס שהוא מצביע עליו (int במקרה שלנו)

אז, אם מאתחלים מצביע לתא הראשון במערך, ואז מוסיפים 1, הוא הופך למצביע לתא השני במערך:

int arr[5];
int *ptr = &arr[0];

ptr = ptr + 1;

if (ptr == &arr[1])
printf("Now pointing to arr[1]\n");


את מוזמנת לנסות את הקוד הזה ולראות שהוא פועל.

כעת, תזכרי מה הוא k.
אם k - 1 היה אינדקס במערך, של איזה איבר הוא היה?

 

[brokenn]

אההה

רז הוא מצביע חתא האחרון במכרך?
Ptr1=ptr+k-1
מה שמוזר לי זאת הצורת כתיבה
זה לא ברור לי למה לא רשום נגיד* לפני

 

[BravoMan]

כי לא ניגשים לערך, אלא משנים את הכתובת עצמה:

כשכותבים * לפני מצביע, פרוש הדבר שרוצים לגשת לערך ששמור בכתובת שבתוך המצביע.

אבל זה לא מה שעושים בשורה הזו.
כאן, משנים את הכתובת עצמה.

תחשבי על מצביע כעל מספר פשוט (וזה באמת כך).
כאן לוקחים את המספר שיש בתוך prt, מחברים עליו k (כפול 4 כי זה int) ומחסירים 1 (שוב, כפול 4).
את התוצאה מאחסנים ב-ptr1.

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

 

[brokenn]

סבבה

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

* func(int vec[],int n);
void main(){
int i, vec[10]={0}, *ptr, *ptr1;
int k=sizeof(vec)/sizeof(vec[0]);
ptr = func(vec ,k);
ptr1=ptr+k-1;כאן אנחנו ניגשים לכתובת של הערך האחרון במערך?
printf("in main :\n");
for(i=0; i<k; i++){הללואה מתחילה מהתא האחרון במערך?
vec=*(ptr1-i);התא הראשון במערך יקבל את הערך של התא האחרון בPTR וכו?
printf("%3d, %3d\n",vec,*(ptr+i));
}

 

[BravoMan]

כן, נראה נכון...

 

[freak2100]

כמעט...

את לא ניגשת לכתובת של הערך האחרון במערך, את רק מחשבת את המצביע אליו. לגשת אליו זה אחר כך כשאת מוסיפה * לפני ptr1 או ptr1-i.
הלולאה רצה מ-0 עד k לא כולל, מבחינת הלולאה אין חשיבות לתא ראשון או אחרון. זה ש-ptr1 מצביע לתא האחרון במערך, ואז ממנו כל פעם הולכים אחורה כשהלולאה מתקדמת (כי מחסירים את i), זה גורם לנו לעבור על המערך מהסוף להתחלה.

 

[brokenn]

שאלה נוספת-מיון מערך(סליחה על החפירות[: )

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

 

[brokenn]

התחלתי לכתוב קוד ואינני יודעת איך להמשיך

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
void Get_Lost(char *s);
void main()
{
unsigned n;
int *ptr,i,j;
printf("enter the number of integers:");
scanf("%u",&n);
ptr=(int *) malloc(n*sizeof(int));
if(!ptr)
Get_Lost("no memory is available, exit");
printf("enter %u integers: ",n);
for(i=0;i<n;i++)
scanf("%d",&ptr);

 

[nocgod]

מה זאת אומרת מיון עם הקצאה דינאמית?

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

לגבי הקוד שהבאת בהודעה הבאה: כל מה שכתבת זה הקצאת זיכרון (ובדיקה שהזיכרון התקבל...עם פונקציה מוזרה) וקליטה של מידע למערך שזה עתה הקצאת.
איפה ניסיון לממש את bubble sort? איפה הניסיון לממש את פונקציה swap?

 

[טרול המתכנן]

merge sort