שאלות ב java

שאלות:

להורדה כאן או כאן

חבר (friend) של המחלקה

Friend

ראינו שאין לשום דבר מחוץ למחלקה גישה למשתנים ולפונקציות שבחלק ה private של המחלקה.
יש יוצא דופן:
אם נגדיר פונקציה/מחלקה כלשהי כ friend של מחלקה, היא תוכל לגשת לכל התוכן ה private של אותה מחלקה.

מבנה של מחלקה חברה:

class First{

         .

         .

         .

public:

friend class Second; // זה שם מחלקה האחרת Second 

         .

         .

         .

};

-כך מצהירים על המחלקה Second כ friend של המחלקה First.

אילו סוגי זכרונות יש

מאמר מאת: www.4project.co.il


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

קודם כל מה זה זיכרון?
זהו רכיב או איזור ברכיב כלשהו שמסוגל לזכור מצב של ביט או סדרה של ביטים. יש הרבה טכנולוגיות של זכרונות, כאלה שמאפשרים לשנות את מצב הביטים במהירות, כאלה שלא מאפשרים לשנות בכלל או כאלה שמאפשרים לשנות, אבל זה לא כל כך פשות. חלק מהטכנולוגיות יכולות לשמור על מצב הביטים גם כשלרכיב לא מספקים זרם וחלק דורשים הספקת זרם כדי לפעול.
לרכיבי זכרון יש קווי כתובת (Address) שמציינים את מיקום הביטים אותם אתם רוצים לקרוא או לכתוב וקווי Data שמציינים את ערך הביטים בקריאה או כתיבה. יש גם קווים נוספים כמו ChipSelect שעוזר לעבוד עם כמה רכיבים המחוברים לאותם קווי Address, קו Enable ועוד אחרים שיכולים להשתנות בהתאם לסוג הרכיב והטכנולוגיה.

ROM - Read Only Memory
זכרון לקריאה בלבד. תחשבו עליו כאוסף של חוטים שחלק חתוכים שלא מוליכים וחלק שלמים שכן מוליכים. כלומר חלק יחזירו 0 לוגי וחלק 1 לוגי כשקווי הכתובת יצביעו עליהם. מצב החוטים/הביטים בדרך כלל נקבע במהלך היצור של הרכיב.

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

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

פונקציה הורסת Destructor

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

- שם הפונקציה ההורסת זהה לשם המחלקה. אבל בתוספת התו ~ לפניו.
- התחביר זהה לזה של פונקציה בונה, לכן לא נמצא שום "סוג ערך מוחזר" לפני שם הפונקציה. גם לא void.
- לא מקבלת ולא מחזירה נתונים. לכן לעולם לא תהיה יותר מפונקציה הורסת אחת במחלקה.
- תפקידה להשמיד את האובייקט (דבר שלפעמים נחוץ).
- בשפת ++C אין חובה לכתוב פונקציה הורסת. בין אם יש ובין אם אין פונקציה בונה.

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

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

בשפת 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.


לדוגמה:

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

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

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

מאמר מבוא למערכות הפעלה

מאמר של מוטי על מערכות הפעלה:

להורדה: כאן או כאן

דוגמית:

מבני נתונים - מבוא

מבני נתונים - מצגת מבוא:

קישור להורדה

מקור: מכללת אורט כפר-סבא

מהו CLASS

class  -  מחלקה

ה class מתנהג כמו ה struct של שפת C. אבל עם תחביר מעט שונה והרבה תכונות נוספות.


הדוגמה הפשוטה:

class Item{
public:        // נסביר בהמשך מה משמעות השורה הזאת, כרגע פשוט נכתוב אותה
 int a;
 int b;
 char c;
};
 
void main(){
 Item q1;
 q1.a = 5;
 q1.b = 10;
 q1.c = 'A';
 cout <<q1.a<<"\n"<<q1.b<<"\n"<<q1.c<<"\n";
}

כפי שרואים, בניגוד ל struct כאן אין צורך לכתוב את המילה "class" כל פעם שמכריזים על משתנה.

מ C אל ++C

ההבדלים בין C ל ++C

אחרי שלמדנו שפת C, נתחיל ללמוד ++C.

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

הבדלים חשובים:

C
על מנת ליצור ב Visual Studio תוכנית היה עלינו להשמיט את ה "pp" מסיומת הקובץ ("Source.c" במקום "Source.cpp").

++C
ב ++C לא נשמיט.

שפת C - מצביע לפונקציה, qsort , bsearch ומשתנה const

מצביע לפונקציה

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

מבנה כללי:

     ; (הארגומנטים שהפונקציה מקבלת)   (שם_המצביע *)   סוג הערך שהפונקציה מחזירה


לדוגמה אם יש פונקציה בשם "F":

double F(int a, int b, char c) { ...... }

אז כדי שמצביע "p" יוכל להצביע עליה, צריך להגדיר אותו כך:

double (*p) (int a, int b, char c);

ואז נוכל להכניס אליו את הכתובת של הפונקציה:

p = F ;

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

שפת C - עוד חזרות פשוטות

משולש שווה שוקיים

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

לדוגמה:

שפת C - משחק בול פגיעה

עוד תרגילים וחזרות על חומר ישן

ננסה ליצור את המשחק "בול פגיעה" (Bulls and Cows)

למי שלא מכיר כך עובד המשחק:
*המחשב בוחר רצף של 4 ספרות שונות בסדר אקראי.
*השחקו מנסה לנחש מה הספרות (בסדר הנכון)

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

~משחק חשיבה נחמד ומומלץ לכולם~
ראו גם: וויקיפדיה

שפת C - עוד על define ו enum

define מתקדם

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

-השם הרשמי להגדרות כאלו הוא "מאקרו" (macro).
-נראה היום שאפשר לעשות פעולות מתקדמות יותר עם define. בדומה לפונקציות:

#include <stdio.h>
#define p(a) printf("%d\n",a)
void main(){
 int x=3,y=8;
 p(x);
 p(y);
}

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

printf("%d\n",מספר)

גם תווים:

#include <stdio.h>
#define p(a) printf("%c\n",a+1)
void main(){
 p('e');
 p('E');
}

שפת C - הגדרת טיפוס typedef

הגדרת טיפוס - typedef

התפקיד של typedef זה להקל על מתכנתים ע"י הגדרת שם לטיפוס (סוג) חדש, או ע"י הגדרת שם נוסף לטיפוס קיים.
השימוש ב typedef הופך את התוכנית ליותר קריאה, ולעיתים גם ליותר קצרה.
הפקודה נכתבת מחוץ לכל הפונקציות. בדומה לinclude ולמשתנים גלובאלים.

מבנה כללי:

typedef     שם_חדש     שם ישן ;   

לדוגמה:
p1 ו p2 הם מסוג int בשתי התוכניות הבאות:

#include <stdio.h>
void main(){
 int p1 , p2;
.
.
.
}

//// 
 
#include <stdio.h>
typedef int phone;
void main(){
 phone p1 , p2;
.
.
.
}