זיכרון דינאמי

הקצאת זיכרון דינאמי

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

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

#include <iostream>
using namespace std;
 
void main(){
 int *ptr = new int;
 *ptr = 5;
 cout<<*ptr<<"\n"; // ידפיס 5
}

לשחרור זיכרון עבור משתנה בודד נשתמש באופרטור delete.
לדוגמה:

#include <iostream>
using namespace std;
 
void main(){
 int *ptr = new int;
 *ptr = 5;
 cout<<*ptr<<"\n";
 delete ptr;
}

מספר רנדומלי, ודיליי (השהייה) ב ++C

מספרים רנדומליים

בשפת C למדנו על מספרים רנדומליים.
נראה בקצרה איך זה עובד ב ++C.

א. נוסיף את הספרייה:
                          < ctime>
ב. נכתוב פעם אחת בפונקצייה main את השורה:

                                                                                                                                        srand( time(0));

ג. נקבל מספר רנדומלי ע"י:
                      rand() % 2


כדי להגביל את טווח המספרים משתמשים ב %
כך:

                                                                                                                                        int x = rand() % 10;

כעת x יהיה מספר בין 0-9

או:

                                                                                                                                        int x = rand() % 10+1;

כעת x יהיה מספר בין 1-10

שאלות חזרה ב sql

שאלות:

משתנה מיוחס

משתנה מיוחס

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


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

#include <iostream>
using namespace std;
void swap(int &a,int &b){
 int temp;
 temp=a;
 a=b;
 b=temp;
}
void main(){
 int num1=5,num2=10;
 swap(num1,num2);
 cout << num1 << "  " << num2 << "\n";
}

חפיפת פונקציות וברירת מחדל

חפיפת פונקציות

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

היום נראה שזה מותר. באחד מהתנאים:

-הפונקציות בעלות השם הזהה מקבלות מספר שונה של פרמטרים.
-הפונקציות בעלות השם הזהה מקבלות פרמטרים מסוגים שונים.
-הפונקציות בעלות השם הזהה מקבלות מספר שונה של פרמטרים, וגם מסוגים שונים.

דוגמה:

#include <iostream>
using namespace std;
 
int f1(){  //1
 return 5*3;
}
int f1(int x, int y){ //2
 return x*y;
}
 
double f1(double x, double y){  //3
 return x*y;
}
double f1(int x, double y, int z){  //4
 return x*y*z;
}
void main(){
 cout<<f1()<<"\n";         // 15
 cout<<f1(7,8)<<"\n";      // 56
 cout<<f1(7.5,8.5)<<"\n";  // 63.75
 cout<<f1(2,0.5,5)<<"\n";  // 5
 cout<<f1(2,5,6)<<"\n";    // 60
}

פונקציה בונה

פונקציה בונה ב class שלנו

לרוב נרצה שתהיה "פונקציה בונה" (Constructor) בכל class.
תפקידה להכניס ערכים ראשוניים לחלק/לכל המשתנים של האובייקט.

-שמה יהיה זהה לשם ה class.
-תמיד תהיה בעזור ה public.
-תפעל באופן אוטומטי. כל פעם שנוצר אובייקט חדש.
-היא יכולה לקבל ארגומנטים, אך לא חייבת.
-היא לא מחזירה ערך. ולא מציינים עובדה זו ע"י void.


לדוגמה:

מרכיבים עיקריים של מערכת מבוססת מיקרו מחשב

מרכיבים עיקריים של מערכת מבוססת מיקרו מחשב

מצגת הסבר מקיפה.
להורדה: כאן או כאן