ΓΛΩΣΣΑ C++ - ΜΑΘΗΜΑ 3 - ΚΛΑΣΕΙΣ ΚΑΙ ΔΕΙΚΤΕΣ

H ΓΛΩΣΣΑ C++
Μάθημα 3:
Κλάσεις και Δείκτες
Δημήτρης Ψούνης

Περιεχόμενα Μαθήματος
Α. Θεωρία
1. Διαχείριση Μνήμης
1. Στατική Δέσμευση Μνήμης
2. Στατική Δέσμευση Μνήμης για
Συνήθεις Μεταβλητές
3. Στατική Δέσμευση Μνήμης για
Αντικείμενα
2. Δυναμική Δέσμευση Μνήμης
1. Δείκτες (Υπενθύμιση από C)
2. Οι τελεστές new και delete
3. Δυναμική Δέσμευση για Συνήθεις
Μεταβλητές
4. Δυναμική Δέσμευση για Αντικείμενα
5. Δυναμική Δέσμευση και
Κατασκευαστές
2Δημήτρης Ψούνης, Η Γλώσσα C++, Μάθημα 3: Κλάσεις και Δείκτες
3. Κλάσεις που περιέχουν δείκτες
1. Παράδειγμα κλάσης που περιέχει
δείκτες
2. …και ένα πρόβλημα (χωρίς λύση για
την ώρα)
4. Δυναμική Δέσμευση Μνήμης για
Πίνακες
1. Μονοδιάστατοι πίνακες
2. Παράδειγμα δέσμευσης μνήμης για
μονοδιάστατους πίνακες
3. Διδιάστατοι πίνακες
4. Παράδειγμα δέσμευσης μνήμης για
διδιάστατους πίνακες
B. Ασκήσεις

A. Θεωρία
1. Στατική και Δυναμική Δέσμευση Μνήμης
• Η διαχείριση μνήμης στη C++ γίνεται με παρόμοιο τρόπο με τη C.
• Τα παρακάτω είναι εντελώς αντίστοιχα:
• Στατική Δέσμευση Μνήμης:
• Είναι γνωστός εκ των προτέρων ο χώρος μνήμης που απαιτείται για τα στιγμιότυπα.
• Και έχει ήδη αποφασιστεί κατά το χρόνο μεταγλώττισης (π.χ. δηλώνουμε έναν πίνακα 10
θέσεων)
• Οι τοπικές μεταβλητές αποθηκεύονται στον χώρο της συνάρτησης (στοίβα – stack)
• Δυναμική Δέσμευση Μνήμης:
• Δεν είναι γνωστός εκ των προτέρων ο χώρος μνήμης που πρέπει να δεσμεύσει το
πρόγραμμά μας.
• Αλλά αποφασίζεται κατά το χρόνο εκτέλεσης (π.χ. ο χρήστης αποφασίζει πόσες θέσεις θα
έχει ένας πίνακας που χρησιμοποιεί το πρόγραμμα)
• Ο χώρος μνήμης που δεσμεύεται δυναμικά είναι κοινός για όλες τις συναρτήσεις (σωρός –
heap)

A. Θεωρία
2. Στατική Δέσμευση μνήμης για συνήθεις μεταβλητές
/* CPP3.local_variables.cpp */
#include <iostream>
using namespace std;
void f()
{
int y=3;
cout<<"inside f";
}
int main()
{
int x=5;
cout<<"inside main";
f();
return 0;
}
• Κάθε συνάρτηση έχει το δικό της χώρο μνήμης.
• Κάθε τοπική μεταβλητή αποθηκεύεται στο χώρο μνήμης της
συνάρτησης στην οποία ανήκει.
• Σχηματικά, για το παράδειγμα:
• Αυτός ο χώρος μνήμης καλείται και στοίβα (stack), λόγω του
τρόπου με τον οποίο εχει υλοποιηθεί η κλήση των
συναρτήσεων σε μία στοίβα:
main
f

A. Θεωρία
3. Στατική Δέσμευση μνήμης για Αντικείμενα
• Ένα αντικείμενο αποθηκεύεται στη μνήμη ως εξής:
• Τα μέλη του βρίσκονται σε διαδοχικές θέσεις μνήμης
• Προσοχή, οι μέθοδοι βρίσκονται σε άλλο χώρο (είναι κοινές για όλα τα αντικείμενα της κλάσης)
• Ο τελεστής sizeof μπορεί να χρησιμοποιήθεί για να μετρήσουμε το πλήθος των bytes που
χρησιμοποιεί ένα αντικείμενο.
• Παράδειγμα:
/* CPP3.sizeof.cpp
Μέγεθος αντικειμένου */
#include <iostream>
class dummy {
public:
int x;
int y;
};
int main()
{
dummy ob;
ob.x = 3; ob.y = 5;
cout<<sizeof ob<<endl;
return 0;
}
• Θα τυπώσει 8 (δύο ακέραιοι 4bytes ο
καθένας)
• Και η εικόνα της μνήμης:

A. Θεωρία
• Ένας δείκτης είναι μια μεταβλητή που αποθηκεύει διευθύνσεις μεταβλητών
• Ένας δείκτης δηλώνεται ως εξής:
• Όπου ΤΔ είναι ένας οποιοσδήποτε τύπος δεδομένων (int, float, double κ.λπ.)
• Π.χ. ένας δείκτης σε ακέραιο δηλώνεται με τη δήλωση:
• Αποθηκεύουμε σε έναν δείκτη την διεύθυνση μιας μεταβλητής με τη δήλωση:
• O τελεστής & επιστρέφει τη διεύθυνση της μεταβλητής στην οποία εφαρμόζεται.
• Π.χ. αποθηκεύουμε στον δείκτη ptr τη διεύθυνση μιας μεταβλητής x με την εντολή:
• και λέμε «ο δείκτης ptr δείχνει στην μεταβλητή x»
ΤΔ *pointer_name;
int *ptr;
pointer_name = &variable;
ptr = &x;
• Αναλυτικά βλ. και «Γλώσσα C – Μάθημα 8: Δείκτες»

A. Θεωρία
/* CPP3.pointers.cpp */
#include <iostream>
int main()
{
int x=5;
int *p = NULL;
p = &x;
cout<<"x = "<<x<<" (address: "<<&x<<")"<<endl;
cout<<"*p = "<<*p<<" (address: "<<p<<")"<<endl;
return 0;
}
• Το πρόγραμμα δείχνει την βασική ιδιότητα:
• Για ένα δείκτη (p) που «δείχνει» σε μία
μεταβλητη ισχύουν:
• To NULL είναι μία ειδική τιμή
• που συμβολίζει ότι ο δείκτης δεν
δείχνει κάπου.
• Είναι καλό ένας δείκτης που δεν δείχνει
κάπου να έχει την τιμή NULL
• H τιμη του NULL είναι 0.
• Σχηματικά:
p == &x //Διεύθυνση της x
*p == x // Τιμή της x

A. Θεωρία
2. Οι τελεστές new και delete
• Ο τελεστής new χρησιμοποιείται για να δεσμεύσει δυναμικά χώρο μνήμης
• Αντικαθιστά τη malloc της C.
• Η σύνταξη του είναι:
• Δεσμεύει χώρο μνήμης για ένα αντικείμενου τύπου type και επιστρέφει έναν δείκτη σε
αυτόν το χώρο
• Ο χώρος μνήμης που δεσμεύεται δυναμικά, είναι κοινός για όλες τις συναρτήσεις και
ονομάζεται σωρός (heap)
• Προσοχή, αν αποτύχει η δέσμευση (δεν υπάρχει χώρος) επιστρέφει NULL
• και θα πρέπει πάντα να ελέγχουμε ότι η δέσμευση έγινε επιτυχημένα
ptr = new type;
• Ο τελεστής delete χρησιμοποιείται για να απόδεσμευσει χώρο μνήμης που έχει δεσμευτεί
δυναμικά
• Αντικαθιστά τη free της C.
• Η σύνταξη του είναι:
delete ptr;

A. Θεωρία
2. Οι τελεστές new και delete (Έλεγχος Δέσμευσης Μνήμης)
• Πάντα πρέπει να κάνουμε έλεγχο αν η μνήμη που αιτηθήκαμε με τη new, έχει όντως δεσμευτεί.
• Βλέπουμε τρεις τρόπους για να «πιάσουμε» το πρόβλημα:
• A’ τρόπος: Ο πιο απλός, μιας και απλά ελέγχουμε την επιστρεφόμενη τιμή:
• Β’ τρόπος: Πιο ψαγμένος, ξέρουμε ότι το NULL είναι 0 (και για να είμαστε ακριβής (void *) 0)
• Και ξέρουμε ότι το 0, είναι το λογικό ψευδές
• και το !0 είναι το λογικό αληθές:
• Γ’τρόπος: Ο πιο σύνθετος και φαντεζί, αλλά ενσωματώνει τις δύο εντολές σε μία γραμμή:
• Στις σημειώσεις θα χρησιμοποιήσουμε κυρίως το Β’ τρόπο
• Και θα βγάζουμε απλά ένα ενημερωτικό μήνυμα (αργότερα θα μπορούμε να κάνουμε και
περισσότερα πράγματα, με τις εξαιρέσεις της C++)
ptr = new type;
if (ptr==NULL)
{ …. do some action… }
ptr = new type;
if (!ptr)
if (!(ptr = new type))

A. Θεωρία
3. Δυναμική Δέσμευση για Συνήθεις Μεταβλητές
• Το παράδειγμα δείχνει τη δέσμευση
μνήμης για έναν ακέραιο αριθμό, τόσο
στατικά όσο και δυναμικά:
#include <iostream> // CPP3.dynamic_variable.cpp
int main()
{
int x; // Μεταβλητή που δεσμέυει στατικό χώρο
int *p; // Δείκτης σε ακέραιο
p = new int; // Δυναμική δέσμευση μνήμης
if (!p) cout<<“Error allocating memory”;
/* Αναθέσεις τιμών */
x = 1;
*p = 5;
/* Εκτυπώσεις */
cout<<"x = "<<x<<" (address: "<<&x<<")"<<endl;
cout<<"*p = "<<*p<<" (address: "<<p<<")"<<endl;
delete p; // Αποδέσμευση μνήμης
return 0;
}
Υπενθυμίσεις από τη C:
• Η x δεσμεύει χώρο μνήμης μέσα στο χώρο
μνήμης της συνάρτησης
• Ο χώρος που δεσμεύεται δυναμικά μέσω
της p, είναι ένας ξεχωριστός χώρος, κοινός
για όλο το πρόγραμμα
• (λέγεται και σωρός – heap)
• Σχηματικά:

A. Θεωρία
/* CPP3.dynamic_object.cpp Δυναμική Δέσμευση
μνήμης για αντικείμενο */
#include <iostream>
class dummy {
public:
int x;
};
int main()
{
dummy *p = NULL; //Θα δείξει σε αντικείμενο
p = new dummy; // Δέσμευση χώρου
p->x = 5;
cout<<"p->x = "<<p->x<<endl;
return 0;
}
• Αντίστοιχα (αφού μία κλάση είναι τύπος δεδομένων), μπορεί να δεσμευτεί δυναμικά χώρος
μνήμης για ένα αντικείμενο.
• Όταν χρησιμοποιούμε ένα αντικείμενο μέσω δείκτη,
• Έχουμε πρόσβαση στα δημόσια μέλη-μεθόδους μέσω του τελεστή -> (βελάκι)
• Βλέπουμε και ένα παράδειγμα:

A. Θεωρία
/* CPP3.dereferencing.cpp */
#include <iostream>
class dummy {
public:
int x;
};
int main()
{
dummy *p = NULL; //Θα δείξει σε αντικείμενο
p = new dummy; // Δέσμευση χώρου
(*p).x = 5;
cout<<"(*p).x = "<<(*p).x<<endl;
return 0;
}
• Δεδομένου ενός δείκτη που δείχνει σε ένα αντικείμενο.
• Με τον τελεστή *, έχουμε πρόσβαση στο ίδιο το αντικείμενο (dereferencing)
• Και ισχύει ότι το (*p) είναι το αντικείμενο στο οποίο δείχνει ο δείκτης.
• Συνεπώς έχουμε πρόσβαση στα δημόσια μέλη του (*p) με τον τελεστή . (τελεία)
• Βλέπουμε και ένα παράδειγμα:

A. Θεωρία
/* CPP3.pointers_and_objects.cpp Δείκτης σε
αντικείμενο */
#include <iostream>
class dummy {
public:
int x;
};
int main()
{
dummy ob;
dummy *p = &ob;
ob.x = 6;
cout<<ob.x<<" "<<p->x<<" "<<(*p).x<<endl;
return 0;
}
• Και ένα ακόμη παράδειγμα, όπου βάζουμε ένα δείκτη να δείχνει σε ένα ήδη υφιστάμενο
αντικείμενο:
• Για να τονιστεί η διαφορά στην πρόσβαση,
• απευθείας από το αντικείμενο (τελεστής .)
• μέσω δείκτη (τελεστής ->)
• μέσω dereferencing ( * και . )

A. Θεωρία
5. Δυναμική Δέσμευση και κατασκευαστές
• Όταν δημιουργούμε ένα αντικείμενο με τον τελεστή new,
• και εφόσον το αντικείμενο αυτό έχει κατασκευαστή
• πρέπει να περάσουμε και τα ορίσματα στον κατασκευαστή
• Ο κατασκευαστής καλείται όταν κάνουμε new
• Ο καταστροφέας καλείται όταν κάνουμε delete
/*
CPP3.constructor_destru
ctor.cpp */
#include <iostream>
class dummy {
public:
dummy(int in_x);
~dummy();
private:
int x;
};
int main()
{
dummy *p = NULL;
p = new dummy(5); //constructing
if (!p) cout<<“Error allocating
memory”;
delete p; //destructing
return 0;
}
dummy::dummy(int in_x)
{
x = in_x;
cout<<"Constructing...";
}
dummy::~dummy()
{
cout<<"Destructing...";
}

A. Θεωρία
1. Παράδειγμα κλάσης που περιέχει δείκτη
• Ένας δείκτης είναι απλά μία μεταβλητή
• Συνεπώς μπορεί να είναι μέλος σε κλάση
• Βλέπουμε ένα απλό παράδειγμα:
• Στο οποίο δεσμεύουμε δυναμικά στον κατασκευαστή το χώρο για έναν ακέραιο
• και τον αποδεσμεύουμε στον καταστροφέα.
/* CPP3.class_with_pointer */
#include <iostream>
class dummy {
public:
dummy();
~dummy();
void set_val(int in_val);
int get_val();
private:
int *p_val;
};

A. Θεωρία
1. Παράδειγμα κλάσης που περιέχει δείκτη
int main()
{
dummy ob;
ob.set_val(3);
cout<<endl<<ob.get_val()<<endl;
return 0;
}
dummy::dummy()
{
p_val = new int;
if (!p_val) cout<<"Error allocating memory";
}
dummy::~dummy()
{
delete p_val;
}
void dummy::set_val(int in_val)
{
*p_val = in_val;
}
int dummy::get_val()
{
return *p_val;
}

A. Θεωρία
2. …και ένα πρόβλημα (χωρίς λύση για την ώρα)
• Ας δούμε και ένα πρόβλημα που μπορεί να προκύψει όταν μία κλάση περιέχει δείκτες που
κάνουν δυναμική διαχείριση μνήμης
• Το πρόβλημα αυτό προκύπτει όταν:
• Έχουμε μία κλάση που κάνει δυναμική δέσμευση μνήμης
• Κάνουμε αντιγραφή του αντικειμένου (π.χ. ob1 = ob2)
• Μεταγλωττίστε και εκτελέστε το ακόλουθο πρόγραμμα:
/* CPP3.assignment_problem Δυναμική Δέσμευση και Τελεστής Ανάθεσης */
#include <iostream>
class dummy {
public:
dummy();
~dummy();
void set_val(int in_val);
int get_val();
private:
int *p_val;
};

A. Θεωρία
int main()
{
dummy ob1;
ob1.set_val(3);
dummy ob2;
ob2 = ob1;
cout<<ob1.get_val()<<endl;
cout<<ob2.get_val()<<endl;
return 0;
}
dummy::dummy()
{
p_val = new int;
if (!p_val) cout<<"Error allocating memory";
}
dummy::~dummy()
{
delete p_val;
}
void dummy::set_val(int in_val)
{
*p_val = in_val;
}
int dummy::get_val()
{
return *p_val;
}
• Σημαντικό! Στη C++ οι μεταβλητές μπορούν να δηλωθούν σε οποιοδήποτε μέρος του
προγράμματος (αλλά θα το αποφεύγουμε…)

A. Θεωρία
• H εκτέλεση του προγράμματος οδηγεί σε σφάλμα κατά το χρόνο εκτέλεσης:
• Για να καταλάβουμε γιατί συμβαίνει αυτό, θα δούμε την κατάσταση της μνήμης βήμα – βήμα
κατά την εκτέλεση της main

A. Θεωρία
• dummy ob1; // Δεσμεύει το χώρο για το ob1.
• ob1.set_val(3); // αποθηκεύει την τιμή 3 στο χώρο μνήμης

A. Θεωρία
• dummy ob2; // Δεσμεύει το χώρο για το ob2.
• ob2=ob1 // Δεν κάνει ακριβώς αυτό που θέλουμε…

A. Θεωρία
• Τώρα με την ολοκλήρωση του προγράμματος, θα τρέξουν οι δύο destructors.
• Συνεπώς ο ίδιος χώρος μνήμης θα αποδεσμευτεί δύο φορές.
• Και αυτό οδηγεί σε σφάλμα στο χρόνο εκτέλεσης.
• Ενώ ισχύει ότι έχουμε κάνει και το βασικό λάθος
• Με την ολοκλήρωση του προγράμματος, έχει ξεμείνει χώρος μνήμης, τον οποίο
δεσμεύσαμε δυναμικά και δεν τον αποδεσμεύσαμε ποτέ (memory leak)
• Το πρόβλημα αυτό προκύπτει όταν γίνεται bit by bit αντιγραφή αντικειμένων (shallow copy)
• όπως στην περίπτωση που είδαμε,
• αλλά και σε άλλες περιπτώσεις (π.χ. όταν περνάμε ένα αντικείμενο μέσω τιμής σε μία
συνάρτηση)
• Θα αντιμετωπίσουμε το πρόβλημα αυτό, στα επόμενα μαθήματα:
• Θα μάθουμε τις αναφορές (references)
• και μέσω αυτών θα ορίσουμε τον κατασκευαστή αντιγράφου (copy constructor)
• επίσης θα μάθουμε την υπερφόρτωση του =
• και θα ορίσουμε τι πρέπει να γίνεται όταν έχουμε ανάθεση αντικειμένου

A. Θεωρία
4. Δυναμική Δέσμευση Μνήμης για Πίνακες
1. Μονοδιάστατοι Πίνακες
• Οι τελεστές new και delete χρησιμοποιούνται και για την δέσμευση μνήμης για πίνακες
• Δέσμευση Μνήμης:
• Η σύνταξη του τελεστή new είναι:
• Δεσμεύει χώρο μνήμης για n αντικείμενα τύπου type και επιστρέφει έναν δείκτη σε αυτόν
το χώρο
• Το n δεν χρειάζεται να είναι σταθερά.
• Αποδέσμευση Μνήμης:
• Η σύνταξη του τελεστή delete είναι:
ptr = new type [n];
delete [] ptr;

• Βλέπουμε και ένα παράδειγμα δέσμευσης μνήμης για έναν πίνακα n ακεραίων.
A. Θεωρία
2. Παράδειγμα δέσμευσης μνήμης για μονοδιάστατο πίνακα
/* CPP3.1d_dynamic_array Μονοδιάστατος
πίνακας με δυναμική δέσμευση μνήμης */
#include <iostream>
int main()
{
int *arr;
int n=4;
/* Δέσμευση Μνήμης */
arr = new int [n];
if (!arr) cout<<"Error allocating memory!";
/* Κάποια δουλειά στον πίνακα */
for (int i=0; i<n; i++)
arr[i]=i*i;
for (int i=0; i<n; i++)
cout<<arr[i]<<" ";
/* Αποδέσμευση Μνήμης */
delete [] arr;
return 0;
}

A. Θεωρία
3. Διδιάστατοι Πίνακες
• Ένας διδιάστατος ΜxN πίνακας π.χ. ακεραίων είναι:
• ένας πίνακας M δεικτών σε ακέραιο
• όπου κάθε δείκτης είναι ένας πίνακας από N ακεραίους
• Σχηματικά (π.χ. για M=7, N=6):
1 5 2 4 3 2
6 4 6 9 3 4
2 5 9 4 6 2
1 8 9 6 2 3
9 1 5 1 6 7
9 8 4 1 3 5
1 9 7 6 4 2pin[6]
pin[1]
pin[2]
pin[3]
pin[4]
pin[5]
pin[0]
pin
pin[0][4]
pin[3][3]
pin[6][0]
M=7
γραμμές
Ν=6
στήλες

A. Θεωρία
3. Διδιάστατοι Πίνακες
• Από τα παραπάνω:
• Η δέσμευση μνήμης θα γίνει με τις εντολές:
• Προσοχή, ότι το ptr είναι διπλός δείκτης
• αφου θέλουμε να δείχνει στην διεύθυνση μιας μεταβλητής που είναι διεύθυνση
ενός τύπου.
• Συνεπώς θα δηλωθεί ως:
• H αποδέσμευση θα γίνει εντολές:
ptr = new type * [Μ];
for (i=0; i<M; i++)
ptr[i] = new type [N];
type **ptr;
for (i=0; i<M; i++)
delete [] ptr[i];
delete [] ptr;

• Βλέπουμε και ένα παράδειγμα δέσμευσης μνήμης για έναν πίνακα n ακεραίων.
A. Θεωρία
4. Παράδειγμα δέσμευσης μνήμης για διδιάστατο πίνακα
/* CPP3.2d_dynamic_array Διδιάστατος πίνακας με
δυναμική δέσμευση μνήμης */
#include <iostream>
int main()
{
int **arr;
int i,j, n=3, m=5;
/* Δέσμευση Μνήμης */
arr = new int * [n];
if (!arr) cout<<"Error allocating memory!";
for (i=0; i<n; i++)
{
arr[i] = new int [m];
if (!arr[i]) cout<<"Error allocating memory!";
}
/* Κάποια δουλειά στον πίνακα */
for (i=0; i<n; i++)
for (j=0; j<m; j++)
arr[i][j]=i*j;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
cout<<arr[i][j];
cout<<endl;
}
/* Αποδέσμευση Μνήμης */
for (i=0; i<n; i++)
delete [] arr[i];
delete [] arr;
return 0;
}

Β. Ασκήσεις
Άσκηση 1: Διπλοί Δείκτες
Για να πειραματιστούμε με τους δείκτες
• Δηλώστε μία ακέραια μεταβλητή x
• Τυπώστε την τιμή και τη διεύθυνσή της
• Δηλώστε έναν δείκτη σε ακέραιο p
• Θέστε τον να δείχνει στην x
• Τυπώστε την τιμή και τη διεύθυνση του
• Τυπώστε την τιμή του x, μέσω του p.
• Δηλώστε έναν δείκτη σε δείκτη σε ακέραιο, με όνομα pp
• Θέστε τον να δείχνει στον p
• Τυπώστε την τιμή και τη διεύθυνσή του
• Τυπώστε την τιμή του x, μέσω του pp.
• Τυπώστε την τιμή του p, μέσω του pp.

Β. Ασκήσεις
Άσκηση 2: Κλάση Δυναμικός Πίνακας
Κατασκευάστε μία κλάση (ARRAY) που να περιτυλίσσει την έννοια του μονοδιάστατου πίνακα ως
εξής:
• Να έχει ως μέλη έναν δυναμικό πίνακα (δείκτης) ακεραίων, καθώς και τη διάσταση του πίνακα
• Ο κατασκευαστής να παίρνει ως όρισμα τη διάσταση του πίνακα και να δεσμεύει δυναμικά το
χώρο μνήμης που απαιτείται.
• Ο καταστροφέας να διαγράφει τη μνήμη που έχει δεσμευτεί δυναμικά.
• Να έχει accessors για ένα στοιχείο του πίνακα
• Να τυπώνουν μήνυμα λάθους, σε περίπτωση πρόσβασης εκτός των ορίων του πίνακα.
• Μία μέθοδο print που να τυπώνει τα στοιχείτα του πίνακα
Η συνάρτηση main
• Να κατασκευάζει έναν πίνακα της κλάσης με 10 θέσεις
• Να αρχικοποιεί τα στοιχεία του πίνακα, ώστε κάθε στοιχείο να έχει το τετράγωνο της
αντίστοιχης θέσης.
• Να τυπώνει τον πίνακα.
Ποιο πρόβλημα υπάρχει με την υλοποίηση; Πότε περιμένουμε ότι το πρόγραμμα αυτό θα έχει
πρόβλημα και θα «σκάσει» κατά το χρόνο εκτέλεσης;

ΓΛΩΣΣΑ C++ - ΜΑΘΗΜΑ 3 - ΚΛΑΣΕΙΣ ΚΑΙ ΔΕΙΚΤΕΣ

More Related Content

What's hot (20)

Similar to ΓΛΩΣΣΑ C++ - ΜΑΘΗΜΑ 3 - ΚΛΑΣΕΙΣ ΚΑΙ ΔΕΙΚΤΕΣ (20)

More from Dimitris Psounis (20)

Recently uploaded (8)

ΓΛΩΣΣΑ C++ - ΜΑΘΗΜΑ 3 - ΚΛΑΣΕΙΣ ΚΑΙ ΔΕΙΚΤΕΣ