תכנות מכוון עצמים ו- C++ יחידה 02 העמסת פונקציות, ערכי ברירת מחדל, enum, קימפול מותנה קרן כליף

נכון שזה נכון?? אז די! http://programmingpalace.files.wordpress.com/2011/12/smokingwarningforsoftwareengineers.jpg

ביחידה זו נלמד: ranged based for loop auto string literals העמסת פונקציות ערכי ברירת מחדל לפונקציות enum תזכורת לבעיית ה- include'ים כפולים

Ranged Based For-Loop ניתן לרוץ על לולאה ללא אינדקס! C++11 1 2 3 4 5 void main() { int arr[] = { 1,2,3,4,5 }; for (int x : arr) cout << x << " "; cout << endl; for (int& x : arr) x = x*x; } 1 2 3 4 5 1 4 9 16 25 חסרון: לולאה זו מתאימה רק למערכים עליהם רוצים לעבור באופן סדרתי על כל האיברים מההתחלה לסוף (אי אפשר למשל לעבור רק על מיקומים זוגיים וכד')

על משתנה מטיפוס זה ניתן להפעיל את הפונקציה name() שמחזירה את שם הטיפוס auto C++11 ניתן להגדיר משתנים ללא טיפוס ספציפי! typeid היא פונקציה המקבלת משתנה או טיפוס ומחזירה משתנה מטיפוס type_info, המחזיק מידע על טיפוס. על משתנה מטיפוס זה ניתן להפעיל את הפונקציה name() שמחזירה את שם הטיפוס void main() { auto a = 5; auto* b = &a; auto c = &a; auto& d = a; auto x; cout << typeid(a).name() << endl; cout << typeid(b).name() << endl; cout << typeid(c).name() << endl; cout << typeid(d).name() << endl; d = 3; cout << a << " " << d << endl; char ch = 'a'; c = ch; } טיפוסו של המשתנה נקבע מיד עם אתחולו ולכן חייב להיות ידוע בזמן קומפילציה int int * 3 3 // cannot convert from 'char' to 'int *'

auto + ranged for loop void main() { char* daysOfWeek[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; for (auto day : daysOfWeek) cout << day << " "; cout << endl; }

Raw String Literals C++11 כדי להציג למסך תווים מיוחדים (גרשיים, גרש, סלש וכד') יש לשים לפניהם \, מה שלפעמים יכול להיות מעיק, וכן להציג טקסט עם ירידות שורה הפתרון הוא Raw String Literals! void main() { char* s1 = "\"Hello World\""; cout << s1 << endl; char* s2 = R"("Hello World")"; cout << s2 << endl; char* s3 = "\"foo()\""; cout << s3 << endl; char* s4 = R"("foo()")"; char* s4 = R"##("foo()")##"; cout << s4 << endl; } נעטוף את הטקסט שנרצה שיוצג ב- R”(The Text)” "Hello World" "foo()" הבעיה: יש את הרצף "( בתוך הטקסט הפתרון: לעטוף את הסוגריים ברצף כלשהו לבחירתכם (פה בחרתי ##)

העמסת פונקציות (Functions Overloading) כלומר, ניתן להגדיר פונקציות דומות עם שם זהה, המקבלות טיפוסים שונים דוגמה: void swap(int& a, int& b) { int temp = a; a = b; b = temp; void swap(char& a, char& b) char temp = a; void main() } int n1=3, n2=6; swap(n1, n2); char ch1='a', ch2='z'; swap(ch1, ch2); {

בעית דו-משמעות (ambiguity) הקומפיילר אינו יכול להבדיל בין 2 פונקציות הנבדלות אך ורק בערך המוחזר הסיבה: לא בהכרח יהיה שימוש בערך המוחזר דוגמה: int foo() {return 0;} char foo() {return 'a';} void main() { foo(); הקומפיילר לא ידע לאיזו גרסא לפנות, ונקבל שגיאת ambiguity: error C2371: 'foo' : redefinition; different basic types

בעית דו-משמעות (ambiguity) (2) גם במקרה זה הקומפיילר לא ידע לאיזו גרסה לפנות: void foo(double d) {} void foo(float f) {} void main() { double d = 5.2; float f = 7.3f; foo(d); foo(f); } void foo(double d) {} void foo(float f) {} void main() { int x=3; foo(x); דוגמא תקינה error C2668: 'foo' : ambiguous call to overloaded function הקומפיילר לא יודע אם להמיר את x ל- double או ל- float בעיית ה- ambiguity אינה בעיה של הפונקציות, אלא של אופן הקריאה, שאינו מורה לקומפיילר באופן חד-משמעי לאיזו גרסא לפנות

ערכי ברירת מחדל (default values) בשפת C++ ניתן לתת ערך ברירת מחדל לפרמטרים האחרונים שהפונקציה מקבלת, ובכך יהיה ניתן בשימוש להחסיר ארגומנטים אלו התוצאה היא העמסת הפונקציה void printChar(char ch='*', int times=5); void main() { printChar('#', 3); printChar('@'); printChar(); void printChar(char ch, int times) } for (int i=0 ; i < times ; i++) cout << ch; cout << endl; במקרה של הפרדה בין ההצהרה למימוש, ערכי ברירת המחדל יכתבו בהצהרה העמסת 3 פונקציות במחיר מימוש של אחת 

ערכי ברירת מחדל (2) void printChar(char ch='*', int times=5); void printChar(int times, char ch='*'); void main() { printChar('#', 3); printChar('@'); printChar(); printChar(8); void printChar(char ch, int times) } for (int i=0 ; i < times ; i++) cout << ch; cout << endl; void printChar(int times, char ch) printChar(ch, times); נשים לב כי לא ניתן לתת ערך ב"מ לפרמטר times, משום שנקבל שגיאת ambiguity במידה ויקראו לפונקציה ללא פרמטרים קריאה לפונקציה הראשונה קריאה לפונקציה השניה לא ניתן היה להגדיר את את הפונקציה הבאה: void printChar(int times=5, char ch); משום שערכי ב"מ ניתן לתת רק לפרמטרים האחרונים ברשימה. אחרת, הקריאה לפונקציה תצטרך להיות: printChar( , ‘*’) וזה לא תקין

enum הגדרת טיפוס חדש שיכיל ערך מספרי מתוך קבוצה מוגדרת מראש כלומר, הגדרת אוסף קבועים בעלי קשר לוגי למשל: ימות השבוע, אוסף צבעים, ערכים בוליאנים וכד' דוגמה: enum eColor {RED, YELLOW, BLUE}; זוהי הגדרה של 3 קבועים, הראשון מקבל באופן אטומטי את ערך 0, זה שאחריו את ערך 1 וכו'. כעת נוכל להגדיר בתוכנית משתנים מטיפוס color ולתת להם את הערכים RED/YELLOW/BLUE

enum - מתן ערך שגוי אם ניתן למשתנה מטיפוס ה- enum ערך מספרי שאינו הוגדר בקבוצת הערכים שלו, נראה את הערך המספרי (לא נקבל שגיאה) קליטה לתוך enum צריכה להתבצע לתוך int ואז לבצע המרה enum eColor {RED, YELLOW, BLUE}; void main() { eColor c1 = RED; cout << "c1=" << c1 << endl; eColor c2 = (eColor)5; cout << "c2=" << c2 << endl; eColor c3; //cin >> c3; int colorNum; cin >> colorNum; c3 = (eColor)colorNum; } הקומפיילר לא מבצע casting מ- int לטיפוס החדש, לכן צריך לעשות המרה מפורשת

טריק לקבלת שמו של enum ניתן להגדיר מערך גלובלי של מחרוזות עם שמות ה- enum בהתאמה לערכיהם enum eColor { White, Black, Red, Yellow, Blue }; const char* colors[] = { "White", "Black", "Red", "Yellow", "Blue" }; void main() { eColor c = Red; cout << "Selected color is " << colors[c] << endl; }

מאחר ולא נתנו ל- Red ערך, ערכו יהיה ערך עוקב לקבוע שלפניו enum – מתן ערכים שונים ניתן לכל ערך באוסף לתת ערך שאינו עוקב לערך שלפניו, ע"י השמה: מאחר ולא נתנו ל- Red ערך, ערכו יהיה ערך עוקב לקבוע שלפניו enum eColor { White = 10, Black = 20, Red, Yellow = 40, Blue = 50 }; void main() { eColor c1 = (eColor)1, c2 = (eColor)20, c3 = (eColor)21, c4 = (eColor)45; }

Enhanced Enums enum eColor { Red, Yellow, Green }; enum eGrades:char {A, B, C}; //enum eGrades:char { 'A', 'B', 'C' }; void main() { eColor c1 = Red; eColor c2 = eColor::Red; char mathGrade = eGrades::A; cout << "Math grade is " << mathGrade << endl; char physicsGrade = eGrades::B + 'A'; cout << "Physics grade is " << physicsGrade << endl; } הערכים תמיד צריכים להיות מאותחלים כמספרים ניתן (ועדיף!) לפנות לערך בקבוצה עם שם הטיפוס. יותר קריא! למרות שהגדרנו את הטיפוס כ- char, הערכים סדרתיים ומתחילים מ- 0 Math grade is Physics grade is B

Enhanced Enums - הפתרון enum eGrades:char { A='A' , B, C}; void main() { char mathGrade = eGrades::A; cout << "Math grade is " << mathGrade << endl; char physicsGrade = eGrades::B/* + 'A'*/; cout << "Physics grade is " << physicsGrade << endl; } Math grade is A Physics grade is B

Enum Classes ניתן להגדיר את ה- enum כ- class, ואז חלות עליו מספר הגבלות enum class eSeason {Winter, Spring, Summer, Fall }; void main() { int s1 = eSeason::Summer; int s2 = (int)eSeason::Winter; int s3 = Fall; } אין המרה אוטומטית ל- int הפניה לערך חייבת להיות לכלול את שם המחלקה

תזכורת: פעולת ה- include פעולת ה- include היא פקודת קדם-מעבד (preprocessor) אשר שותלת בקוד במקום כל פקודת include את תוכן הקובץ שאותו כללנו בפקודה a.h struct A { int x; }; struct A { int x; }; void main() } main.cpp #include "a.h" void main() } {

הבעיתיות בפקודת include a.h struct A { int x; }; struct A { int x; }; // prototypes void foo(); void main() } נקבל שגיאה של redefinition מאחר והקומפיילר רואה את ההצהרה על המבנה שמוגדר ב- a.h יותר מפעם אחת b.h #include "a.h" // prototypes void foo(); main.cpp #include "a.h" #include "b.h" void main() } {

הפתרון: הידור מותנה ראינו בעבר את הפקודה #define לצורך הגדרת קבוע מסוים פקודה זו מוסיפה את הקבוע שהוגדר לטבלת סימולים של התוכנית במידה וטרם הוגדר. במידה וכבר הוגדר דורסת את ערכו. ניתן גם לכתוב פקודת define ללא ערך, רק כדי להכניס קבוע מסוים לטבלת הסימולים ניתן לבדוק האם קבוע מסוים הוגדר בטבלת הסימולים בעזרת הפקודה #ifdef או אם לא הוגדר בעזרת הפקודה #ifndef במידה והתנאי מתקיים, הקופיילר יהדר את קטע הקוד הבא עד אשר יתקל ב- #endif

כעת יש לנו ב- main פעם אחת בלבד את ההגדרות מכל קובץ הפתרון עם הידור מותנה a.h b.h #ifndef __A_H #define __A_H struct A { int x; }; #endif // __A_H #ifndef __B_H #define __B_H #include "a.h" // prototypes void foo(); #endif // __B_H main.c לאחר preprocessor struct A { int x; }; // prototypes void foo(); void main() } foo(); כעת יש לנו ב- main פעם אחת בלבד את ההגדרות מכל קובץ main.cpp #include "a.h" #include "b.h" void main() } foo(); { טבלת הסימולים: __A_H __B_H

הקומפיילר אינו מכיר את הטיפוס A ולכן שגיאת הקומפילציה... בעיה נוספת ב- include כאשר יש 2 מבנים אשר כל אחד מגדיר אובייקט מטיפוס המבנה השני, מתקבלת שגיאת קומפילציה שקשה להבינה: #ifndef __A_H #define __A_H #include "b.h" struct A { B b; }; #endif // __A_H #ifndef __B_H #define __B_H #include "a.h" struct B { A a; }; #endif // __B_H הקומפיילר אינו מכיר את הטיפוס A ולכן שגיאת הקומפילציה... #include "a.h" #include "b.h" void main() } { טבלת הסימולים: __A_H __B_H

הצהרה שהמחלקה תוגדר בהמשך הפתרון במקרה זה נדאג שלפחות אחד המבנים יכיל רק מצביע למבנה השני, ולא אובייקט כאשר יוצרים אובייקט צריך לבצע include לקובץ המגדיר אותו כאשר יש מצביע לאובייקט לא חייבים לבצע include לקובץ המכיל אותו, אלא להסתפק בהצהרה שמבנה זה יוגדר בהמשך בקובץ cpp בו תהיה היצירה של האובייקט נבצע את ה- include לקובץ בו מוגדר המבנה #ifndef __A_H #define __A_H #include "b.h" struct A { B b; }; #endif // __A_H #ifndef __B_H #define __B_H struct A; struct B { A* a; }; #endif // __B_H הצהרה שהמחלקה תוגדר בהמשך

ביחידה זו למדנו: ranged based for loop auto string literals העמסת פונקציות ערכי ברירת מחדל לפונקציות enum תזכורת לבעיית ה- include'ים כפולים