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

המהדר

אנו נשתמש במהדר $g++$ כדי להדר קוד $C++$ אשר ימצא בקבצי מקור בעלי סיומת $cpp,c$ או $C$ (גדולה).
פקודת הקימפול תראה כך:

$ g++ -std=c++17 -Wall -Werror -pedantic-errors main.cpp -o HelloWorld

תוכנית $Hello\; World$ ב-$C++$

כפי שנאמר מקודם ישנם כמה שינויים בתכנות ב-$C++$. נראה כמה מהם כעת.
השינוי הראשון שהוא שקבצי ה-$\#include$ הסטנדרטיים של $C++$ הם ללא סיומת. למשל, $\#include\; <\!\! iostream\!\!>$.
בואו נראה את התוכנית:

#include <iostream>
using namespace std;

int main()
{
	cout << "Hello world" << endl;
	return 0;
}

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

קלט ולפלט

קלט ופלט מבוצעים ב-$C++$ באמצעות $streams$ כאשר:

• קליטה מבוצעת ע"י $istream$.
• פליטה מבוצעת ע"י $ostream$.

קריאה וכתיבה לסטרימים מתבצעות באמצעות אופרטור קלט $>>$ ואופרטורי פלט $<<$.
הסטרים $cin$ משמש לקריאה מהקלט הסטנדרטי והסטרים $cout$ משמש לכתיבה לפלט הסטנדרטי.
ניתן להדפיס תו ירידת שורה באמצעות הקבוע $endl$.
בנוסף, ניתן לשרש מספר הדפסות באותה הפקודה.

int i;
double d;
char c[100];

...

cin >> i; // reading input as integer
cin >> d; // reading input as double
cin >> c; // reading input as c string (SHOULD BE AVOIDED!)

...

cout << "this is i: " << i << endl << "this is d: " << d << endl << "this is c: " << c << endl;

קליטה ברציפות

ניתן לבדוק האם סטרים קלט הסתיים באמצעות הפעולה(בעצם שיטה(שזה $method$)) $eof$ כך:

while (!cin.eof())
{
	// read some input and do stuff...
}

הסטרים מסתיים כאשר הוא מקבל את התו המיוחד $eof$ המייצג סיום.

• כאשר מפנים קלט מקובץ - תו זה מועבר אוטומטית בסוף הקובץ
• כאשר כותבים קלט בטרמינל - ניתן להעביר את התו במפורש באמעות $Ctrl+D$.

מחרוזות

ב-$C++$ מוגדר עבורינו הטיפוס $string$ ב-$std$ המייצג מחרוזת.
על מנת להשתמש בו נדרש להכניס אותו לתוכנית שלנו כך:

#include <string>
using std::string

את זה נכתוב בראש הקובץ.
השימוש ב-$string$ מסיר את הצורך בניהול מפורש של הזכרון.

נשתמש ב-$string$ כך:

int main()
{
	string s = "Learning how to use string";
	string s2 = "spring semester";
	string s3 = s + " " + s2;
	s3[s3.size() - 1] = "!";
	cout << s3 << endl;
	return 0;
}

פעולות על מחרוזות

1. שרשור מחרוזות - באמצעות אופרטור החיבור $+$
2. העתקת מחרוזות - באמצעות אופרטור ההשמה $=$
3. גישה לתו במחרוזת - באמצעות אופרטור הסוגריים המרובעים $[\;]$
4. אורך המחרוזת - מוחזר מהמתודה $size$
5. השוואה לקסיקוגרפית של מחרוזות - בעזרת אופרטורי ההשוואה ($\dots,==,>,<$)

קריאת וקליטת מחרוזות

קריאה

ניתן לקרוא מחרוזות מהקלט עד "התו הלבן"(רווח/טאב/ירידת שורה) באמצעות אופרטור הקלט $>>$.
אם נרצה לקרוא שורה שלמה כולל רווחים, נוכל לבצע זאת באמצעות הפקודה $getline$ כך:

string s;
cin >> s; // reads a single word
getline(cin, s); // read until the end of the line

#include <iostream>
#include <string>

using namespace std;

int main()
{
	string s;
	while (!cin.eof())
	{
		getline(cin, s);
		cout << s << endl;
	}
	return 0;
}

מצביעים

במצביעים הכל נשאר אותו הדבר מ-$C$ (במצביעים רגילים בלבד) אך כן יש כמה שיפורים.

• במקום לכתוב $NULL$ אנו נשתמש בקבוע החדש $nullptr$.

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

העברת פרמטרים ל-$main$

ראינו בפקודות ה-$shell$ קבלה של ערכים בתוך שורת הפקודה. איך נעשה זאת עם תוכניות $C++$?
נכתוב את הפעולה הראשית שלנו כך:

int main(int argc, char** argv)

במקרה זה יילקחו הערכים משורת ההרצה של התכנית ויושמו לתוך המשתנים שקיבלנו ע"י מערכת ההפעלה בתצורה הבאה:

• המשתנה $argc$ יאותחל למספר הארגומנטים בשורת הפקודה(כולל שם הפקודה)
• המשתנה $argv$ הוא מערך של מחרוזות כאשר התא ה-$n$ בו יכיל את הארגומנט ה-$n$ בשורת הפקודה. תא $0$ יכיל את שם התוכנה שהורצה.
  • בנוסף, קיים איבר אחרון נוסף במערך המאותחל ל-$NULL$.

echo Hello world

char** argv = {"./echo", "Hello", "world", NULL};
int argc = 3;

הפתרון שלי:

#include <iostream>
#include <string>
using namespace std;

int main(int agrc, char** argv)
{
	for (int i = 1; i < argc; i++)
	{
		cout << argv[i] << " ";
	}
	cout << endl;
	return 0;
}

הפתרון שלהם:

#include <iostream>
#include <string>
using namespace std;

int main(int agrc, char** argv)
{
	for (int i = 1; i < argc; i++)
	{
		if (i != 1)
			cout << " ";
	
		cout << argv[i];
	}
	cout << endl;
	return 0;
}

הצעה נוספת לפתרון:

#include <iostream>
#include <string>
using namespace std;

int main(int agrc, char** argv)
{
	argv++;
	while (argv != NULL)
	{
		cout << *argv << " ";
		argv++;
	}
	cout << endl;
	return 0;
}

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

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

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

עוד סוג של יצור הוא זיכרון שמוקצה דינמית שהוא זיכרון שזמן החיים שלו הוא בשליטת המתכנת. זיכרון זה מוקצה באיזור שקרוי ה-$heap$. (בניגוד למשתנים מקומיים שמוקצים על מחסנית הקריאות)

אנו נשתמש בזיכרון דינמי כאשר

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

הגישה לזיכרון הדינמי נעשית תמיד בעזרת מצביעים!

יצירת משתנה דינמי

הקצאות זיכרון דינמיות ב-$C++$ מתבצעות ע"י האופרטור $new$.
הקצאת ערך יחיד ואתחולו ניתן לבצע כך:

int* i1 = new int; // random value
int* i2 = ne int(7); // the new integer has the value 7

ניתן להקצות מערך ע"י:

int* array = new int[n];

שחרור משתנה דינמי

שחרור עצם שהקוצה ע"י $new$ מתבצע בעזרת $delete$ כך:

delete ptr;
delete[] array; // delets a `new type[size_t]`

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

if (ptr != nullptr)
	delete ptr;

delete ptr;

int* ptr = malloc(sizeof(int));
if (!ptr)
{
	// handle errors ...
}
*ptr = 5;
int* array = malloc(sizeof(*array)* *ptr);
if (!array)
{
	// handle errors ...
}
free(ptr);
free(array);

int* ptr = new int(5);
int* array = new int[*ptr];

delete ptr;
delete[] array;

דליפות זיכרון

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

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

בעלות על זיכרון

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

מבנים

ניתן להגדיר טיפוסים חדשים המהווים הרכבה של מספר טיפוסים קיימים בעזרת המילה השמורה $struct$ כך:

struct <name>
{
	<typename 1> <field name 1>;
	<typename 2> <field name 2>;
	...
	<typename n> <field name n>;
} <declerations>;

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

struct point
{
	double x;
	double y;
};

struct date
{
	int day;
	char month[4];
	int year;
};

struct person
{
	string name;
	struct date birth;
}

point p;
p.x = 3.0;
p.y = 2.0;
double distance = sqrt(p.x * p.x + p.y * p.y);

point* p = new point();
(*p).x = 3.0;
p->y = 2.5; // these two lines are the same

double distance = sqrt(p->x * p->y + p->y * p->y);

פעולות על מבנים

• ניתן לאתחל מבנים בעזרת התחביר:

  date d = { 31, "NOV", 1970 };
  

• ניתן לבצע השמה בין מבנים מאותו הטיפוס:

  date d1, d2;
  // ...
  d1 = d2;
  

  במקרה זה מתבצעת השמה בין כל שני שדות תואמים.
• מבנים מועברים ומוחזרים מפונקציות $by\; value$ - כלומר, הם מועתקים.
• הפעולות האלו אינן מתאימות למבנים מסובכים יותר בעיקר בגלל מצביעים.

רשימה מקושרת בעזרת מבנים

נסתכל על המבנה הבא:

struct Node
{
	int data;
	Node* next;
};

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

typedef Node* nodeptr;
struct Node
{
	int data;
	nodeptr next;
};

נסתכל על שימוש לדוגמה:

Node* node1 = new Node();
Node* node2 = new Node();

node1->data = 1;
node1->next = node2;
node2->data = 2;
node2->next = nullptr;

לאחר הפעולה הזו הזכרון יראה כך:
​

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

רשימה מקושרת מאפשרת:

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

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

struct Node
{
	int data;
	Node* next;
};

Node* createNode(int d)
{
	Node* ptr = new Node();
	ptr->data = d;
	ptr->next = nullptr;
	return ptr;
}

void destroyList(Node* head)
{
	while(head)
	{
		Node* toDelete = head;
		head = head->next;
		delete toDelete;
	}
}

Node* insert(Node* head, int d)
{
	Node* newHead = createNode(d);
	newHead->next = head;
	return newHead;
}

int main()
{
	Node* head = nullptr;
	int input;
	
	while (!cin.eof())
	{
		cin >> input;
		head = insert(head, input);
	}
	
	for (Node* ptr = head; ptr != nullptr; ptr = ptr->next)
	{
		cout << ptr->data << endl;
	}
	
	destroyList(head);
	return 0;
}