Εισαγωγή Στον Προγραμματισμό Με c++ Κωνσταντίνος Κουκουλέτσος Τει Πειραιά

ΕΛΛΗΝΙΚΗ ΔΗΜΟΚΡΑΤΙΑ
Ανώτατο Εκπαιδευτικό Ίδρυμα Πειραιά

Τεχνολογικού Τομέα
Εισαγωγή στον Προγραμματισμό

με C++
Κωνσταντίνος Κουκουλέτσος
Τμήμα Αυτοματισμού
Ενότητα # 1: Εισαγωγή
Περιεχόμενα
• Περιβάλλον ανάπτυξης
• Διαδικασία συγγραφής & εκτέλεσης
προγράμματος
• Καλές πρακτικές παρουσίασης προγράμματος
• Αλφάβητο, Λεξιλόγιο, Αναγνωριστικά, Βασικοί
τύποι δεδομένων, Μεταβλητές, Σταθερές της C++
• Αριθμητικοί, Σχεσιακοί & Λογικοί τελεστές της
C++
Περιβάλλον Ανάπτυξης
Dev C++ της εταρείας Bloodshed
http://www.bloodshed.net/devcpp.html
 Online tutorials
English
http://www.cplusplus.com/doc/tutorial/
http://www.cprogramming.com/
http://www.netspace.org/~mts/cpp/
http://www.functionx.com/cpp/index.htm
6
Διαδικασία συγγραφής και εκτέλεσης
Πρόγραμμα:
Εμφάνιση μηνύματος στην οθόνη
Απλό πρόγραμμα
Εκτύπωση μίας γραμμής
To πρόγραμμα παρουσιάζει βασικά χαρακτηριστικά της C++
9
Επεξήγηση προγράμματος (1)
Οδηγία προς το Προ-επεξεργαστή
(Preprocessor) να συμπεριλάβει τα
αρχεία επικεφαλίδας (header file)
<cstdlib> και <iostream>
Συνάρτηση main Αρχίζει με {

και τελειώνει με }
Οι εντολές τελειώνουν με ;
Η συνάρτηση main
εμφανίζεται μόνο μία φορά
σε κάθε πρόγραμμα C++
Τελεστής εισαγωγής (insertion) του ρεύματος ροής

(αντικειμένου) cout.
Ότι εισάγεται στην είσοδο του cout προωθείται προς
την έξοδο του δηλ. την οθόνη
Η λέξη κλειδί return προκαλεί έξοδο από την
συνάρτηση; Η τιμή 0 ή EXIT_SUCESS σημαίνει
επιτυχή περάτωση του προγράμματος 10

Σχόλια μίας γραμμής
Σχόλιο πολλών γραμμών
Λέξη κλειδί που προκαλεί

αλλαγή γραμμής
Χαρακτήρας διαφυγής Χαρακτήρας διαφυγής

Δηλώνει 2 αλλαγές γραμμών Δηλώνει αλλαγή γραμμής
Χρήση εσοχών
11
Το πρόγραμμα τρέχει σωστά
12
Τα δύο προγράμματα είναι το ίδιο
13
Καλές Πρακτικές Παρουσίασης
Προγράμματος
1. Κάθε πρόγραμμα αρχίζει με κάποια σχόλια
2. Σχόλια μπαίνουν και μέσα στο πρόγραμμα
3. Χρησιμοποιούμε εσοχές για καλύτερη
αναγνωσιμότητα του προγράμματος
4. Οι εσοχές είναι σύμφωνα με ισχύοντες πρακτικές
14
Μεταβλητές
- Θέσεις στην μνήμη του υπολογιστή
- Ο τύπος των μεταβλητών πρέπει να δηλώνεται
- Οι βασικοί τύποι μεταβλητών είναι
int – ακέραιοι αριθμοί
char – χαρακτήρες
double – πραγματικοί (κινητής υποδιαστολής)
- Οι μεταβλητές πρέπει να δηλώνονται με όνομα και τύπο πριν από την χρήση
τους
int arithmos1;
int arithmos2;
int sinolo;
- Αναγνωριστικά (identifiers) είναι τα ονόματα που χρησιμοποιούνται για τις
μεταβλητές
15
Πρόγραμμα πρόσθεσης αριθμών
Δήλωση ακεραίων μεταβλητών
Χρήση τελεστή εξαγωγής (extraction) του

ρεύματος ροής (ή αντικειμένου) cin, που
είναι συνδεδεμένο με το πληκτρολόγιο. Η
πληκτρολόγηση ενός δεδομένου
προωθείται προς την έξοδο του cin που
είναι κάποια μεταβλητή
16
Αλφάβητο της C++

H γλώσσα προγραμματισμού C++ χρησιμοποιεί τους
παρακάτω χαρακτήρες:
- Μικρά a, b, c, …, z και κεφαλαία A, B, C, …, Z
- Ψηφία 0, 1, 2, …, 9
- Ειδικούς χαρακτήρες
+ = - /( ) * & % $ # ! | ~ \ ^ < > . , ; : ? { } [ ] _
- Κενό διάστημα (white space) πού είναι οι χαρακτήρες κενό

κενή γραμμή ο χαρακτήρας tab (αγνοούνται από τον compiler)
17
Το λεξιλόγιο της C++
Σε ένα πρόγραμμα της C++ διακρίνονται τα
παρακάτω είδη στοιχείων:
- Σχόλια (comments) και Λέξεις κλειδιά (reserved words)
- Μεταβλητές (variables) με τα αναγνωριστικά τους (identifiers)
και Σταθερές (constants)
- Συμβολοσειρές (strings) και Τελεστές (operators)
- Σημεία στίξης και διαχωριστές (punctuators & separators)
18
Λέξεις κλειδιά
19
Αναγνωριστικά Ονόματα
(Identifiers)
Δηλώνουν συναρτήσεις και μεταβλητές
- Ισχύουν οι παρακάτω κανόνες
- To όνομα μπορεί να αποτελείται από γράμματα μικρά και
κεφαλαία, ψηφία και τον χαρακτήρα υπογράμμισης underscore
- Ο πρώτος χαρακτήρας πρέπει να είναι γράμμα ή ο χαρακτήρας
υπογράμμισης _ (underscore)
- Δεν επιτρέπεται η χρήση δεσμευμένων λέξεων
20
Αναγνωριστικά Ονόματα-
Παραδείγματα
 Καλό είναι τα ονόματα να είναι τα ονόματα να έχουν σχέση με
την μεταβλητή που αντιπροσωπεύουν. Με τον τρόπο αυτό το
πρόγραμμα γίνεται πιο ευανάγνωστο
πχ. plithos, poso, pososto, perimetros, fpa, AnoOrio, KatoOrio …..
 Ονόματα μη αποδεκτά
1num, poso-forou, φπα
 Υπάρχει διαφορά μεταξύ κεφαλαίων και μικρών

Poso poso
21
Βασικοί τύποι Δεδομένων και
Ακρίβεια
22
Δηλώσεις μεταβλητών-
παραδείγματα
 int poso;
 float a,b,c;
 int fpa= 18, kefalaio=100000;
 double mikos1=18.9, mikos2=5.8
23
Δηλώσεις Μεταβλητών-Εκχωρήσεις
 Δηλώνονται σε οποιοδήποτε σημείο του προγράμματος αρκεί να
γίνει η δήλωση πριν από την χρήση
float a,b,c;
int fpa= 23, kefalaio=100000;
int totalfpa;
foros=kefalaio*fpa/100;
int ipoloipo;
ipoloipo=kefalaio-foros;
 Η εκχώρηση δεν σημαίνει ισότητα αλλά σημαίνει βάλε στο αριστερό
μέρος την τιμή που προκύπτει μετά το υπολογισμό του δεξιού
μέρους
int k=10;
k=k+2;
24
Εύρος ακεραίου
Ο ακέραιος τύπος έχει περιορισμένο
εύρος μέχρι 2 εκατομμύρια.
Αν η τιμή που προκύπτει είναι εκτός
εύρους τότε έχουμε υπερχείλιση
(overflow) αλλά δεν εμφανίζεται
ΛΑΘΟΣ
25
Σταθερές
Εάν θέλουμε η τιμή μιας Το ίδιο επιτυγχάνεται και με την οδηγία
μεταβλητής να μην αλλάξει #define προς τον pre-processor
κατά την εκτέλεση τότε #define FPA 18 //xoris ; sto telos
χρησιμοποιούμε το πρόθεμα #define PI 3.1415926535897932384626433832795
const (από τη λέξη constant, //paradeigma
σταθερά) πριν τον τύπο float rad ;
δεδομένων της μεταβλητής const float PI=3.1415 ;
const int fpa=18; cout<< “Dose aktina tou kiklou” ;
cin>> rad ;
float embado = PI * rad * rad ;
cout<< "Εμβαδόν= "<< embado << endl;
26
Αριθμητικοί Τελεστές
= Τελεστής απόδοσης τιμής

+,- πρόσθεση, αφαίρεση
*,/ πολλαπλασιασμός, διαίρεση
% υπόλοιπο ακεραίας διαίρεσης
++ , -- Τελεστές αύξησης και μείωσης κατά 1
(χρησιμοποιούνται σαν πρόθεμα και
επίθεμα)
27
Προσοχή στις πράξεις ακεραίων
Εάν και οι δύο αριθμοί είναι Τι εμφανίζεται αν εκτελεστεί
ακέραιοι το ενδιάμεσο το παρακάτω πρόγραμμα;
αποτέλεσμα είναι ακέραιο.
Έτσι 7/3 είναι 2 και όχι 2.5
Όμως 7/3. είναι 2.5

7/4. είναι 1.75
28
Παραδείγματα Εκχώρησης
int a,b; H εκχώρηση χρησιμοποιείται int a,b;
a=5; μέσα σε μία άλλη εκχώρηση
a=a+3; a=5;
b=++a;
a=4+(b=2);
cout<<a<<b;
66
a=14%7;
a=16%7; a=5;
b=a++;
a=5/2; cout<<a<<b;
a=6/4; 65
29
Σύνθετες εκχωρήσεις
 (+=, -=, *=, /=, %= )
 compound assignment
operators
 Αλλάζει η τιμή της μεταβλητής
με πράξη που γίνεται στην
τρέχουσα τιμή της.
30
Σχεσιακοί Τελεστές
Οι τελεστές χρησιμοποιούνται για να σχηματίσουμε
λογικές συνθήκες. Το αποτέλεσμα είναι μία λογική
τιμή, είτε αληθής (true) είτε ψευδής (false).
== ίσο
!= διάφορο
> μεγαλύτερο
< μικρότερο
>= μεγαλύτερο ή ίσο
<= μικρότερο ή ίσο
Στην C++ η τιμή false εκφράζεται και απεικονίζεται

εσωτερικά με την τιμή 0 ενώ η true με οποιαδήποτε
τιμή διάφορο του μηδενός
31
Λογικοί Τελεστές
 Οι λογικοί τελεστές
! (not)
&& (and)
|| (or)
χρησιμοποιούνται για να σχηματίσουν λογικές προτάσεις.
32
Σχεσιακοί και Λογικοί Τελεστές-

Παραδείγματα
8 == 3) // είναι false.
(6 > 4) // είναι true.
(3 != 2) // είναι true.
(8 >= 8) // είναι true.
(3 < 3) // είναι false.
Τι θα εμφανίσει το παρακάτω;
int k;
k=(7==5)&&(5>4); cout<<k;
33
Προτεραιότητα τελεστών
1. Οι πράξεις εκτελούνται
σύμφωνα με την προτεραιότητα
2. Τελεστές με την ίδια
προτεραιότητα εκτελούνται από
τα αριστερά προς τα δεξιά
3. Χρησιμοποιούνται
παρενθέσεις για να αλλαχτεί η
εκτέλεση των πράξεων
a=6/2+1;
a=6/(2+1);
b=a+2+6/2;
a= (a+2+6)/2;
34
Ενότητα # 2: Εντολή If
• Εντολή if
• if.. else
• Ένθετη εντολή if..else
• Πολλαπλά if..else
• Εντολή switch
• Ισοδυναμία if..else με switch
• Παραδείγματα
5
Εντολή if
• Με την εντολή αυτή γίνεται έλεγχος (αλλαγή) της ροής του προγράμματος
• Σύνταξη εντολής:
Απλή πρόταση
if (λογική παράσταση)
Block εντολών
• Το Block εντολών είναι εντολές που περικλείονται σε { } Π.χ.
if (a==5) {
a=2*a;
cout<<a;
}
• Σε περίπτωση μία εντολής δεν χρειάζονται { }
if (a==5)
cout<<a;
6
Πρόταση if..else (1)
 Πρόταση if…else
if (λογική παράσταση)
Block εντολών1
else
Π.χ.
if (a==5) {
a=2*a;
cout<<a;
}
else {
a=b;
cout<<a<<b;
}
Πρόταση if..else (2)

πχ
if (vathmos<5) {
cout<<“distixos apetixes”;}
else {
cout<<“bravo ”;
cout<<“perases me= ”<<vathmos;}
Προσοχή στις εσοχές ο τρόπος στοίχισης διευκολύνει

την ανάγνωση (το πρόγραμμα γίνεται ευανάγνωστο)
8
Ένθετη εντολή if..else (nested if)
Πρόκειται για εντολές if που H στοίχιση του παραδείγματος
περικλείονται σε άλλες μπορεί να διαφοροποιηθεί:
εντολές if…else if (x > 0)
cout << «Το x einai thetiko";
else
πχ if (x < 0)
cout << “To x einai arnitiko";
else
if (x > 0) cout << “To x einai miden";
cout << «Το x einai thetiko"; Μπορεί να γραφεί
else if (x > 0)
cout << «Το x einai thetiko";
if (x < 0) else if (x < 0)
cout << “To x einai arnitiko"; cout << “To x einai arnitiko«
else else
cout << “To x einai miden"; cout << “To x einai miden";
Πολλαπλά if..else (nested if)

if (λογική παράσταση1) Γίνεται έλεγχος για πολλαπλες
• Block εντολών1 περιπτώσεις παραθετοντας μία
else if (λογική παράσταση2) if/else μεσα σε μία άλλη if/else
• Block εντολών2
else if (λογική παράσταση3) Μόλις μία από τις συνθήκες (λογική
παράσταση) βρεθεί ότι είναι αλήθεια
• Block εντολών3
εκτελείται το block που αντιστοιχεί σε
else if (λογική παράσταση4) αυτή την συνθήκη και όλες οι άλλες
• Block εντολών4 εντολές δεν εκτελούνται
…….. (παραλείπονται)
• ……
else
Block εντολώνΝ
υπόλοιπο πρόγραμμα
10
Αντιστοίχιση else με If (1)
a=9, b=3;
a=9, b=7;
a=2, b=3;
a=2, b=7
Το else αντιστοιχεί στο τελευταίο if που δεν έχει δικό του else.
11
Αντιστοίχιση else με If (2)
a=9, b=3;
a=9, b=7;
a=2, b=3;
a=2, b=7
Το else αντιστοιχεί στο τελευταίο if που δεν έχει δικό του else.
12
Εντολή switch
• Χρησιμοποιείται για πολλαπλή επιλογή αντι if..elseif..else if else…
switch (παράσταση)
{case τιμή1:
break;
case τιμή2:
break;
case τιμή2:
break;
……..
……
default
Block εντολώνΝ
}
Η παράσταση πρέπει να εκτιμάται σαν ακεραία
Η τιμη1, τιμή2 είναι ακέραιοι αριθμοί ή χαρακτήρες (όχι πραγματικοί ή strings )
13
Παράδειγμα χρήσης εντολής switch
break προκαλεί το τέλος της switch και

το πρόγραμμα συνεχίζει με την πρώτη
εντολή μετά την δομή switch. Αν δεν
μπεί το break συνεχίζεται η εκτέλεση και
των άλλων εντολών ακόμη και αυτών
που ανήκουν σε άλλες case
Προσοχή στις δύο case. Εδώ τα δύο

case έχουν κοινό block επειδή δεν
υπάρχει break οπότε αυτό εκτελείται αν
η παράσταση op είναι ίσον με * ή ίσο
με x
14
Ισοδυναμία if..else με εντολή switch (1)
Να γραφεί η παρακάτω εντολή if

ισοδύναμα με χρήση δομής switch
15
Ισοδυναμία if..else με εντολή switch (2)
Να γραφεί η παρακάτω εντολή if

ισοδύναμα με χρήση δομής switch
Απάντηση
16
Ενότητα # 3: Επαναλήψεις
• Εντολή for
• Εντολή while
• Εντολή do..while
• break & continue
5
Εντολές Επαναλήψεων
•H C++ διαθέτει τις παρακάτω εντολές
επανάληψης (βρόγχος)
– Εντολή for
– Εντολή while
– Εντολή do… while
Εντολή for
Αρχική τιμή
for (εντολή1; συνθήκη επανάληψης; εντολή2)

block;
Συνθήκη
πχ Αύξηση τιμής
for (i=1;i<=10; i++)
cout<<i<<endl;
Block εντολών
• Λειτουργία της εντολής επανάληψης
–Εκτελείται η εντολή1_αρχικοποίησης
– Ελέγχεται η συνθήκη και αν ισχύει, εκτελείται το block, διαφορετικά η for τερματίζει.
– Εκτελείται η εντολή2
– Εκτελείται το b)
• Έλεγχος της συνθήκης που καθορίζει αν θα συνεχιστεί ή όχι η επανάληψη
γίνεται στην αρχή
7
Εντολή for-Παραδείγματα
Εντολή for-Παραδείγματα
9
Εντολή while
while (συνθήκη) {
block;
}
Λειτουργία εντολής
• Αν η συνθήκη είναι αληθής (τιμή =1) τότε εκτελείται το block των εντολών και
μετά εξετάζεται και πάλι ή συνθήκη.
• Αν η συνθήκη είναι ψευδής τότε η επαναληπτική διαδικασία σταμάτα και
εκτελείται η εντολή που βρίσκεται αμέσως μετά το block της δομής while.
• Συνήθως η εντολή while χρησιμοποιείται στην περίπτωση που το πλήθος των
επαναλήψεων δεν είναι γνωστό ή εάν το πλήθος των επαναλήψεων δεν παίζει
ρόλο αλλά εξαρτάται από την ικανοποίηση ή όχι μίας συνθήκης.
10
Εντολή while-Περιπτώσεις-λάθη (1)

Συνεχής επανάληψη χωρίς τέλος
Στη περίπτωση αυτή η επανάληψη και εκτύπωσε δεν σταματά
Στο παρακάτω πρόγραμμα η επανάληψη δεν εκτελείται καμία φορά. Δεν είναι
λάθος γιατί υπάρχουν τέτοιες περιπτώσεις που δεν θέλουμε να γίνει εκτέλεση
αν δεν ισχύει κάποια αρχική συνθήκη
11
Εντολή while-Περιπτώσεις-λάθη (2)
Ποιο είναι το αποτέλεσμα των τριών
επόμενων επαναλήψεων
Στην πρώτη δεν εμφανίζεται τίποτε.
Στην δεύτερη εμφανίζεται μία

μαύρη οθόνη γιατί η επανάληψη
είναι χωρίς σώμα εντολών προς
εκτέλεση.
Στην τρίτη τι γίνεται;
12
Εντολή do..while
do {
block;
} while (συνθήκη);
Λειτουργία εντολής
• Εκτελείται το block των εντολών και μετά γίνεται έλεγχος της συνθήκης. Εάν η
συνθήκη είναι αληθής (τιμή =1 η ακόμη πιο γενικά ≠0 ) τότε εκτελείται και πάλι το
block των εντολών και μετά εξετάζεται πάλι ή συνθήκη.
• Αν η συνθήκη είναι ψευδής τότε η επαναληπτική διαδικασία σταμάτα και
εκτελείται η εντολή που βρίσκεται αμέσως μετά το block των εντολών της δομής
do…while.
• Η επαναληπτική διαδικασία do…while είναι παρόμοια με την while, όμως οι
εντολές εντός του block εντολών θα εκτελεστούν τουλάχιστον μια φορά
ανεξαρτήτως αν είναι αληθής ή όχι η συνθήκη γιατί η συνθήκη εξετάζεται στο
τέλος της διαδικασίας.
13
Παραδείγματα εφαρμογής do..while (1)
Το do…while εκτελεί μία σειρά εντολών και μετά ελέγχει την
συνθήκη επανάληψης.
Εφαρμόζεται ευρέως στην περίπτωση που ο χρήστης αφού
εισάγει μία τιμή γίνεται έλεγχος της τιμής αυτής.
Ο χρήστης βλέπει μήνυμα σε κάθε περίπτωση

14
Παραδείγματα εφαρμογής do..while (2)
Εναλλακτικά μπορεί να χρησιμοποιηθεί το while και ο χρήστης να

βλέπει μήνυμα στην περίπτωση που εισάγει λάθος αριθμός.
15
Ισοδύναμες επαναλήψεις
Στην while πρέπει να μπορεί να υπολογίζεται η συνθήκη με την

έναρξη της επαναληπτικής διαδικασίας. Για αυτό η μεταβλητή κ
αρχικοποιείται (κ=-999)
16
Εύρεση πλήθους, αθροίσματος και

γινομένου
Εύρεση πλήθους (μέτρημα)
1) int plithos=0;
2) Όταν πρέπει να μετρήσω αυξάνω τον μετρητή δηλ. plithos++;
Εύρεση αθροίσματος
1) Μηδενίζω μία μεταβλητή sum=0;
2) Για αν αθροίσω ένα αριθμό num χρησιμοποιώ την εντολή
sum=sum+num; ή sum+=num;
Εύρεση γινομένου
1) Θέτω μία μεταβλητή πχ g=1;
2) Για να πολλαπλασιάσω ένα αριθμό num χρησιμοποιώ την
εντολή g=g*num; ή g*=num;
17
Παράδειγμα 1ο
• Πόσοι αριθμοί που εισάγει χρήστης από το
πληκτρολόγιο πρέπει να προστεθούν για να
ξεπεράσει το άθροισμά τους το 100, και ποιο
το συνολικό άθροισμα;
int total, num;
int plithos=0;
total=0;
while (total<100) {
cout<<"dose arithmo ";cin>>num;
plithos++; total+=num;
}
18
Παράδειγμα 2ο
Μπάλα ρίπτεται από ύψος και const double orio=0.02;
αναπηδά. double ArxikoYpsos; int anapidiseis=0;
Δεδομένου ότι η μπάλα αναπηδά cout<<"\nDoste arxiko ipsos ";
στα 2/3 του προηγούμενου ύψους cin>>ArxikoYpsos;
cout <<"Starting Height: "<<ArxikoYpsos<<"
πόσες φορές αναπήδησε και ποιο το meters "<<endl;
ύψος που φθάνει κάθε φορά. double ipsos=ArxikoYpsos;
Να ληφθεί υπόψη ότι κάτω από το
while (ipsos >=orio) {
0.2cm η μπάλα σταματά να ipsos *=2./3.;
αναπηδά διότι δεν διαθέτει την anapidiseis++;
cout <<" anapidisi "<<anapidiseis<<" = ";
απαιτούμενη ενέργεια. cout<<ipsos<<" meters"<<endl;
To αρχικό ύψος να εισάγεται από το }
πληκτρολόγιο. cout<<"H balla anapidise"<<anapidiseis<<"
fores \n\n";
system("PAUSE");
return 0;
19
break και continue (1)
Η εντολή break:
Η εντολή break χρησιμοποιείται για τον τερματισμό της εκτέλεσης
μιας επαναληπτικής δομής (for, while. do…while). Η εκτέλεση του
προγράμματος μεταφέρεται στην εντολή που υπάρχει αμέσως μετά
την for, while. do…while.
20
break και continue (2)

Η εντολή continue:
Η εντολή continue προκαλεί τη διακοπή εκτέλεσης των εντολών του
βρόχου και τη μεταβίβαση του ελέγχου του προγράμματος στην
επόμενη επανάληψη (βήμα και εξέταση της λογικής συνθήκης
21
Παραδείγματα (1)
Να βρείτε το πλήθος ψηφίων ενός ακέραιου αριθμού. Nα χρησιμοποιηθούν και
οι δύο επαναληπτικές διαδικασίες while και do….while. Να παρατηρήσετε ότι
για τον αριθμό 0 οι δύο διαδικασίες δίνουν διαφορετικό αποτέλεσμα.
22
Παραδείγματα (2)
Να εισάγεται αριθμός χ που να μην γίνεται αποδεκτός παρά
μόνον αν είναι στο διάστημα 0-100.
Κατόπιν να βρίσκεται το άθροισμα των που διαιρούνται με το 4
από το 0 έως τον αριθμό x
23
Ενότητα # 4: Πίνακες
• Δήλωση πίνακα
• Αρχικοποίηση πίνακα
• Συνάρτηση size of
• Επεξεργασία πίνακα
• Πολυδιάστατοι πίνακες
• Παραδείγματα & Ασκήσεις
5
Πίνακας
 Ένας πίνακας είναι μία ομάδα δεδομένων του ιδίου τύπου. Οι
πίνακες δίνουν την δυνατότητα επεξεργασίας πολλών
δεδομένων με γρήγορο και από τρόπο.
Πχ. Για την επεξεργασία των βαθμών των σπουδαστών σε ένα
τμήμα απαιτείται μεγάλο πλήθος μεταβλητών. Για 50
σπουδαστές χρειαζόμαστε 50 μεταβλητές (v1,v2, v3…v50).
Πράξεις και γενικά χειρισμός τόσων μεταβλητών είναι
πρακτικά αδύνατος.
 Με την χρήση πίνακα όλες οι μεταβλητές έχουν ένα κοινό
όνομα και διαφέρουν μόνο ως προς τον δείκτη.
Ορισμός-Δήλωση πίνακα
• Η δήλωση ορισμός γίνεται ως εξής:
type name[size]
Π.χ. float vathmos[50]
// dilonei ena pinaka me 50 theseis kai stoixeia pragmatikous
Π.χ. int v[5]
// dilonei ena pinaka me 5 theseis kai stoixeia akeraious
• H προσπέλαση των στοιχείων γίνεται ως εξής
– Το 1o στοιχεία του ανωτέρω πίνακα είναι το v[0],
– Tο 2o στοιχείο είναι το v[1]
– To τελευταίο στοιχείο του πίνακα είναι το v[4] στη περίπτωση
που έχει δηλωθεί ένας πίνακας v[5] ή το v[49] στην περίπτωση
που έχει δηλωθεί ένας πίνακας v[50]
7
Αρχικοποίηση πίνακα
 Τιμές σε πίνακα μπορούν να δοθούν με τον παρακάτω τρόπο
int v[5]={101,102,103,104,105 }
 Αν το μέγεθος του πίνακα δεν έχει γραφεί τότε με μία
αρχικοποίηση το πλήθος των στοιχείων του πίνακα ορίζεται
από το πλήθος των τιμών τις τιμές που πίνακα
int v[ ]={ 100,200,300}
Με τον τρόπο αυτό ορίζεται πίνακας 3 θέσεων
 Αν στην αρχικοποίηση ενός πίνακα παραληφθούν κάποιες
τιμές τότε είναι 0
int v[5]={101,102}
Οι υπόλοιπες θέσεις του πίνακα δηλ. v[2] =0 , v[3] =0 , v[4] =0
 Η δήλωση int v[50]={0} μηδενίζει όλες τις θέσεις σε ένα πίνακα
Δήλωση πίνακα
Δήλωση πίνακα
int a[10];
Όνομα πίνακα a
Τύπος int
Σύνολο στοιχείων 10
Συνολικά bytes
4X10=40
9
Μέγεθος πίνακα-Συνάρτηση sizeof
 Η συνάρτηση sizeof μπορεί να χρησιμοποιηθεί με πίνακες
και επιστρέφει σαν τιμή το συνολικό μέγεθος σε bytes που
καταλαμβάνει ο πίνακας.
cout<<sizeof(int); //4
cout<<sizeof(double); //8
int i; sizeof(i) ; //4
 Όλα τα στοιχεία του πίνακα έχουν το ίδιος μέγεθος. Για να
βρεθεί το μέγεθος που καταλαμβάνει ένας πίνακας μπορεί
να χρησιμοποιηθεί η εντολής
int plithos = sizeof(pin)/sizeof(pin[0])
 To ίδιο θα ήταν αν χρησιμοποιηθεί η εντολή
float pin[ ];
int plithos = sizeof(pin)/sizeof(float)
10
Επεξεργασία πίνακα
 Γίνεται με την χρήση της εντολής for.
 O λόγος που χρησιμοποιείται το for, αντί για
κάποια άλλη δομή επανάληψης, είναι γιατί είναι
γνωστό το πλήθος των επαναλήψεων που πρέπει
να γίνουν για την πρόσβαση σε όλα τα στοιχεία
του πίνακα.
11
Εισαγωγή και εμφάνιση στοιχείων (1)
12
13
14
Πολυδιάστατος πίνακας
 Ένα πολυδιάστατος πίνακας έχει περισσότερες από μία
διαστάσεις. Πίνακες με παραπάνω από 3 διαστάσεις
συναντιόνται σπάνια στην πράξη.
Δήλωση πίνακα δύο διαστάσεων
 Ένα πίνακας με δύο διαστάσεις που θα είχε την
δυνατότητα να αποθηκεύει τους βαθμούς μίας τάξης 50
ατόμων σε 6 μαθήματα θα οριζόταν ως εξής
float vat[50][6];
 Για τους πίνακες δύο διαστάσεων ισχύουν ότι και για
τους μονοδιάστατους πίνακες σχετικά με την
αρχικοποίηση και τον χειρισμό τους
15
Πίνακας δύο διαστάσεων
 Αρχικοποίηση
int pinax[ 2 ][ 2 ] = { { 11, 22 }, { 33, 44 } };
 Προσοχή στην ομαδοποίηση

int pinax[ 2 ][ 2 ] = { { 11 }, { 3, 4 } };
 Αναπαράσταση πίνακα δύο διαστάσεων

int pin[3][4]
16
Παράδειγμα 1
Να εμφανίζεται πίνακας δύο διαστάσεων στην οθόνη.
Ο πίνακας να αρχικοποιείται μέσα στο πρόγραμμα.
17
18
Άσκηση 1: Εμφάνιση μεγαλύτερου

στοιχείου
Να εισάγονται σε πίνακα 6 αριθμοί. Μετά την εμφάνιση του πίνακα να
εμφανίζεται το μεγαλύτερο στοιχείο του πίνακα και η θέση του.
19
Άσκηση 1: Λύση
20
Άσκηση 2: Εμφάνιση βαθμολογίας
Παρατήρηση
 showpoint: Όταν εμφανίζονται αριθμοί εμφανίζονται πάντα με δεκαδικό σημείο
 fixed: Οι αριθμοί εμφανίζονται με τόσα δεκαδικά ψηφία όσα καθορίζονται από την
setprecision
 right: Στοιχίζει δεξιά
 setprecision(2): καθορίζει το πλήθος των δεκαδικών ψηφίων
21
Άσκηση 2: Εμφάνιση βαθμολογίας
22
Τυχαίοι αριθμοί-Ψευδοτυχαίοι (1)

 Στη βιβλιοθήκη <cstdlib> της Dev C++
υπάρχουν οι συναρτήσεις rand και srand, που
χρησιμεύουν στην δημιουργία μιας
ακολουθίας ψευδο-τυχαίων αριθμών.
 Η συνάρτηση rand() επιστρέφει ένα ακέραιο

αριθμό στο διάστημα [0,RAND_MAX], Η τιμή
RAND_MAX για τον Dev C++ compiler είναι
32767.
 Η συνάρτηση κάνει επιλογή από μία σειρά
αριθμών που παράγονται από μαθηματικούς
τύπους και θεωρούνται τυχαίοι γι αυτό τον
λόγο και ονομάζονται ψευδοτυχαίοι.
23
 Η rand κάνει χρήση μίας τέτοιας
ακολουθίας αριθμών και πάντα αρχίζει
από το ίδιο σημείο έναρξης παραγωγής
των αριθμών αυτών.
 Εάν το πρόγραμμα τρέξει πάλι από την
αρχή θα γίνει παραγωγή των ίδιων
αριθμών.
 Για τον λόγο αυτό χρησιμοποιείται η
συνάρτηση srand(time(0)) αρχικοποιεί την
ακολουθία που παράγει η συνάρτηση
rand με διαφορετική τιμή, λαμβάνοντας
μία τιμή από την ένδειξη του ρολογιού
του υπολογιστή Η συνάρτηση αυτή
βρίσκεται στην βιβλιοθήκη <ctime>) .
24

 Αν χρειαζόμαστε τυχαίους αριθμούς, ακέραιους, σε
κάποιο διάστημα από high έως low τότε (low<high)
αντί για το διάστημα 0-RAND_MAX, χρησιμοποιείται
του ακέραιο υπόλοιπο του τυχαίο αριθμού σύμφωνα
με το τύπο
x=low+rand()%(high-low+1)
εμφανίζεται ακέραιος αριθμός στο διάστημα
[low,low+high] (με w<RAND_MAX)
 πχ. Για να γίνει παραγωγή τυχαίων αριθμών από το
10 έως και το 14
rand()%5 +10
 πχ. Για προσομοίωση μίας ρίψης ζαριού
rand()%6 +1
25
Παράδειγμα
Να εμφανίζονται τα αποτελέσματα 10 ρίψεων που κάνει
παίκτης με δύο ζάρια:
26
Ενότητα # 5: Pointers
• Διευθύνσεις και μνήμη
• Δείκτες
• Πράξεις με δείκτες
• NULL
• Πίνακες & δείκτες
Διευθύνσεις και μνήμη

Η μνήμη αποτελείται από θέσεις
(cells) στις οποίες αποθηκεύονται
δεδομένα.
Κάθε θέση έχει την δική του
διεύθυνση.
Το μέγεθος κάθε κελιού είναι 1 byte.
6
Δείκτες (Pointers)
 Μία μεταβλητή καταλαμβάνει μία ή περισσότερες θέσεις στην μνήμη.
 Οι θέσεις (bytes) που καταλαμβάνει μία μεταβλητή εξαρτάται από τον
τύπο του δεδομένου. Στην Dev C++ για τους γνωστούς τύπους οι θέσεις
είναι :
char 1 byte
int 4 bytes
float 4 bytes
double 8 bytes
 Επειδή η μεταβλητή καταλαμβάνει συνήθως περισσότερα από ένα byte
σαν διεύθυνση της μεταβλητής θεωρείται ότι είναι η διεύθυνση του
πρώτου byte που καταλαμβάνει η μεταβλητής
 Για να υπολογιστεί το μέγεθος μίας μεταβλητής χρησιμοποιώ την
συνάρτηση sizeof
πχ. cout<<sizeof(int) // εμφανίζει τον αριθμό 4
Ορισμός Δείκτη
 Ο δείκτης είναι μία μεταβλητή που σαν περιεχόμενο έχει μία
διεύθυνση της μνήμης.
Πχ. int a=11;
int * pa;
 H pa είναι μία μεταβλητή που σαν περιεχόμενο έχει μία
διεύθυνση μίας ακεραίας μεταβλητής (δηλαδή δείχνει μία
μεταβλητής ακέραιου τύπου).
 Για να δώσω μία τιμή στο pa χρησιμοποιώ τον τελεστή & που
ονομάζεται τελεστής διεύθυνσης (reference operator)
pa=&a;
Η pa έχει σαν περιεχόμενο την διεύθυνση της μεταβλητής a
(&a = address of a)
8
Χρήση Δείκτη
 Επειδή με τον δείκτη έχω πρόσβαση στην διεύθυνση μίας μεταβλητής μπορώ να
έχω και πρόσβαση στο περιεχόμενο της διεύθυνσης αυτής δηλαδή στον αριθμό
που αποθηκεύεται στην μεταβλητή που εχει αυτήν την διεύθυνση
 Αυτό γίνεται με το τελεστή * που μέχρι τώρα χρησιμοποιείται για
πολλαπλασιασμό αλλά και στην δήλωση δείκτη
 Το σύμβολο * χρησιμοποιείται επίσης και σαν
τελεστής έμμεσης αναφοράς (dereference operator, indirection operator) για την
από-αναφοροποιηση (dereferencing) στην τιμή της μεταβλητής που δείχνει ένας
δείκτης, δηλαδή o τελεστής επιτρέπει την έμμεση αναφορά σε τιμή μίας
μεταβλητής.
Με το * εμφανίζεται η τιμή που βρίσκεται στην διεύθυνση που δείχνει (περιέχει ο
δείκτης) δηλαδή:
int a=11;
int * pa=&a;
cout<<*pa //εμφανίζει τον αριθμό 11
Παρατηρήστε ότι :
 οι τιμές του a και *pa είναι οι ίδιες και
 το περιεχόμενο του δείκτη pa που είναι μια διεύθυνση
συμπίπτει με την διεύθυνση που έχει αποθηκευτεί η a.
 H διεύθυνση που έχει αποθηκευτεί η μεταβλητή a
εμφανίζεται με το &a.
10
Παρατηρήσεις
 Για τον ορισμό του ενός δείκτη τα παρακάτω είναι ισοδύναμα.
int* a;
int * a;
int *a;
 Για τον ορισμό περισσοτέρων του ενός δεικτών ο τελεστής * πρέπει να
επαναλαμβάνεται:
int * a,* b,* c, d;
Όλες οι μεταβλητές εκτός από την d είναι τύπου δείκτη, ενώ η d είναι ακέραια
μεταβλητή.
 Ένας δείκτης είναι σαν μία ακεραίου τύπου μεταβλητή. Απλά σαν τιμή έχουν
ένα 16-δικό αριθμό που αναφέρεται σε μία διεύθυνση όπου περιέχεται ένας
αριθμός του ιδίου τύπου με τον τύπο του δείκτη.
 Αν έχω δύο δείκτες πχ int * pa, * pb τότε η εκχώρηση pa=pb σημαίνει ότι ο
δείκτης pa έχει την ίδια τιμή με το δείκτη pb δηλαδή και οι δύο δείκτες δείχνουν
προς την ιδία διεύθυνση, αυτή που δείχνει ο pb
11
12
Σύνοψη
 Η δήλωση ενός δείκτη γίνεται με  Η εντολή *pb=44 έχει σαν
int * pa, *pb; float * pd; αποτέλεσμα τιμή της μεταβλητής
 Αφού δηλωθούν οι μεταβλητές η που δείχνει ο δείκτης pb γίνεται 44
αρχικοποίηση των δεικτών γίνεται  Το σύμβολο * χρησιμοποιείται για
με εκχωρήσεις διευθύνσεων να δηλώσει δείκτες και σαν
pa=&a ; pb=&b; pd=&d; τελεστής έμμεση αναφοράς
 Με την εντολή pa=pb ο δείκτης pa (indirection operator – dereference
και ο pb έχουν το ίδιο περιεχόμενο operator) για την από–
δηλαδή δείχνουν στην ίδια θέση αναφοροποιηση (dereferencing)
της μνήμης στην τιμή της μεταβλητής που
 Με την εντολή *pa=*pb το δείχνει ένας δείκτης, δηλαδή για
περιεχόμενο της μεταβλητής που την έμμεση αναφορά σε τιμή μίας
δείχνει ο pa αλλάζει τιμή μεταβλητής.
13
Συχνά λάθη
 Ο δείκτης είναι διεύθυνση (δεκαεξαδικός αριθμός )  Για την αποφυγή τέτοιων
και παίρνει τιμή με την χρήση του τελεστή & και όχι λαθών καλό είναι με την
με απόδοση αριθμητικής τιμής δήλωση δείκτη ταυτόχρονα να
int* d, x=200 ; αρχικοποιείται
d=&x; // sosto int x=100;
cout<<x<<*d<<endl;; int* d=&x, //arxikopoihsh
d=3000; //lathos (invalid conversion from int to int*
 Με την δήλωση ενός δείκτη ο δείκτης περιέχει μία  Aν αυτό δεν μπορεί να γίνει
τυχαία διεύθυνση. Ενώ μπορώ να εμφανίσω την μπορώ κάνω χρήση μίας
διεύθυνση αυτή αν κάνω χρήση αυτής θα προκαλέσει ειδικής τιμής ώστε ο δείκτης
λάθος-κόλλημα στο πρόγραμμα (crash). Στο να μην δείχνει πουθενά
παρακάτω παράδειγμα ο compiler δεν «ξερει» πού να
βάλει την τιμή 100.
int* d; //xoris arxikopoihsh
cout<<d;
*d=100;
cout<<*d<<endl;
14
NULL
Αν δηλωθεί ένας δείκτης και δεν είμαι σε θέση να τον αρχικοποιήσω
μπορώ να του αποδώσω την τιμή NULL. Στην περίπτωση αυτή ο
δείκτης δεν δείχνει πουθενά.
int *dik =NULL;

if (dik!=NULL)
cout<< *dik;
else
cout<< " O diktis den exei timi akomi";
cout<<*d; //tiponi spoupidia
15
Πράξεις με δείκτες
 Οι δείκτες είναι σαν ακέραιες μεταβλητές.
 Επιτρέπονται πράξεις πρόσθεσης αφαίρεσης αύξησης και μείωσης
δηλαδή επιτρέπεται η χρήση των τελεστών
+ - ++ --
 Όμως προσθέτοντας ή αφαιρώντας από ένα δείκτη προστίθεται ή

αφαιρείται το μέγεθος του τύπου του δείκτη δηλ σε ένα δείκτη pd η
πράξη pd++ ισοδυναμεί με την
pd+sizeof(Type)
όπου Type ο τύπος του δείκτη.
 Πχ. αν ο τύπος του δείκτη είναι ακέραιος προστίθενται 4 bytes στην

διεύθυνση που δείχνει ο δείκτης.
16
int a[ ]={50,55,60,65};
int* dk=&a[2];
int m;
m=*dk+1; cout<<m<<" "; //emfanizei to 61
m=*(dk+1); cout<<m<<" "; //emfanizei to 65
dk--; cout<<*dk<<" ";//emfanizei to 55
17
18
Πίνακες και δείκτες
1. Στην C++ δείκτες και πίνακες έχουν στενή σχέση.
Ο πίνακας a είναι ένας δείκτης του ιδίου τύπου με τον
πίνακα και δείχνει στο πρώτο στοιχείο του πίνακα.
2. Όταν ο compiler συναντά a[n] το μετατρέπει σε *(a+n).

Επομένως το
1ο στοιχειο a[0] του πίνακα είναι το *a
2ο στοιχειο a[1] του πίνακα είναι το *(a+1)
3ο στοιχειο a[2] του πίνακα είναι το *(a+2) κλπ.
19
Δήλωση δείκτη πίνακα

int a[ ]={50,55,60,65};
cout<<*a;
//emfanizetai to 50 dil.to 1o stoixio tou pinaka
cout<<*(a+3)
//emfanizetai to 65 dil.to 4o sroixeio tou pinaka
for (int i=0;i<4,i++)

cout<<*(a+i)<<" ";
Για να δηλώσω ένα δείκτη που δείχνει στο πρώτο στοιχείο του πίνακα μπορώ να το
κάνω με δύο τρόπους:
int a[ ]={50,55,60,65};
int * da=a;
εναλλακτικά χρησιμοποιώ την δήλωση
int * da=&a[0]
20
Να ορισθεί πίνακας με 4 θέσεις και να μηδενιστούν τα στοιχεία του
1ος τρόπος
float p1[4];
cout<<"times for p1"<<endl;
for( int k=0;k<4;k++){
p1[k]=0;
cout<<setw(4)<<p1[k];}
2ος τρόπος
float p2[4];
cout<<"times for p2"<<endl;
for(int k=0;k<4;k++){
*(p2+k)=0;
cout<<setw(4)<<p2[k];}
21
Παρατηρήσεις (1)
 Οι τελεστές ++ και - - έχουν μεγαλύτερη προτεραιότητα από τον τελεστή *
(indirection operator). Επομένως η έκφραση *p++ όταν ο p έχει οριστεί σαν
δείκτης είναι ισοδύναμη με την *(p++), δηλαδή αυξάνεται η τιμή του p ώστε να
δείχνει στο επόμενο στοιχείο.
 Σε εκφράσεις του τύπου κ=*p++ επειδή το ++ χρησιμοποιείται σαν επίθεμα η
παράσταση υπολογίζεται σαν την τιμή που δείχνει ο δείκτης πριν γίνει αύξηση
του δείκτη δηλαδή η *p++ πρώτα εφαρμόζεται ο τελεστής *και μετά ο ++.
Επίσης θα πρέπει να τονιστεί ότι ακόμη και η χρήση παρενθέσεων δεν αλλάζει το
αποτέλεσμα και η παράσταση κ= *(p++) υπολογίζεται σαν την τιμή που δείχνει ο
δείκτης πριν γίνει αύξηση του δείκτη. Δηλαδή οι παραστάσεις κ=*p++ και η κ=
*(p++) είναι ισοδύναμες
int a[2]={10,20};
int* d, k ;
d=&a[0];k=*(d++); cout<<" k= "<<k<<" *d= "<<*d<<endl;
d=&a[0];k=*d++; cout<<" k= "<<k<<" *d= "<<*d<<endl;
// emfanizontai oi idies times k=10 *d=20
22
 Μόνο στην περίπτωση που χρησιμοποιηθεί το ++
σαν πρόθεμα τότε υπολογίζεται η τιμή που δείχνει ο
δείκτης αφού γίνει η αύξηση
d=&a[0];
k=*++d;
cout<<" z= "<<k<<" *d= <<*d<<endl;
// emfanizontai oi times z=20 *d=20
23
24
Παρατήρηση
 Το αναγνωριστικό ενός πίνακα (όνομα) είναι ένας δείκτης
που δείχνει στο πρώτο στοιχείο του πίνακα. Ενώ επιτρέπεται
αλλαγή τιμής σε μία μεταβλητή τύπου δείκτη δεν
επιτρέπεται αλλαγή τιμής σε ένα δείκτη όταν αυτός έχει
δηλωθεί ότι είναι πίνακας.
 Ο δείκτης στην περίπτωση αυτή είναι ένας constant pointer.

Ο λόγος είναι ότι αν αλλάξει η τιμή δεν θα υπάρχει
πρόσβαση στα υπόλοιπα στοιχεία του πίνακα. Το παρακάτω
παράδειγμα εξηγεί το γεγονός αυτό.
25
26
Ενότητα # 6: Συναρτήσεις
• Συναρτήσεις της C++
• Συναρτήσεις που ορίζονται από τον χρήστη
• Πρωτότυπα Συναρτήσεων
• Τύπος αναφοράς
• Κλήση δια τιμής και κλήση με αναφορά
• Εμβέλεια μεταβλητών
5
Συναρτήσεις
 Με την χρήση των συναρτήσεων ένα πρόγραμμα
μπορεί να χωριστεί σε άλλα μικρότερα κομμάτια,
δομές.
 Ο δομημένος προγραμματισμός βασίζεται στην αρχή
της δόμησης μίας εφαρμογής προγραμματισμού
κάνοντας χρήση μικρότερων δομημένων στοιχείων.
 Με την χρήση συναρτήσεων επιτυγχάνεται η
διάσπαση ενός προβλήματος σε μικρότερα.
 Η συνάρτηση είναι ένα σύνολο εντολών που καλείται
και χρησιμοποιείται από ένα σημείο ενός
προγράμματος. Στην C++ ακόμη και το main θεωρείται
ότι είναι μία συνάρτηση.
6
Συναρτήσεις της C++

 Η στανταρντ C++ βιβλιοθήκη περιλαμβάνει ένα πλήθος
συναρτήσεων που μπορεί να χρησιμοποιήσει ο
προγραμματιστής . Τα αρχεία επικεφαλίδων (header files)
περιέχουν τους ορισμούς- δηλώσεις συναρτήσεων που
μπορεί να χρησιμοποιηθούν.
 Πολλές μαθηματικές συναρτήσεις (sin, cos, tan, sqrt κλπ.)
περιέχονται στο αρχείο επικεφαλίδων math.h ή cmath.h
ανάλογα με τον compiler.
Π.χ.
for (k=10; k>=0; k--)
cout<<sqrt(k)<<endl;
7
Συναρτήσεις που ορίζονται από το
χρήστη (1)
 Μία τέτοια συνάρτηση πρέπει να δηλωθεί και να οριστεί πριν γίνει χρήση
της συνάρτησης από το πρόγραμμα. Ο ορισμός μίας συνάρτησης έχει την
παρακάτω μορφή:
Τύπος_επιστροφής συνάρτηση (τύπος παράμετρος1,
τύπος παράμετρος2,…)
{
εντολές
}
 Η παρακάτω συνάρτηση βρίσκει το άθροισμα δύο ακεραίων αριθμών

int athoisma(int a, int b)
{
return a+b;
}
Συναρτήσεις που ορίζονται από το

χρήστη (2)
 Στο παράδειγμα διακρίνονται
int athoisma(int a, int b)
{
return a+b;
}
 Το όνομα της συνάρτησης

 Τον τύπο της επιστροφής
 Τις παραμέτρους και τον ορισμό τους
 Την τιμή που επιστρέφει με την εντολή return. Η συνάρτηση
επιστρέφει μία και μόνο τιμή.
9
using namespace std;
int addition (int a, int b)
{ int p;
p=a+b;
return (p);
}
int main ()
{ int z;
z = addition (15, 8);
cout << "The result is " << z<<"\n";
int k=40,l=50;
z=addition (k, l);
system("PAUSE");
return 0;
}
10
 Υπάρχει αντιστοιχία μεταξύ του τύπου και του αριθμού των παραμέτρων
που χρησιμοποιούνται στον ορισμό και στην κλήση της συνάρτησης.
 Οι παράμετροι που χρησιμοποιούνται για να ορίσουν την συνάρτηση
λέγονται τυπικές παράμετροι (formal parameters). Οι παράμετροι που
χρησιμοποιούνται στην κλήση μίας συνάρτησης λέγονται ορίσματα
(arguments). Τα ορίσματα αναφέρονται στην βιβλιογραφία και σαν
παράμετροι κλήσης ή πραγματικές παράμετροι (actual parameters)
 Μόλις γίνει κλήση της συνάρτησης, οι τιμές των ορισμάτων μεταφέρονται
στις παραμέτρους που βρίσκονται στον ορισμό της συνάρτησης. Η
μεταβλητή p που ορίζεται στην συνάρτηση χρησιμοποιείται για να
υπολογιστεί το άθροισμα και να γίνει επιστροφή του αθροίσματος από
την συνάρτηση στο main.
 Εάν η συνάρτηση δεν επιστρέφει καμία τιμή τότε ορίζεται σαν τύπου void
και δεν υπάρχει return ή υπάρχει χωρίς τιμή (return;) H τιμή που
επιστρέφεται είναι του ιδίου τύπου με την συνάρτηση
11
Πρωτότυπα Συναρτήσεων
 Για να γίνει κλήση μίας συνάρτησης (δηλαδή για να
χρησιμοποιηθεί η συνάρτηση) πρέπει προηγουμένως να έχει
δηλωθεί.
 Η δήλωση γίνεται μέσω του λεγόμενου πρωτότυπου της
συνάρτησης (function prototype) και επιτρέπει στον compiler
να γνωρίζει τα απαραίτητα στοιχεία που αφορούν την
συνάρτηση. Αυτά τα στοιχεία είναι ο τύπος και το όνομα της
συνάρτησης καθώς και ο τύπος και ο αριθμός των
παραμέτρων της συνάρτησης.
12
int addition(int , int ); //prototypo sinartiseis
int main( )
{ int z;
z = addition (15,8);
int k=40,l=50;
z=addition (k,l);
system("PAUSE"); return 0;
}
int addition (int a, int b)
{ int p; p=a+b;
return (p);
}
Σημείωση: Τα ονόματα των παραμέτρων της συνάρτησης μπορούν να
παραληφθούν, όπως γίνεται στο παραπάνω πρωτότυπο
13
Τύπος Αναφοράς
 Το σύμβολο & χρησιμοποιείται σαν τελεστής διεύθυνσης
(address-of operator) για να αποδώσει τιμή σε ένα δείκτη.
 Το ίδιο σύμβολο επίσης χρησιμοποιείται για να δηλώσει
μία μεταβλητή που λέγεται αναφορά ( reference) και είναι
ένα εναλλακτικό όνομα μίας άλλης μεταβλητής
 Π.χ
int x;
int & ax=x;
 Με την δήλωση αυτή η μεταβλητή ax είναι ένα συνώνυμο
της x. Οι δύο μεταβλητές έχουν το ίδιο περιεχόμενο.
14
Κλήση δια τιμής και κλήση με

αναφορά
 Όταν καλείται μία συνάρτηση οι τιμές των ορισμάτων περνούν στην
συνάρτηση με χρήση δύο παραμέτρων κλήσης. Οι τιμές των ορισμάτων
αντιγράφονται σαν τιμές στις παραμέτρους της συνάρτησης δηλαδή
δημιουργούνται αντίγραφα των μεταβλητών κλήσης. Η χρήση της
συνάρτησης με τον τρόπο αυτό λέγεται κλήση δια τιμής (call by value).
Τυχόν αλλαγές των παραμέτρων της συνάρτησης δεν επηρεάζουν τις
αρχικές μεταβλητές στο κυρίως πρόγραμμα γιατί μόνο οι τιμές των
μεταβλητών μεταφέρθηκαν στην συνάρτηση.
 Ένας δεύτερος τρόπος για το πέρασμα τιμών προς την συνάρτηση είναι
με την κλήση διά αναφοράς (call by reference). Με τον τρόπο αυτό η
διεύθυνση του ορίσματος αντιγράφεται στην παράμετρο. Μέσα στην
συνάρτηση η διεύθυνση χρησιμοποιείται για πρόσβαση στο όρισμα.
Τυχόν αλλαγή στην τιμή της παραμέτρου επηρεάζουν και το όρισμα
επειδή οι δύο μεταβλητές αναφέρονται στην ίδια διεύθυνση.
15
Παράδειγμα (χρήση παραμέτρων τιμής)
void func2values (int, int );
// Stin defteri parametro ginetai klisi me anafora
int main ( )
{ int a=10, b=30;
cout << "The result is " << a<< b <<"\n";
func2values(a, b);
system("PAUSE");
return 0; }
void func2values (int x, int y )
{ x=2*x; y=2*y;
cout<<"oi times x kai y edo einai "<< x <<" "<< y <<"\n“; }
 Η κλήση μέσω τιμής δεν μπορεί να επιστρέψει την αλλαγμένη τιμή της
παραμέτρου στο κυρίως πρόγραμμα.
 Ακόμη και με χρήση return μπορώ να επιστρέψω μία και μόνο τιμή.
 Για να γίνει επιστροφή της τιμής κάποιων μεταβλητών χρησιμοποιώ για κάθε μία
από τις μεταβλητές κλήση με αναφορά
16
Παράδειγμα (χρήση παραμέτρων αναφοράς)

void func2values (int, int &);
// Stin defteri parametro ginetai klisi me anafora
int main ( )
{ int a=10, b=30;
func2values(a, b);
system("PAUSE");
return 0; }
void func2values (int x, int & y )
{ x=2*x; y=2*y;
cout<<"oi times x kai y edo einai "<< x <<" "<< y <<"\n"; }
 Η κλήση με αναφορά είναι ένας αποτελεσματικός τρόπος επιστροφής

περισσοτέρων της μίας τιμής συνάρτηση.
 Για να γίνει επιστροφή της τιμής κάποιων μεταβλητών χρησιμοποιώ για κάθε μία
από τις μεταβλητές κλήση με αναφορά
17
Να εμφανίζονται οι προηγούμενη και επόμενη τιμή μίας ακεραίας
μεταβλητής
void func2(int, int &, int &);
// Dio parametroi opou ginetai klisi me anafora
int main ()
{
int a=200, prin, meta;
cout << "The result is " << a<<"\n";
func2(a, meta, prin);
cout << "The result is " << a<<" "<<prin<<" "<<meta<<"\n";
system("PAUSE");return 0; }
void func2(int z , int & x, int & y )

{
x=z+1; y=z-1;
cout<<"oi times x kai y einai "<<x<<" "<<y<<"\n"; }
18
Εμβέλεια Μεταβλητών
 Εμβέλεια (scope) μίας μεταβλητής είναι ο χώρος σε ένα
πρόγραμμα όπου μία μεταβλητή έχει οριστεί και επομένως
μπορεί να χρησιμοποιηθεί.
 Μία μεταβλητή έχει εμβέλεια μόνο μέσα στο μπλοκ των
εντολών που έχει οριστεί. Μπλοκ εντολών είναι μία ομάδα
εντολών που περιέχεται σε αγκύλες { }. Μία τέτοια
μεταβλητή θεωρείται τοπική (local) μεταβλητή.
 Αντίθετα μία καθολική (global) μεταβλητή είναι ορατή από
οποιοδήποτε μέρος ενός προγράμματος. Μία καθολική
μεταβλητή ορίζεται εκτός της συνάρτησης ή του main
19
20
Εμβέλεια Μεταβλητών συνέχεια

 Οι μεταβλητές που ορίζονται μέσα σε επαναλήψεις ισχύον
μόνο για την διάρκεια εκτέλεσης των επαναλήψεων
 Σε ένα μπλοκ εντολών μία τοπική μεταβλητή υπερισχύει μίας
καθολικής που έχει το ίδιο όνομα. Επίσης να σημειωθεί ότι
μετά το πέρας της κλήσης μίας συνάρτησης τυχόν τοπικές
μεταβλητές που έχουν οριστεί μέσα στην συνάρτηση παύουν
να υπάρχουν.
21
Παραδείγματα (εμβέλεια)
22
Λυμένα Παραδείγματα Χρήσης

Συναρτήσεων (1)
Λυμένο Παράδειγμα 1
Να γραφεί πρόγραμμα
που να βρίσκει τον
μεγαλύτερο από 2
ακέραιους. Η εισαγωγή
των αριθμών καθώς και η
εύρεση του μεγαλύτερου
αριθμού να γίνονται με
συναρτήσεις
23
Λυμένα Παραδείγματα Χρήσης
Συναρτήσεων (2)
Λυμένο Παράδειγμα 2
Να γραφεί πρόγραμμα
που να καλεί συνάρτηση
που μετατρέπει τα
δευτερόλεπτα σε
ισοδύναμο χρόνο που
εκφράζεται σε λεπτά και
δευτερόλεπτα. Να
εισάγεται ο αριθμός που
αντιπροσωπεύει
δευτερόλεπτα στο κύριο
πρόγραμμα (πχ 65 sec = 1
min & 5 sec).
24
Ενότητα # 7: Συναρτήσεις και Πίνακες

• Πίνακες ως παράμετροι συνάρτησης
• Συναρτήσεις και Πίνακες
• Παραδείγματα & Ασκήσεις
Συναρτήσεις και Πίνακες (1)

 Ένας πίνακας μπορεί να χρησιμοποιηθεί σαν παράμετρος σε
μία συνάρτηση. Όμως στην C++ δεν γίνεται μεταβίβαση
όλου του πίνακα αλλά μόνο της διεύθυνσης του πρώτου
στοιχείου. Υπενθυμίζεται ότι στη C++ το όνομα ενός πίνακα
είναι ταυτόχρονα και ένας δείκτης.
 Π.χ. Τι θα εμφανίσει το παρακάτω πρόγραμμα
6
Συναρτήσεις και Πίνακες (2)
Πχ
int main(void)
{
int a[10]; //orizetai pinakas
………
sinart(a); //kaleitai mia sinartisi. To a exei thesi deikti
…
}
Η συνάρτηση funct συνεπώς πρέπει να οριστεί ως
int sinart (int * pa).
Ισοδύναμοι τρόποι δήλωσης (1)

 Ο compiler επιτρέπει να γραφεί ισοδύναμα ο ορισμός της συνάρτησης
σαν:
int funct (int pa[ ])
ή ακόμη
int funct (int pa[10])
 ...ώστε να είναι κατανοητό ότι η συνάρτηση καλείται έχοντας έναν
πίνακα σαν παράμετρο. Δηλαδή στον ορισμό των παραμέτρων μίας
συνάρτησης μπορεί να γραφεί μία από τις παρακάτω ισοδύναμες
δηλώσεις
int * pa
int pa[ ]
int pa[10]
 Και οι τρεις τρόποι στην ουσία έχουν σαν αποτέλεσμα την χρήση ενός
δείκτη.
8
Ισοδύναμοι τρόποι δήλωσης (2)
 Όλοι οι ανωτέρω τρόποι δήλωσης έχουν το ίδιο αποτέλεσμα και δηλώνουν ότι
στην κλήση της συνάρτησης ένας πίνακας θα χρησιμοποιηθεί. Στην
πραγματικότητα μόνο μία διεύθυνση θα μεταβιβαστεί προς την συνάρτηση.
 Η διάσταση του πίνακα που δηλώνεται στις τυπικές παραμέτρους δεν παίζει
κανένα ρόλο δηλαδή στο παραπάνω παράδειγμα ο πίνακας μπορεί να δηλωθεί
και σαν int pa[30]. Η C++ δεν κάνει έλεγχο για τα όρια των διαστάσεων σε ένα
πίνακα.
 Επειδή στην ουσία με την κλήση της συνάρτησης που έχει πίνακα σε μία από τις
παραμέτρους δεν μεταβιβάζεται πληροφορία για το πλήθος των στοιχείων του
πίνακα αυτό γίνεται με χρήση μίας άλλης παραμέτρου που μεταβιβάζει το
πλήθος όταν αυτό χρειάζεται. Συμπερασματικά για να χρησιμοποιήσω ένα πίνακα
σε μία συνάρτηση σαν παράμετρο πρέπει να περιλαμβάνεται και το μέγεθος του
πίνακα
Διπλασιασμός κάθε στοιχείου πίνακα με συνάρτηση
void diplas(double v[], int n) //n= plithos stoixeion tou v[]

{ for (int i = 0; i < n; ++i)
v[i]*=2;
}
int main( int argc, char *argv[])
{ double a[]={5,6,10,30};
int plithos=sizeof(a)/sizeof(double); //ypologizo tin diastasi
diplas(a,plithos);
for (int k = 0; k < plithos; ++k)
cout<< a[k]<<" ";
cout<<endl;
system("PAUSE"); return EXIT_SUCCESS;
}
Παρατηρήσεις: Ο ορισμός της συνάρτησης θα μπορούσε να είναι
void diplas(double * v, int n)
void diplas(double v[100], int n)
10
11
Οφέλη από τη χρήση συναρτήσεων

 Μέχρι τώρα ίσως δεν έχει γίνει αντιληπτό η χρησιμότητα
των συναρτήσεων που ορίζονται από τον προγραμματιστή.
 Με την χρήση των συναρτήσεων επιτυγχάνεται:
 Μικρότερος κώδικας (γιατί αποφεύγεται η επανάληψη κώδικα που
χρησιμοποιείται σε διαφορετικά τμήματα ενός προγράμματος
 Δυνατότητα χρήσης της συνάρτησης από άλλα προγράμματα (πχ οι
μαθηματικές συναρτήσεις που προσφέρει η C++.
 Καλύτερος έλεγχος του προγράμματος. (Το συνολικό πρόγραμμα
διασπάται σε μικρότερα τμήματα που έχουν την δυνατότητα να
εκλεχθούν και διορθωθούν πιο εύκολα από τον προγραμματιστή)
12
Λυμένο Παράδειγμα-Εκφώνηση
Να εισάγονται οι βαθμοί δύο τμημάτων που αποτελούνται

από 5 και 6 σπουδαστές. Να εμφανίζεται ο μέγιστος
βαθμός και ο μέσος όρος του κάθε τμήματος. Ποιο τμήμα
πέτυχε τον καλύτερο μέσο όρο; Τέλος να εμφανίζεται το
πλήθος των σπουδαστών που πέτυχαν βαθμό ίσο με τον
μέγιστο σε κάθε τμήμα.
13
Λύση (1)
14
Λύση (2)
15
Λύση (3)
16
Ασκήσεις με Συναρτήσεις και Πίνακες
 Να γραφούν οι παρακάτω συναρτήσεις
1. Συνάρτηση που να βρίσκει τον μέσο όρο των στοιχείων
ενός πίνακα
2. Συνάρτηση που να βρίσκει τον μικρότερο και μεγαλύτερο
στοιχείο ενός πίνακα
3. Συνάρτηση που να βρίσκει τον πλήθος των στοιχείων που
είναι μεγαλύτερο του μέσου όρου του πίνακα
 Οι συναρτήσεις να χρησιμοποιηθούν για δύο πίνακες
πραγματικών αριθμών. Τα αποτελέσματα να εμφανίζονται με
χρήση καταλλήλων μηνυμάτων
17
Λύσεις (1)
18
Λύσεις (2)
19
Λύσεις (3)
20
Παλαιότερα Θέματα_1
21
Άσκηση 1
Άσκηση: Τι εμφανίζει το παρακάτω πρόγραμμα στην οθόνη;
22
Άσκηση 2
Άσκηση: Τι εμφανίζει το παρακάτω πρόγραμμα στην οθόνη;
23
Παλαιότερα Θέματα_2
24
Λυμένο Θέμα_1
Εκφώνηση Λύση
Να γραφεί πρόγραμμα που

Να εισάγει 15 μετρήσεις
κατανάλωσης ρεύματος (ΚW)
από το πληκτρολόγιο. Το
πρόγραμμα να κάνει χρήση
επαναληπτικής διαδικασίας
while.
Να εμφανίζεται πόσες από τις
μετρήσεις είναι μικρότερες
του 80 και ποιος ο μέσος όρος
κατανάλωσης συνολικά.
25
Λυμένο Θέμα_2
Εκφώνηση Λύση
Μία συνάρτηση συνήθως υπολογίζει και επιστρέφει τιμές
(αποτελέσματα) βάσει κάποιων δεδομένων. Να γραφεί
πρόγραμμα που να περιέχει τις κατάλληλες συναρτήσεις (μία
ή περισσότερες) Στο main να εισάγονται τα δεδομένα αφού
γίνει εμφάνιση καταλλήλου μηνύματος. Κατόπιν με χρήση
(κλήση) της συνάρτησης/εων να υπολογίζονται τα
αποτελέσματα/μα. Τα αποτελέσματα θα επιστρέφονται στο
main και θα εμφανίζονται στο main με την χρήση καταλλήλου
μηνύματος. Προσοχή: Να γίνει χρήση μίας συνάρτησης μόνο.
Τα αποτελέσματα θα επιστρέφονται στο main με χρήση
καταλλήλων παραμέτρων και όχι με την εντολή return.
Τα δεδομένα στο παρόν πρόβλημα είναι τρεις τιμές

αντιστάσεων r1 και r2 και r3 σε ένα κύκλωμα. Το αποτέλεσμα
είναι η συνολική αντίσταση TotalS του κυκλώματος όταν οι
αντιστάσεις συνδέονται σε σειρά βάσει του τύπου TotalS
=r1+r2+r3 και η συνολική αντίσταση TotalP όταν οι δύο πρώτες
αντιστάσεις συνδέονται παράλληλα βάσει του τύπου
TotalP=r1*r2/(r1+r2) (Τα δεδομένα είναι τύπου int και τα
αποτελέσματα τύπου float)
26
Ενότητα # 8: Δομές
• Ορισμός δομής
• Εκχώρηση και σύγκριση δομών
• Ορισμός πίνακα από δομή
• Δομές μέσα σε δομές
• Δομές και Συναρτήσεις
• Συναρτήσεις που επιστρέφουν δομές
5
Ορισμός Δομής (1)
 Μία δομή είναι ένας σύνθετος τύπος δεδομένων που ορίζεται από τον
προγραμματιστή. Μία δομή μπορεί να περιέχει διαφορετικούς τύπους
δεδομένων όπως int, chat, double ακόμη και arrays. O ορισμός μίας δομής γίνεται
με την δεσμευμένη λέξη struct. Μία δομή που πχ αναφέρεται σε ένα υπάλληλο
είναι η εξής:
struct ypallilos
{
char eponimo[40];
int age;
double salary;
} yp1;
 Οι μεταβλητές eponimo, age, salary είναι τα μέλη ή πεδία της δομής. Η

μεταβλητή (αναγνωριστικό yp1) συνίσταται από τα τρία αυτά πεδία.
 Στο ανωτέρω παράδειγμα ορίστηκε μία δομή και δημιουργήθηκε μία μεταβλητή
τύπου δομής.
6
Ορισμός Δομής (2)

• Ο ορισμός μίας δομής μπορεί να γίνει χωριστά με την δημιουργία μεταβλητών.
struct ypallilos
{
char eponimo[40];
int age;
double salary;
};
Ypallilos yp1, yp2;
• Στο παραπάνω παράδειγμα υπάρχει ο ορισμός μίας δομής και κατόπιν η

δημιουργία δύο μεταβλητών τύπου δομής με ονόματα yp1 και yp2.
• Η πρόσβαση στα μέλη μία δομής γίνεται με την χρήση το τελεστή (.) τελείας (dot
operator) δηλαδή yp1.age αναφέρεται στην μεταβλητή age του yp1 ενώ το
yp2.salary στην μεταβλητή salary του yp2
7
• To παρακάτω παράδειγμα ορίζει και εκχωρεί τιμές σε δομές
#include <iostream>
int main()
{
struct ypallilos
{
char* eponimo;
int age;
double salary;
} yp1;
yp1.eponimo= "Papadopoulos";
yp1.age = 28;
yp1.salary = 1200;
cout << "Stoixeia ypallilou \n" << yp1.eponimo << " "
<< yp1.age << " " << yp1.salary << endl;
}
8
• Είναι επίσης δυνατόν να οριστεί ο τύπος της δομής και μετά να δηλωθούν και
δημιουργηθούν μεταβλητές του συγκεκριμένου τύπου δομής. Επίσης είναι δυνατό να
δοθούν τιμές στα πεδία μίας δομής ακλουθώντας τον τρόπο που δίδονται τιμές στα
στοιχεία ενός πίνακα.
#include <iostream>
int main()
{ struct ypallilos
{
char* eponimo;
int age;
double salary;
};
ypallilos yp1 ={ "Papadopoulos", 28,1200};
ypallilos yp2 ={ "Pappas", 40,1300};
system("PAUSE"); return 0;}
9
• Στο παραπάνω πρόγραμμα ορίζονται δύο μεταβλητές με
τύπο την δομή ypallilos.
• Ο ορισμός τους είναι με παρόμοιο τρόπο που ορίζονται δύο
μεταβλητές οποιοδήποτε τύπου πχ με δύο ακεραίους int a, b;
• Τα μέλη μπορεί να είναι οποιοσδήποτε τύπος δεδομένων
ακόμη και πίνακες ή και δομές όπως θα δούμε αργότερα. Το
παρακάτω παράδειγμα κάνη χρήση δομής με μέλος ένα
πίνακα
10
#include <iostream>
int main()
{
struct spoudastis
{ char spoud_Name[40];
float spoud_vathmos[2]; };
struct spoudastis sp1;
cout<<" Dose ta stoixia tou spoudasti"<<endl;
cout<<" Eponimo ";
cin.getline(sp1.spoud_Name,40);
cout<<" Vathmo ";
cin>>sp1.spoud_vathmos[0]>>sp1.spoud_vathmos[1];
cout<<endl<< " Stoixeia spoudasti"<<endl;
cout<<sp1.spoud_Name<<" "<<sp1.spoud_vathmos[0]
<<" "<<sp1.spoud_vathmos[1]<<endl;
}
11
Εκχώρηση και σύγκριση δομών
 Επιτρέπεται η εκχώρηση από μία μεταβλητή δομής
σε μία άλλη εφόσον είναι του ιδίου τύπου δομής.
 Αντίθετα όπως είναι γνωστό δεν επιτρέπεται
εκχώρηση από ένα πίνακα σε ένα άλλο γιατί ο
πινάκας θεωρείται ότι είναι δείκτης προς σταθερά
(constant pointer)
12
Παράδειγμα Εκχώρησης
//DS03b
#include <iostream>
int main()
{
struct ypallilos
{ char* eponimo;
int age;
double salary; };
ypallilos yp2 =yp1;
cout << "Stoixeia 1ou ypallilou \n" << yp1.eponimo << " "
cout << "Stoixeia 2u ypallilou \n" << yp2.eponimo << " "
}
13
Εκχωρήσεις - Συγκρίσεις
 Αντί για εκχώρηση μίας δομής σε άλλη το ίδιο αποτέλεσμα επιτυγχάνεται και με εκχωρήσεις
των μελών της μίας μεταβλητής στην άλλη δηλαδή στο παραπάνω παράδειγμα η εκχώρηση
yp2=yp1;
ισοδυναμεί με τις εκχωρήσεις
Yp2.eponimo=yp1.eponymo;
Yp2.age=yp1.age;
Yp2.salary=yp1.salary;
 Ενώ επιτρέπεται εκχώρηση μεταξύ δύο μεταβλητών του ιδίου τύπου δομής για να γίνει
σύγκριση δύο δομών θα πρέπει να εξεταστούν τα πεδία των δύο δομών χωριστά. Το γεγονός
αυτό συνεπάγεται ότι είναι λάθος προτάσεις του τύπου
if (yp2==yp1)
 Η σύγκριση δύο δομών γίνεται με μία πιο σύνθετη λογική πρόταση που εξετάζει όλα τα μέλη
της κάθε μεταβλητής χωριστά
if (yp2.eponimo==yp1.eponimo && yp2.age==yp2.age && yp2.salary==yp1.salary
14
Ορισμός πίνακα από δομή (1)

Ένας πίνακας μπορεί να οριστεί έχοντας σαν στοιχεία μία δομή. Ορίζοντας ένας τέτοιο πίνακα επιτυγχάνεται
μία ομαδοποίηση των δεδομένων.
Παράδειγμα ds05
int main()
{ struct ypallilos
{
char* eponimo; int age; double salary;
};
struct ypallilos epix[2]= //H lexi struct epanalamvanetai

{ //omos mporei kai na min epanalamvanetai
{ "Papadopoulos", 28,1200},
{ "Pappas", 40,1300},
};
cout << "Stoixeia ypallilou \n" << epix[0].eponimo << " "
<< epix[0].age << " " << epix[0].salary << endl;
}
15
Ορισμός πίνακα από δομή (2)
Ο τρόπος αυτός της οργάνωσης είναι καλύτερος από τον ορισμό πολλών πινάκων για
την αποθήκευση των δεδομένων.
Στο παραπάνω παράδειγμα θα έπρεπε να δημιουργηθούν 3 πίνακες για να
αποθηκεύσουν τα δεδομένα: ένας για τα eponimo ένας για τα age ένας για τα salary
O ορισμός πίνακα δομών μπορεί να γίνει ταυτόχρονα με τον ορισμό της δομής
struct ypallilos
{
char* eponimo;
int age;
double salary;
} epix[2] ;
16
Δομές μέσα σε δομές

Μία δομή μπορεί να έχει σαν μέλος οποιοδήποτε τύπο μεταβλητής ακόμη
και μία άλλη δομή. Η πρόσβαση στα μέλη γίνται με διαδοχικές χρήσεις του
τελεστή (.)
struct point {
int x; int y;
};
struct rectangle {
struct point panoAris; struct point katoDexia;
};
int main()
{
struct rectangle rect1;
rect1.panoAris.x=-2; rect1.panoAris.y=3;
rect1.katoDexia.x=8; rect1.katoDexia.y=-1;
double d1= (rect1.panoAris.x-rect1.katoDexia.x);
double d2= (rect1.panoAris.y-rect1.katoDexia.y);
double diag=sqrt(pow(d1,2)+pow(d2,2));
cout<<"diagonios"<<diag<<endl;
system("PAUSE"); return 0;}
17
Δομές και Συναρτήσεις
 Mία δομή μπορεί να μεταβιβαστεί σαν παράμετρος σε μία συνάρτηση τους δύο
γνωστούς τρόπους: δια τιμής και δια αναφοράς. Επιπλέον μία συνάρτηση μπορεί
να επιστρέφει μία τιμή τύπου δομής.
 Αυτό είναι αντίθετο από ότι συμβαίνει με τους πίνακες όπου οι πίνακες
μεταβιβάζονται δια αναφοράς και μόνο, αφού στην ουσία μεταβιβάζεται η
διεύθυνση του πρώτου στοιχείου του πίνακα.
 Επίσης μία συνάρτηση δεν μπορεί να επιστρέφει τιμές τύπου πίνακα.
 Στο επόμενο παράδειγμα χρησιμοποιούνται δύο συναρτήσεις. Η μία συνάρτηση
(inStoixeia) διαβάζει και αποθηκεύει τα στοιχεία μίας δομής. Επειδή η συνάρτηση
καλείται από το κυρίως πρόγραμμα, όπου μεταβιβάζονται και τα εισαγόμενα
στοιχεία, η τυπική παράμετρος της συνάρτησης είναι διεύθυνση προς δομή
(reference to structure) και επομένως η κλήση είναι δια αναφοράς. Η άλλη
συνάρτηση (printStoixeia) εμφανίζει τα στοιχεία της δομής στην οθόνη και η
μεταβίβαση γίνεται δια τιμής.
18
struct dstudent
{ // ds06
char lastName[40];
int testScore; int programmingScore;
double mesos;
};
void inStoixeia(dstudent& fstud)
{ int score;
cout<<"Dose eponymo"; cin >> fstud.lastName;
cout<<"dose tous dio vathmous";
cin >> fstud.testScore >> fstud.programmingScore;
fstud.mesos = (fstud.testScore + fstud.programmingScore) / 2.0; }
void printStoixeia(dstudent fstud)
{
cout<< fstud.lastName<< " " << fstud.testScore
<< " " << fstud.programmingScore << " " << fstud.mesos << endl;
}
int main()
{ dstudent stud1,stud2;
inStoixeia(stud1); inStoixeia(stud2);
printStoixeia(stud1); printStoixeia(stud2);
system("PAUSE"); return 0; }
19
Συναρτήσεις που επιστρέφουν δομές
 Μία συνάρτηση μπορεί να έχει σαν επιστρεφόμενο τύπο μία
δομή. Στην περίπτωση αυτή η συνάρτηση δηλώνεται ότι
επιστρέφει δομή. Το αμέσως προηγούμενο παράδειγμα
μπορεί, αντί της συνάρτησης inStoixeia που είναι τύπου void
να κάνει χρήση μίας συνάρτησης που επιστρέφει στο κυρίως
πρόγραμμα μία δομή. H συνάρτηση ReadStoixeia που
επιστρέφει μία δομή δεν δέχεται καμία παράμετρο και όταν
καλείται στο κυρίως πρόγραμμα η τιμή που επιστρέφει
εκχωρείται σε μεταβλητή τύπου δομής.
 Η συνάρτηση κάνει χρήση μίας τοπικής μεταβλητής τύπου
δομής για να αποθηκεύσει το στοιχεία και η εντολή return
επιστρέφει τα στοιχεία στο κυρίως πρόγραμμα.
20
Παραδείγματα συναρτήσεων που

επιστρέφουν δομές
Παράδειγμα 1 Παράδειγμα 2
//DS 07 eisodos me sinartisi void printStoixeia(dstudent fstud)
#include <iostream> {
cout << fstud.lastName << " " <<
struct dstudent
{ char lastName[40]; fstud.testScore
int testScore; << " " << fstud.programmingScore << " "
int programmingScore; << fstud.mesos << endl;
double mesos; }; }
//sinartisi pou epistrefei domi
dstudent ReadStoixeia ( )
int main()
{ dstudent fstud;
cout<<"Dose eponymo"; {
cin >> fstud.lastName; dstudent stud1,stud2;
cout<<"dose tous dio vathmous"; stud1= ReadStoixeia ( ); stud2=
cin >> fstud.testScore >> fstud.programmingScore; ReadStoixeia ( );
fstud.mesos = (fstud.testScore + fstud.programmingScore) / 2.0; printStoixeia(stud1);
return fstud;
printStoixeia(stud2);
}
}
21
Ενότητα # 9: Εισαγωγή στον Αντικειμενοστραφή
Προγραμματισμό
• Αντικειμενοστραφείς γλώσσες
• Κλάση και Αντικείμενα
• Χρήση αντικειμένων
• Δημόσια και ιδιωτικά μέλη
• Ενθυλάκωση
5
Αντικειμενοστραφείς γλώσσες
 Ενώ ο διαδικαστικός προγραμματισμός δίνει έμφαση στις
διαδικασίες ο αντικειμενοστραφείς δίνει έμφασή στα
αντικείμενα.
 Το μοντέλο στο οποίο βασίζεται μία αντικειμενοστραφής
γλώσσα είναι ο φυσικός και τεχνητός κόσμος που αποτελείται
από αντικείμενα (άνθρωπος, ζώο, σπίτι, αυτοκίνητο κλπ).
 Ένα αυτοκίνητο έχει κάποια βασικά χαρακτηριστικά (ρόδες,
τιμόνι, φρένο). Σε ένα αυτοκίνητο μπορούν να εφαρμοστούν
και ορισμένες διαδικασίες: φρενάρισμα, στρίψιμο, αύξηση
ταχύτητας.
 Ο τρόπος με τον οποίο εφαρμόζονται οι διαδικασίες είναι
κρυμμένος από τον οδηγό (δηλαδή πως φρενάρει ή πως
δουλεύει η μηχανή)
6
Κλάση
 Μια κλάση είναι ένας γενικός ορισμός αντικειμένου που καθορίζει
χαρακτηριστικά και ενέργειες.
 Η κλάση είναι το πρότυπο που δημιουργεί αντικείμενα. Το
αντικείμενο είναι ένα στιγμιότυπο μίας κλάσης.
 Ένα αντικείμενο είναι μία οντότητα που η συμπεριφορά του
καθορίζεται από τις ενέργειες που μπορεί να εκτελέσει το
συγκεκριμένο αντικείμενο.
 Η κλάση autokinito ορίζει μια γενική περιγραφή που θα μπορούσε
να περιλαμβάνει:
 Τα χαρακτηριστικά: μάρκα, χρώμα, θέσεις, τροχοί.
 Τις ενέργειες: pato_gkazi, frenaro, strivo
 To αντικείμενο oxima_ix4054 είναι ένα συγκεκριμένο φυσικό
αντικείμενο που έχει μία και μοναδική ταυτότητα διαθέτει όλα τα
χαρακτηριστικά και τις ενέργειες της κλάσης που ανήκει
7
Κλάση και Αντικείμενα
 Μια κλάση (ή τάξη) είναι μια διευρυμένη έννοια μίας δομής δεδομένων
όπως οι πίνακες ή οι δομές. Όμως μία κλάση αντί να έχει μόνο
δεδομένα, μπορεί να έχει και συναρτήσεις
 Ένα αντικείμενο (object) είναι η υλοποίηση (instantiation- στιγμιότυπο)
μιας κλάσης. Αν δούμε τις κλάσεις σαν μεταβλητές τότε μία κλάση ορίζει
τον τύπο της μεταβλητής ενώ το αντικείμενο είναι μία μεταβλητή που
έχει σαν τύπο την κλάση. Από την άποψη των μεταβλητών, μία τάξη θα
είναι το είδος, και ένα αντικείμενο θα είναι η μεταβλητή.
 Μία τέτοια κλάση θα μπορούσε να είναι η κλάση σπουδαστής ενώ
αντικείμενα οι σπουδαστές ενός τμήματος.
Κλάση και Αντικείμενα (σπουδαστής)
9
Άλλα Χαρακτηριστικά
Ο αντικειμενοστραφής προγραμματισμός διαθέτει και τα παρακάτω
χαρακτηριστικά που βέβαια αντιστοιχούν και το προηγούμενο
παράδειγμα του αυτοκινήτου
• Encapsulation (ενθυλάκωση): Οι διαδικασίες και τα δεδομένα
μπορούν να κρύβονται από το χρήστη
• Polymorphism (πολυμορφισμός): Αντικείμενα που ανήκουν σε
παρόμοιες κλάσεις μπορούν να έχουν κοινά χαρακτηριστικά αλλα και
τρόπο προσπέλασης. Με τον τρόπο αυτό ο χρήστης να μπορεί να τα
χειριστεί χωρίς να χρειάζεται να εφαρμόζει νέες διαδικασίες.
• Inheritance (κληρονομικότητα): Μπορούν να δημιουργηθούν νέα
αντικείμενα με βάση ένα άλλο ήδη υπάρχον και τα νέα αντικείμενα
να κληρονομούν τα χαρακτηριστικά του παλιού αλλά και να
διαθέτουν δικά τους χαρακτηριστικά και ενέργειες.
10
Ορισμός κλάσης στην C++

Στο κομμάτι του διπλανού using namespace std;
προγράμματος ορίζεται μια κλάση
(δηλαδή, ένας τύπος ή είδος) που class Korthogonio {
ονομάζεται Korthogonio. Η κλάση int x, y;
αυτή περιλαμβάνει τέσσερα μέλη: public:
δύο μέλη δεδομένων με τύπο int void TimesPlevron (int a, int b) {
(μέλος x και μέλος y), και δύο μέλη x = a;
y = b;
συναρτήσεις τις TimesPlevron ()
}
και την Emvado (). int Emvado (){
return (x*y);
}
};
11
Public Προσδιοριστικό
 H λέξη public είναι ένα προσδιοριστικό πρόσβασης (access specifier) που
καθορίζει τον τρόπο πρόσβασης που έχουν τα μέλη τους. Η public
καθορίζει ότι οι δύο συναρτήσεις μέλη TimesPlevron Emvado είναι
προσβάσιμα από οποιοδήποτε σημείο, όπου το αντικείμενο έχει οριστεί
και είναι ορατό.
 Οι δυο μεταβλητές x και y είναι private επειδή κάθε μέλος μίας κλάσης
που δεν ορίζεται άμεσα με τον τρόπο πρόσβασης (private, public,
protected) είναι private. Οι τρόποι πρόσβασης θα εξηγηθούν πιο
παρακάτω
 Οι συναρτήσεις μέλη που ανήκουν σε μία κλάση λέγονται και μέθοδοι.
 Συνηθίζεται τα ονόματα των κλάσεων να αρχίζουν με κεφαλαίο γράμμα.
Προσοχή: Μετά τον ορισμό της κλάσης ακολουθεί ερωτηματικό
τερματισμού. Αν παραλειφθεί ο compiler εμφανίζει λάθη τα οποία
παραξενεύουν τον προγραμματιστή και τα οποία δεν σχετίζονται με την
συγκεκριμένη παράλειψη.
12
Χρήση αντικειμένων
 Ενώ έχει οριστεί μία κλάση δεν έχουμε δημιουργήσει ακόμη αντικείμενα.
Τα αντικείμενα έχουν το τύπο της κλάσης και αποτελούν στιγμιότυπα
(instantiations) της κλάσης. Τα αντικείμενα δημιουργούνται με την
δήλωση τους όπως δηλώνονται όλες οι μεταβλητές σε ένα πρόγραμμα,
δηλ.
Korthogonio sxima;
 Μετά την προηγούμενη δήλωση sxima, μπορούμε να αναφερθούμε μέσα

στο σώμα του προγράμματος σε οποιοδήποτε από τα public (δημόσια)
μέλη του sxima αντικειμένου σαν να ήταν συνήθεις συναρτήσεις ή
κανονικές μεταβλητές, απλά τοποθετώντας το όνομα του αντικειμένου
ακολουθούμενο από μια τελεία ( . ) (dot operator ) και στη συνέχεια το
όνομα του μέλους. Η τελεία στην περίπτωση αυτή είναι ένας τελεστής.
13
Πρόσβαση στα μέλη
Η πρόσβαση στις συναρτήσεις μέλη της κλάσης Παρατηρήστε τη διαφορά μεταξύ του ονόματος της
γίνεται με χρήση του τελεστή (.) της τελείας. κλάσης και το ονόματος του αντικειμένου. Στο
προηγούμενο παράδειγμα στην δήλωση
sxima.TimesPlevron (10,20); Korthogonio sxima;
cout << "To emvado = " << sxima.Emvado()<<endl;
Korthogonio ήταν το όνομα της κλάσης (δηλαδή, το
Στην περίπτωση αυτή εφαρμόζουμε την μέθοδο είδος), ενώ sxima ήταν ένα αντικείμενο του τύπου
ΤimesPlevron και την μέθοδο Emvado στο Korthogonio. Είναι η ίδια σχέση που έχουν στην
αντικείμενο sxima. Το πλήρες main είναι: ακόλουθη δήλωση:
int a;
Program 5.1.1 ο τύπος int και η μεταβλητή a. Tο int είναι το όνομα του
int main () { τύπου και το a είναι το όνομα της μεταβλητής.
Korthogonio sxima;
sxima.TimesPlevron (10,20); //xrisi tis Όπως αναφέρθηκε και προηγουμένως οι συναρτήσεις
TimesPlevron sto sxima μέλη που ανήκουν σε μία κλάση λέγονται και μέθοδοι
cout << "To emvado = " << sxima.Emvado()<<endl; και καλούνται πάντα σε συνδυασμό με κάποιο
αντικείμενο δηλαδή εφαρμόζεται η μέθοδος στο
system("PAUSE"); αντικείμενο.
return EXIT_SUCCESS;
}
14
Δημόσια και ιδιωτικά μέλη

 Όπως αναφέρθηκε κλάση Korthogoniο using namespace std;
περιλαμβάνει τέσσερα μέλη: δύο δεδομένα-
μελη με τύπο int (μέλος x και y μέλος), με class Korthogonio {
private πρόσβαση (επειδή η private int x, y;
πρόσβαση είναι η προεπιλεγμένη public:
πρόσβαση) και δύο συναρτήσεις-μέλη με void TimesPlevron (int a, int b) {
public πρόσβαση: TimesPlevron () και την x = a;
Emvado (). y = b;
 Στα μέλη που ορίζονται δημόσια υπάρχει }
πρόσβαση από συναρτήσεις (μαζί και το int Emvado (){ return (x*y); }
main) που δεν ανήκουν στην κλάση. Εξ’ };
ορισμού όποια μέλη δεν είναι δημόσια είναι
int main () {
ιδιωτικά δηλαδή είναι προσβάσιμα μόνο
Korthogonio sxima;
μέσα από την κλάση (δηλαδή από όλες τις sxima.TimesPlevron (10,20);
συναρτήσεις που ορίζονται ή περιγράφονται cout << "To emvado = " << sxima.Emvado()<<endl;
μέσα στην κλάση). Στο παράδειγμα που
είδαμε όλα τα μέλη πριν από την λέξη public system("PAUSE");
είναι ιδιωτικά. return EXIT_SUCCESS;
}
15
 Η πρόσβαση στα μέλη x και y έχει καθοριστεί να είναι private. Η δήλωση
private αρνείται την πρόσβαση σε αυτές τις μεταβλητές από οποιοδήποτε
μέρος έξω από την κλάση.
 Τα x y που είναι ιδιωτικά είναι προσπελάσιμα από την μέθοδο
TimesPlevron γιατί η μέθοδος είναι μέλος της κλάσης. Ο μόνος τρόπος
πρόσβασής και απόδοσης τιμών στα x y είναι μέσα από την συνάρτηση-
μέλος TimesPlevron που μπορεί να καθορίσει τιμές για τα μέλη μέσα
στην κλάση αντικειμένου. Ως εκ τούτου, το υπόλοιπο μέρος του
προγράμματος δεν χρειάζεται να έχει άμεση πρόσβαση σε αυτές τις δύο
μεταβλητές.
16

 Στην συνάρτηση μέλος (μέθοδο) TimesPlevron μπορούν να
χρησιμοποιηθούν οι μεταβλητές x και y, που είναι private μέλη της
κλάσης Korthogonio. Τα x , y είναι προσβάσιμα μόνο από τα άλλα μέλη
της κλάσης τους. Αντίθετα αν στο main υπάρχουν οι εντολές
cout<<sxima.x; ή cout<<x; ή sxima.x=20;
είναι λάθος γιατί το main δεν επιτρέπεται να έχει πρόσβαση στα x y εκτός
αν χρησιμοποιηθεί η μέθοδο TimesPlevron
 Με το τρόπο αυτό επιτυγχάνεται ομαδοποίηση και απόκρυψη στοιχείων –
μελών των αντικειμένων από υπόλοιπο πρόγραμμα. Η δυνατότητα αυτή
αποκαλείται ενθυλάκωση (encapsulation) και είναι ένα από τα βασικά
χαρακτηριστικά του αντικειμενοστραφούς προγραμματισμού.
 Το μόνο τα μέλη του αντικειμένου sxima στα οποία δεν μπορούμε έχουμε
πρόσβαση έξω από την κλάση είναι x και y, επειδή η πρόσβαση είναι
private και είναι προσπελάσιμα μέσα από τα άλλα μέλη της ίδιας κλάσης.
17
Ενθυλάκωση
 Σε μεγαλύτερα προγράμματα είναι πολύ σημαντικό το
γεγονός ότι κάποιο μέλος του αντικειμένου δεν μπορεί
να τροποποιηθεί παρά μόνο με μεθόδους που έχουν
οριστεί για το σκοπό αυτό. Θα προσπαθήσουμε να
δούμε τα οφέλη της ενθυλάκωσης με ένα πολύ απλό
παράδειγμα
 Στο παρακάτω πρόγραμμα οι μεταβλητές x και y δεν
προστατεύονται, αλλά δηλώνονται public δηλαδή
κάποιος μπορεί να αλλάξει τις τιμές μέσα από το main.
 Επομένως η μέθοδος ΤimesPlevron δεν χρειάζεται αφού
με την εντολή sxima.x=10 μπορώ να αλλάξω την πλευρά
ενός αντικειμένου της κλάσης.
18
Παράδειγμα ενθυλάκωσης
using namespace std; Στην περίπτωση που γίνει κάποια αλλαγή στην κλάση Korthogonio θα
class Korthogonio { πρέπει ο προγραμματιστής να φροντίσει οι αλλαγές να γίνουν και στο
public: κυρίως πρόγραμμα.
Αν δηλαδή τα χ y να μετονομαστούν σε p1 και p2 τότε για να τρέξει
int x, y; σωστά το πρόγραμμα θα πρέπει οι εντολές
int Emvado (){ sxima.x=10; sxima.y=20; να γίνουν
return (x*y);} sxima.p1=10; sxima.p2=20;
}; Αντίθετα με την ενθυλάκωση και την χρήση μεθόδων πού έχουν
αποκλειστική πρόσβαση σε μεταβλητές οποιαδήποτε αλλαγή του
int main () { κώδικα στην κλάση δεν απαιτεί αλλαγές στο main όπως φαίνεται στο
Korthogonio sxima; παρακάτω παράδειγμα που είναι το γνωστό παράδειγμα που έχουμε
δεί μέχρι τώρα και που εφαρμόζεται η ενθυλάκωση.
sxima.x=10; public:
sxima.y=20; void TimesPlevron(int a, int b){
cout << "To emvado = " << x = a; y = b;}
sxima.Emvado()<<endl; int Emvado (){
return (x*y);} };
system("PAUSE"); int main () {
return EXIT_SUCCESS; Korthogonio sxima;
sxima.TimesPlevron (10,20); //xrisi tis TimesPlevron sto sxima
} cout << "To emvado = " << sxima.Emvado()<<endl;
system("PAUSE");
return EXIT_SUCCESS; }
19
Οι συναρτήσεις (μέθοδοι) μίας κλάσης μπορούν να οριστούν και
εκτός της κλάσης με τον παρακάτω τρόπο
//5.1.2
class Korthogonio {
int x, y;
public:
void TimesPlevron(int,int);
int Emvado () ;
};
void Korthogonio::TimesPlevron (int a, int b) {
x = a;
y = b;
}
int Korthogonio::Emvado() {
return (x*y);
}
20
 Ο ορισμός του αντικειμένου μπορεί να γίνει και με τον παρακάτω τρόπο.
Οι συναρτήσεις πρώτα δηλώνονται μέσα στην κλάση και μετά ορίζονται
εκτός της κλάσης με την χρήση του scope operator (::) που είναι δύο
άνω κάτω τελείες). Ο scope operator (::) (τελεστής διάκρισης εμβέλειας,
τελεστής επίλυσης εμβέλειας) προσδιορίζει την κλάση στην οποία η
συνάρτηση ανήκει, και η συνάρτηση έχει ακριβώς τις ίδιες ιδιότητες που
έχει το πρωτότυπο της σαν η συνάρτηση συμπεριλήφθηκε μέσα στον
ορισμό της κλάσης.
 Mε τον τρόπο αυτό, ορίζονται τα μέλη μίας κλάσης εκτός του χώρου της
κλάσης, δηλαδή διευκρινίζεται ότι ορίζεται μια συνάρτηση που είναι
μέλος της κλάσης Korthogonio και όχι μία συνηθισμένη συνάρτηση.
 Ο τρόπος αυτός θυμίζει τον τρόπο που συναρτήσεις δηλώνονται πρίν το
main, κάνοντας χρήση των πρωτοτύπων των συναρτήσεων, και ορίζονται
μετά το main.
21
 Χάριν ευκολίας και για να γίνει σύγκριση παρατίθενται οι δύο τρόποι ο
ένας δίπλα στον άλλο:
 Η μόνη διαφορά ανάμεσα σε συνάρτηση με τον πλήρη ορισμό μέσα στην
κλάση του και σε μία συνάρτηση που έχει μόνο το πρωτότυπο στη κλάση
και αργότερα τον ορισμό της, είναι ότι στην πρώτη περίπτωση, η
συνάρτηση θεωρείται αυτομάτως ένα ενσωματωμένο μέλος συνάρτηση
από το μεταγλωττιστή, ενώ στη δεύτερη θα είναι μια inline συνάρτηση
μέλος της τάξης, η οποία στην πραγματικότητα δεν έχει καμία
διαφορετική συμπεριφορά.
 Εξυπακούεται ότι ένα αντικείμενο μπορεί να έχει μερικές από τις
συναρτήσεις να ορίζονται μέσα και κάποιες άλλες έξω από το σώμα του
αντικειμένου αρκεί να χρησιμοποιείται όπου χρειάζεται ο τελεστής (::)
(τελεστής διάκρισης εμβέλειας).
22
//Program 5.1.1 //Program 5.1.2
using namespace std; using namespace std;
class Korthogonio { class Korthogonio {
int x, y; int x, y;
public: public:
void TimesPlevron (int a, int b){ void TimesPlevron(int,int);
x = a; int Emvado () ;
y = b; };
} void Korthogonio::TimesPlevron (int a, int b) {
int Emvado (){ x = a;
return (x*y); y = b;
} }
}; int Korthogonio::Emvado() {
return (x*y);
}
23
Χρήση μιας κλάσης (1)
Ένα από τα μεγαλύτερα πλεονεκτήματα της κλάσης είναι ότι, όπως και κάθε άλλο είδος,
μπορούμε να δηλώσουμε διάφορα αντικείμενα της.
Για παράδειγμα, μετά με το προηγούμενο παράδειγμα της τάξης Korthogonio, θα
μπορούσαμε να έχουμε δηλώσει και ένα άλλο αντικείμενο ή όσα άλλα αντικείμενα θέλουμε:
//Program 5.2.1
class Korthogonio {
int x, y;
public:
void TimesPlevron(int a, int b){ x = a; y = b;}
int Emvado (){return (x*y);}
};
int main () {
Korthogonio sxima1, sxima2;
sxima1.TimesPlevron (10,20);
cout << "To emvado = " << sxima1.Emvado()<<endl;
system("PAUSE");
}
24

 Σε αυτήν την συγκεκριμένη περίπτωση, η κλάση (ο τύπος ή το είδος των
αντικειμένων), με το οποίο μιλάμε είναι Korthogonio, εκ των οποίων
υπάρχουν δύο υλοποιήσεις ( ή στιγμιότυπα) της κλάσης, αντικείμενα τα
sxima1 και sxima2. Κάθε ένα από αυτά έχει τις δικές του μέλη μεταβλητές
και μέλη συναρτήσεις.
 Παρατηρήστε ότι η κλήση της sxima1.Emvado () δεν δίνει το ίδιο
αποτέλεσμα με την κλήση να sxima2.Emvado (). Αυτό οφείλεται στο
γεγονός ότι κάθε αντικείμενο της κλάσης Korthogonio έχει τις δικές του
μεταβλητές x και y, καθώς, κατά κάποιο τρόπο, έχει επίσης τις δικές τους
συναρτήσεις TimesPlevron () και την Emvado () που η καθεμία τους
χρησιμοποιεί τις μεταβλητές του δικού τους αντικειμένου. Όμως στην
πραγματικότητα κάθε αντικείμενο δεν έχει τις δικές του συναρτήσεις
αλλά υπάρχει μόνο ένα αντίγραφο των συναρτήσεων, αυτό που ορίστηκε
στην κλάση, που χρησιμοποιείται από κάθε αντικείμενο. Αυτή είναι η
βασική έννοια του αντικειμενοστραφούς προγραμματισμού: Τα
δεδομένα και οι συναρτήσεις είναι μέλη του αντικειμένου.
25
 Δεν χρειάζεται πλέον η χρήση των global μεταβλητών που
περνάμε από τη μία συνάρτηση στην άλλη σαν παραμέτρους
αλλά αντ 'αυτού θα χρησιμοποιούμεν αντικείμενα που έχουν
τα δικά τους δεδομένα και συναρτήσεις ενσωματωμένες ως
μέλη.
 Παρατηρήστε ότι δεν υπάρχουν παράμετροι όταν γίνεται
κλήση στις συναρτήσεις sxima1.emvado ή sxima2.emvado. Οι
εν λόγω συναρτήσεις μέλη χρησιμοποιούν απευθείας τα
δεδομένα μέλη των αντίστοιχων αντικειμένων sxima1 και
sxima2 επειδή έχουν το δικαίωμα της απευθείας πρόσβασης.
26
Ενότητα # 10: Constructors και Destructors

• Constructor και destructor
• Χρήση constructor
• Πολλαπλοί Constructors
• Χρήση destructor
Δισαφήνιση των εννοιών constructor

και destructor
 Οι δύο αυτές έννοιες αποδίδονται στην Ελληνική
βιβλιογραφία με πολλά ονόματα.
 Τα πιο συνηθισμένα είναι δομητές και αποδομητές,
κατασκευαστές και καταστροφείς, συναρτήσεις
δόμησης και αποδόμησης, δημιουργοί και
καταστροφείς. Χάριν ευκολίας θα χρησιμοποιηθούν
τα Αγγλικά ονόματα.
6
Constructors (1)
 Είναι αναγκαίο τα αντικείμενα να αρχικοποιούν τις
μεταβλητές ή να τους αποδίδεται δυναμική μνήμη κατά τη
διάρκεια της διαδικασίας της δημιουργίας τους για να
λειτουργούν σωστά και να αποφεύγεται η εμφάνιση
απροσδόκητων τιμών κατά τη διάρκεια της εκτέλεσής τους.
 Για παράδειγμα, τι θα συνέβαινε αν στο προηγούμενο
πρόγραμμα γινόταν κλήση στην συνάρτηση μέλος Emvado ()
προτού κληθεί η συνάρτηση TimesPlevron (); Μάλλον θα
είχαμε πάρει ένα απροσδιόριστο αποτέλεσμα δεδομένου ότι
στα μέλη x και y ποτέ δεν έχει ανατεθεί μια τιμή. Ένα τέτοιο
γεγονός φαίνεται όταν τρέξουμε το προηγούμενο
πρόγραμμα καλώντας την συνάρτηση Emvado() πριν δοθούν
τιμές στα αντικείμενα.
7
Constructors (2)
 Προκειμένου να αποφευχθεί αυτό, μια κλάση
μπορεί να περιλαμβάνει μια ειδική συνάρτηση που
ονομάζεται constructor, η οποία καλείται αυτόματα
κάθε φορά που ένα νέο αντικείμενο της κλάσης
αυτής έχει δημιουργηθεί. Αυτή η συνάρτηση
constructor ακολουθεί τους παρακάτω κανόνες
 πρέπει να έχει το ίδιο όνομα με την κλάση, και
 δεν μπορεί να επιστρέφει τιμή (ούτε καν και την τιμή
void), δηλαδή μία συνάρτηση constructor δεν έχει τύπο.
8
Program 5.3.1
class Korthogonio {
int x, y;
public:
void TimesPlevron(int a, int b){ x = a; y = b;}
};
int main () {
Korthogonio sxima1, sxima2;
// Xrisi Emvado() xoris na exoun apodothei times
system("PAUSE");
}
Χρήση Constructors
Οι constructors χρησιμοποιούνται για να αποδώσουν τιμές στις μεταβλητές που είναι μέλη
μίας κλάσης. Οι τιμές αυτές μπορεί να είναι οποιεσδήποτε θέλει ο προγραμματιστής ή
κάποιες εξ ορισμού τιμές. H κλάση Korthogonio συμπεριλαμβανομένου μίας constructor
μεθόδου παρουσιάζεται παρακάτω:
Program
using namespace std;//5.4.1
class Korthogonio {
int x, y;
public:
Korthogonio(int a, int b){x = a; y = b;};
int Emvado (){return (x*y);};
};
int main () {
Korthogonio sxima1 (10,20); //Dilosi kai arxikopoihsi antikeimenou
system("PAUSE");
}
10
Όπως μπορείτε να διαπιστώσετε, τα αποτελέσματα του
προγράμματος αυτού είναι το ίδιο με την προηγούμενο
παράδειγμα που διέθετε την συνάρτηση TimesPlevron.
Αλλά τώρα, έχουμε αφαιρέσει την συνάρτηση TimesPlevron (), και
έχουμε συμπεριλάβει ένα constructor (κατασκευαστή) που εκτελεί
μια παρόμοια λειτουργία δηλαδή αποδίδει τιμές ( αρχικοποιεί)
στις μεταβλητές x y κάνοντας χρήση των παραμέτρων που
υπάρχουν στην συνάρτηση constructor.
Υπενθυμίζεται ότι χωρίς τον ορισμό ενός constructor πρώτα πρέπει
να οριστούν τα αντικείμενα και μετά να γίνει αρχικοποίηση όπως
φαίνεται και στο παρακάτω πρόγραμμα που έχουμε δεί και
χρησιμοποιείται για την κατανόηση των εννοιών κλάσεων και
αντικειμένων από την αρχή του κεφαλαίου αυτού.
11
Παράδειγμα Constructor
class Korthogonio { //5.1.1 Ο constructor Korthogonio μπορεί να
int x, y; οριστεί και εκτός της κλάσης
public:
void TimesPlevron(int a, int b){ x = a; y = b;} using namespace std; //5.5.1
class Korthogonio {
int Emvado (){return (x*y);} int x, y;
}; public:
Korthogonio(int , int );
int Emvado ();
int main () { };
Korthogonio sxima1;
sxima1.TimesPlevron (10,20); Korthogonio::Korthogonio(int a, int b){
x = a; y = b;}
cout << "To emvado = " <<
sxima1.Emvado()<<endl; int Korthogonio::Emvado (){
return (x*y);}
system("PAUSE"); int main () {
return EXIT_SUCCESS; Korthogonio sxima1 (10,20);
} cout << "To emvado = " << sxima1.Emvado()<<endl;
system("PAUSE");
}
12
Πολλαπλοί Constructors (1)
Μία κλάση μπορεί να έχει παραπάνω από ένα constructors με διαφορετικό όμως τύπο και
πλήθος παραμέτρων. Όλοι οι constructors σε μία κλάση πρέπει να έχουν το ίδιο όνομα και
αυτό που διαφοροποιεί τον ένα από τον άλλο είναι οι παράμετροι. (Γίνεται υπερφόρτιση-
overloading).
using namespace std; //5.6.1

class Korthogonio {
int x, y;
public:
Korthogonio(){x=0;y=0;} //default contructor (xoris parametrous)
Korthogonio(int a, int b){ x = a; y = b;}
};
int main () {
Korthogonio sxima1 (10,20), sxima2 (40,50);
cout << "To emvado = " << rect1.Emvado()<<endl;
Korthogonio sxima3;
system("PAUSE");
}
13

 Στο παραπάνω πρόγραμμα, παρατηρήστε για το πώς αυτά τα ορίσματα
περνιόνται στον constructor κατά τη στιγμή την οποία δημιουργήθηκαν
τα αντικείμενα της κλάσης αυτής ανάλογα με τις παραμέτρους που
χρησιμοποιούνται:
 Με την εντολή: Korthogonio sxima1 (10, 20), sxima2 (40, 50);
γίνεται χρήση του δεύτερου constructor που έχει οριστεί στο τμήμα
public ενώ στην περίπτωση του sxima3 γίνεται κλήση του πρώτου
constructor. Με τον τρόπο αυτό και ορίζονται αλλά και αρχικοποιούνται
τα αντικείμενα.
 Οι constructors δεν μπορούν να καλούνται άμεσα σαν να ήταν ένα κοινό
μέλος της κλάσης. Εκτελούνται μόνον όταν ένα νέο αντικείμενο της
κλάσης αυτής έχει δημιουργηθεί. Μπορείτε επίσης να δείτε πως ούτε στο
πρωτότυπο του constructor (εντός της κλάσης) ούτε ο τελευταίος
ορισμός του constructor περιλαμβάνει κάποια τιμή επιστροφής ούτε καν
void.
14
 Οποιοσδήποτε constructor που δεν έχει παραμέτρους καλείται εξορισμού constructor
(default constructor). Μία κλάση διαθέτει τον εξορισμό constructor με δύο τρόπος:
• είτε ο προγραμματιστής ορίζει ένα τέτοιο constructor
• είτε ο compiler αυτόματα δημιουργεί ένα τέτοιο constructor στην περίπτωση που
στη κλάση δεν συμπεριλαμβάνεται κανένας constructor από τον προγραμματιστή. Στην
δεύτερη αυτή περίπτωση όμως δεν αρχικοποιείται κανένα αντικείμενο.
 Αν ο προγραμματιστής ορίσει κάποιο constructor ο compiler δεν δημιουργεί αυτόματα τον
εξ’ ορισμού constructor.
 Σε όλες τις συναρτήσεις ο προγραμματιστής μπορεί να εκχωρήσει κάποιες εξορισμού τιμές
στις παραμέτρους. Το ίδιο μπορεί να γίνει και στις συναρτήσεις μέλη μίας κλάσης καθώς
και στους constructors που και αυτοί είναι συναρτήσεις. Οι αρχικές τιμές εκχωρούνται στην
περίπτωση που κληθεί o constructor χωρίς παραμέτρους. Το παρακάτω πρόγραμμα
περιέχει μόνο ένα constructor με τον οποίο υπάρχει δυνατότητα απόδοσης αρχικών τιμών.
15
using namespace std;//5.6.2
class Korthogonio {
int x, y;
public:
Korthogonio(int a=0, int b=0){ x = a; y = b;}
};
int main () {
// kaleitai o constuctors me tis default times 0,0
Korthogonio sxima3;
system("PAUSE");
return EXIT_SUCCESS; }
Προσοχή: Συνήθως όλες τις φορές είναι απαραίτητο να αρχικοποιείται ένα αντικείμενο γι’ αυτό
καλό είναι πάντα να περιλαμβάνεται ένας constructor στο ορισμό μίας κλάσης.
16
Destructors
 Μια συνάρτηση destructor εκπληρώνει το αντίθετο από ένα constructor.
Καλείται αυτόματα όταν ένα αντικείμενο καταστρέφεται, είτε επειδή το
πρόγραμμα έχει φτάσει σε σημείο εκτός του πεδίου εμβέλειας του
αντικειμένου (για παράδειγμα, σε περίπτωση που ορίστηκε ως ένα
τοπικό αντικείμενο μέσα σε συνάρτηση και η συνάρτηση τελειώνει) ή
επειδή είναι ένα αντικείμενο που έχει δημιουργηθεί με δυναμική
κατανομή μνήμης και απελευθερώνεται η μνήμη που καταλαμβάνει
χρησιμοποιώντας τον τελεστή delete.
 Οι destructors πρέπει να έχουν το ίδιο όνομα με την κλάση, αλλά
προηγείται το σύμβολο (~) και δεν θα πρέπει να επιστρέφει καμία τιμή.
Εάν δεν ορίζεται από τον προγραμματιστή δημιουργείται αυτόματα από
το πρόγραμμα. Κάθε κλάση έχει ακριβώς ένα destructor δηλαδή
απαγορεύεται να γίνει υπερφόρτωση σε ένα destructor (ενώ μπορεί να
έχει παραπάνω από ένα constructor). O destructor αυτός είναι είτε ο εξ
ορισμού που δημιουργεί αυτόματα το σύστημα είτε ένας που ορίζει ο
προγραμματιστής
17
Χρήση Destructors
• Η χρήση των destructors είναι ιδιαίτερα κατάλληλη,
όταν σε ένα αντικείμενο εκχωρείται δυναμική μνήμη
κατά τη διάρκεια της ζωής του και κατά τη στιγμή της
καταστροφής θέλουμε να απελευθερωθεί η μνήμη
που καταλαμβάνει το αντικείμενο.
• To επόμενο παράδειγμα εμφανίζει τον τρόπο που
δημιουργείται και καταστρέφεται ένα αντικείμενο. Ο
τρόπος αυτό για να είναι κατανοητός περιλαμβάνει
εντολές εμφάνισης μηνυμάτων (cout) μέσα στους
ορισμούς των constructor και destructor.
18
Παραδείγματα χρήσης Destructors
Παράδειγμα 1 Παράδειγμα 2
using namespace std; int main () {
{Korthogonio sxima1 (100,23);
class Korthogonio { {Korthogonio sxima2 (400,50);
int x, y; cout << "To emvado = " <<
public: sxima2.Emvado()<<endl;
~Korthogonio(); }
Korthogonio(int , int ); cout << "To emvado = " <<
int Emvado (){return (x*y);} sxima1.Emvado()<<endl;
}; }
system("PAUSE");
Korthogonio::Korthogonio(int a, int b){ return EXIT_SUCCESS;
x = a; y = b; cout<<"Dimiourgia antikeimeno"<<endl;
}
}
Korthogonio::~Korthogonio() {
cout<<"Katastrofi antikeimeno"<<endl;
}
19
class Korthogonio {
int x, y;
public:
~Korthogonio();
Korthogonio(int , int );
};
Korthogonio::Korthogonio(int a, int b){

x = a; y = b; cout<<"Dimiourgia antikeimeno"<<endl;
}
Korthogonio::~Korthogonio() {
cout<<"Katastrofi antikeimeno"<<endl;
}
20
int main () {
}
}
system("PAUSE");
}
21
Εργαστήριο 1
Εισαγωγή στο περιβάλλον Dev C++ και στην γλώσσα C++
Άσκηση 1.1
Εύρεση του μεγαλύτερου από 3 ακέραιους που εισάγονται από το πληκτρολόγιο
#include <cstdlib>
#include <iostream>
int main(int argc, char *argv[])

{
// Ena aplo programma stin C++
int a,b;
cout<<"dose proto arithmo :";cin>>a;
cout<<"dose deutero arithmo:";cin>>b;
cout<<"to athrisma einai ="<<a+b<<'\n';
cout<<"i diafora einai ="<<a-b<<endl;
cout<<"to ginomeno einai ="<<a*b<<'\n';
cout<<"to piliko einai ="<<a/b<<endl;
system("PAUSE");
}
Υπεύθυνος καθ. Κ. Κουκουλέτσος Εργαστήρια Προγραμματισμού

Άσκηση 1.2
Να εκτελεστεί το παρακάτω πρόγραμμα. Με την βοήθεια του καθηγητή να διορθωθούν τα
συντακτικά λάθη και να γίνουν κατανοητές οι παρακάτω έννοιες
Αρχεία επικεφαλίδων (Header files)
Ρεύμα εξόδου και εισόδου
Εμφάνιση αριθμών
Χρήση ειδικών χαρακτήρων εξόδου και χαρακτήρων
#include <cstdlib>
#include <iostream>

{
// Ena aplo programma stin C++
int a,b;
cout<<"dose proto arithmo :";cin>>a;
cout<<"dose deutero arithmo:";cin>>b;
cout<<"to athrisma einai ="<<a+b<<'\n';
cout<<"i diafora einai ="<<a-b<<endl;
cout<<"to ginomeno einai ="<<a*b<<'\n';
cout<<"to piliko einai ="<<a/b<<endl;
system("PAUSE");
}

Άσκηση 1.3
Να γραφεί πρόγραμμα που να υπολογίζει το τετράγωνο ενός ακέραιου αριθμού και την
τετραγωνική ρίζα
Υπόδειξη: Θα χρειαστεί η συνάρτηση sqrt και η βιβλιοθήκη (αρχείο επικεφαλίδων) cmath ή την
math.h. Να γίνει χρήση του τύπου double για τον υπολογισμό της τετραγωνικής ρίζας.
#include <cstdlib>
#include <iostream>
#include <cmath>

{
// Evresi tetragonou kai rizas enos akeraiou
int a,tetr;
double riza;
cout<<"dose ena arithmo :";cin>>a;
tetr=a*a;
cout<<"to tetragono tou arithou ";
cout<<a<<" einai = "<<tetr;
riza=sqrt(a);
cout<<"h tetrafoniki riza tou arithou";
cout<<a<<" einai = "<<riza;
system("PAUSE");
}

Άσκηση για τον σπουδαστή
Να δημιουργήσετε ένα νέο project με όνομα askisi13 που να υπολογίζεται η υποτείνουσα ενός
ορθογωνίου τριγώνου όταν εισάγονται οι δύο κάθετες πλευρές.
Να γίνει εκτέλεση του προγράμματος και να ελεγχθεί ότι το πρόγραμμα είναι σωστό για τις
παρακάτω τριάδες αριθμών που αντιπροσωπεύουν τις δύο πλευρές ορθογωνίου τριγώνου και την
υποτείνουσα
Πλευρά Α Πλευρά Β Υποτείνουσα τριγώνου

3 4 5
5 12 13
6 8 10
8 15 17
9 12 15

Να δημιουργήσετε ένα νέο project με όνομα askisi14 που να υπολογίζεται το εμβαδόν τριγώνου
βάσει του τύπου του ¨Ήρωνα κάνοντας χρήση του μήκους των τριών πλευρών.
(a  b  c)
s( s  a)(s   )(s   ) s
Ε= όπου 2
η ημιπερίμετρος του τριγώνου
Να γίνει εκτέλεση του προγράμματος και να ελεγχθεί ότι το πρόγραμμα είναι σωστό για τις
παρακάτω αριθμούς που αντιπροσωπεύουν τις τρεις πλευρές ορθογωνίου τριγώνου και το
εμβαδόν του
Πλευρά Α Πλευρά Β Πλευρά Γ Εμβαδόν
9 15 12 54
3 5 4 6
6 10 8 24

Εντολή if…else, switch, for
Άσκηση 2.1
Εύρεση του μεγαλύτερου από 3 ακέραιους που εισάγονται από το πληκτρολόγιο
#include <cstdlib>
#include <iostream>

{
int a,b,c,meg;
cout<<"Dose 3 akeraious"<<endl;
cin>>a>>b>>c;
if (a>b){
if (a>c) {
meg=a;
}
else{
meg=b;
}
}
else {
if (b>c){
meg=b;
}
else {
meg=c;
}
}
cout<<"o megaliteros apo tous akeraious einai = "<<meg<<endl;
system("PAUSE");
}

Άσκηση 2.2
Nα εισάγεται βαθμός ενός σπουδαστή και να εμφανίζεται μήνυμα με τον χαρακτηρισμό του βαθμού
#include <cstdlib>
#include <iostream>

{
float vathmos;
cout << "Dose bathmo spoudasti ";
cin >> vathmos;
if ((vathmos < 5) && (vathmos >= 0))
cout << "Apotixia";
else
if ((vathmos<6.5) && (vathmos >= 5.0))
cout << "Kalos";
else
if ((vathmos < 8.5) && (vathmos >= 6.5))
cout << "Lian kalos";
else
if ((vathmos<= 10) && (vathmos >= 8.5))
cout<<"arista";
else
cout << "O vathmos einai ektos orion 0-10";
cout<<"\n\n\n";
system("PAUSE");
}
Παρατηρήσεις:
 Το if… else θεωρείται μία εντολή και δεν χρειάζεται να περικλείεται σε αγκύλες { }
 Το ίδιο πρόγραμμα με διαφορετική στοίχιση γράφεται με τέτοιο τρόπο που διευκολύνει το διαχωρισμό
των περιπτώσεων

Άσκηση 2.3 (Διαφορετική στοίχιση)
#include <cstdlib>
#include <iostream>
{
12345678901234567890
float vathmos;
cout << "Dose bathmo spoudasti ";
cin >> vathmos;
if ((vathmos < 5) && (vathmos >= 0))
cout << "Apotixia";
else if ((vathmos<6.5) && (vathmos >= 5.0))
cout << "Kalos";
else if ((vathmos < 8.5) && (vathmos >= 6.5))
cout << "Lian kalos";
else if ((vathmos<= 10) && (vathmos >= 8.5))
cout<<"arista";
else
cout << "O vathmos einai ektos orion 0-10";
cout<<"\n\n\n";
system("PAUSE");
}

Άσκηση 2.4
Με χρήση εντολής switch να εμφανίζεται το αποτέλεσμα της πράξης δύο ακεραίων
#include <cstdlib>
#include <iostream>

{
float num1,num2;
char op;
cout<<"Dose arithmo, praxi kai pali arithmo \n";

cin>>num1>>op>>num2;
switch(op)
{
case '+':
cout<<"Apotelesma "<<num1+num2<<endl;
break;
case '-':
cout<<"Apotelesma "<<num1-num2<<endl;
break;
case '/':
cout<<"Apotelesma "<<num1/num2<<endl;
break;
case '*':
case 'x':
cout<<"Apotelesma "<<num1*num2<<endl;
break;
default:
cout<<"Lathos dedomena"<<endl;
}
system("PAUSE");
}
 Υπάρχουν δύο case για τις περιπτώσεις εισαγωγής πολλαπλασιασμού με την μορφή * και /

Εντολή for while, do… while
Άσκηση 3.1
Εύρεση αθροίσματος ακεραίων με χρήση της εντολής for
#include <cstdlib>
#include <iostream>

{
int num,sum;
cout<<"Dose ena akeraio ";
cin>>num;
sum=0;
for (int i=1; i<=num; i++)
sum+=i;
cout<<"\nTo athrisma 1 eos "<<num<<" einai = "<<sum<<endl;
system("PAUSE");
}

Άσκηση 3.2
Εμφάνιση ενός πολλαπλασιαστικού πίνακα με χρήση nested for
#include <cstdlib>
#include <iostream>
#include <iomanip>
//pollaplasiastikow pinakas ton arithom 1-10

{
int k,p;
for (int i=1;i<=10;i++){
for ( k=1;k<=10;k++){
p=i*k;
cout<<setw(4)<<p;
}
cout<<endl;
}
system("PAUSE");
}
 Το setw καθορίζει το εύρος εκτύπωσης και χρειάζεται την βιβλιοθήκη iomanip

Άσκηση 3.3
Πόσοι αριθμοί που εισάγονται από το πληκτρολόγιο πρέπει να προστεθούν για να ξεπεράσει το
άθροισμά τους το 100, και ποιο το συνολικό άθροισμα; H λύση εμφανίζεται στο παρακάτω
πρόγραμμα.
Άσκηση για τον σπουδαστή:
Η ίδια άσκηση να γραφεί με χρήση της εντολής do…while. Να διαπιστωθεί ότι και οι δύο δομές
δίδουν το ίδιο αποτέλεσμα και να δοθεί προσοχή στην περίπτωση που ο πρώτος αριθμός που θα
δοθεί είναι μεγαλύτερος του 100.
int total, num;

int plithos=0;
total=0;
while (total<100) {
cout<<"dose arithmo ";cin>>num;
plithos++; total+=num;
}
cout<<"\n\ndothikan "<<plithos<<" arithmoi\n";
cout<<"siloniko athroisma "<<total<<"\n\n";

Άσκηση 3.4
Μπάλα ρίπτεται από ύψος και αναπηδά. Δεδομένου ότι η μπάλα αναπηδά στα 2/3 του
προηγούμενου ύψους πόσες φορές αναπήδησε και ποιο το ύψος που φθάνει κάθε φορά. Να
ληφθεί υπόψη ότι κάτω από το 0.2cm η μπάλα σταματά να αναπηδά διότι δεν διαθέτει την
απαιτούμενη ενέργεια.. To αρχικό ύψος να εισάγεται από το πληκτρολόγιο.
#include <iostream.h>
#include <stdlib.h>
int main()
{
const double orio=0.2;
double ArxikoYpsos; int anapidiseis=0;
cout<<"\nDoste arxiko ipsos "; cin>>ArxikoYpsos;
cout <<"Starting Height: "<<ArxikoYpsos<<" meters "<<endl;
double ipsos=ArxikoYpsos;
while (ipsos >=orio) {
ipsos *=2./3.;
anapidiseis++;
cout <<" anapidisi "<<anapidiseis<<" = ";
cout<<ipsos<<" meters"<<endl;
}
cout<<" H balla anapidise "<<anapidiseis<<" fores \n\n";
system("PAUSE");
return 0;

Άσκηση 3.5
Να γραφεί το πρόγραμμα σε γλώσσα C++ που να βρίσκει το πλήθος ψηφίων ενός ακέραιου
αριθμού. Να χρησιμοποιηθεί η εντολή do ….while
Να μετασχηματίστε την επαναληπτική διαδικασία do.. while και να επιλύεται το πρόβλημα με τον
ίδιο τρόπο με χρήση της εντολής while. Βεβαιωθείτε ότι όταν εισάγεται ο αριθμός 0 εμφανίζεται και
πάλι το σωστό πλήθος ψηφίων.
#include <cstdlib>
#include <iostream>
int main(void)
{
int num,intnum;
int plithos=0;
cout<<"Give me a number ";
cin>>num;
// using do statement
intnum=num;
do
{
plithos++;
intnum=intnum/10.;
}
while (intnum !=0);
cout << "The number "<<num<< " has "<< plithos <<" digits"<<endl;
system("PAUSE");
}

Τυχαίοι αριθμοί στην C++
Στη βιβλιοθήκη <cstdlib> της Dev C++ υπάρχουν οι συναρτήσεις rand και srand ,που χρησιμεύουν
στην δημιουργία μιιά ακολουθίας ψευδο-τυχαίων αριθμών. Η συνάρτηση rand() επιστρέφει ένα
ακέραιο αριθμό στο διάστημα [0,RAND_MAX], Η τιμή RAND_MAX για τον Dev C++ compiler είναι
32767. Η συνάρτηση srand(time(0)) αρχικοποιεί την ακολουθία που παράγει η συνάρτηση rand με
διαφορετική τιμή, λαμβάνοντας μία τιμή από την ένδειξη του ρολογιού του υπολογιστή Η
συνάρτηση βρίσκεται στην βιβλιοθήκη <ctime>) .Αν χρειαζόμαστε τυχαίους αριθμούς, ακέραιους,
σε κάποιο διάστημα από high έως low τότε (low<high) αντί για το διάστημα 0-RAND_MAX,
χρησιμοποιείται του ακέραιο υπόλοιπο του τυχαίο αριθμού σύμφωνα με το τύπο
x=low+rand()%(high-low+1)
εμφανίζεται ακέραιος αριθμός στο διάστημα [low,low+high] (με w<RAND_MAX)
Πχ. Για να γίνει παραγωγή τυχαίων αριθμών από το 10 έως και το 14

rand()%5 +10
Παράδειγμα: Να εμφανίζονται τα αποτελέσματα 10 ρίψεων που κάνει παίκτης με δύο ζάρια
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
int main ()
{
int zari1,zari2;
srand ( time(NULL) ); // initialize random seed
for (int i=0;i<36;i++){
zari1 = rand() % 6 + 1; //tixaios apo 1 eow 6: */
zari2 = rand() % 6 + 1;
cout<<zari1<<" "<<zari2<<" ";
if (zari1==4 && zari2==4) cout<<" dortia";
if (zari1==6 && zari2==6) cout<<" exares";
cout<<endl;
}
system("PAUSE");
return 0;
}

Άσκηση 3.6
Στο παιχνίδι εύρεσης ενός αριθμού ο παίκτης προσπαθεί να μαντέψει ένα αριθμό από το 0 έως το
10 . Ο αριθμός είναι ένας κρυφός τυχαίος αριθμός και έχει παραχθεί από τον υπολογιστή. Στον
παίκτη παρουσιάζονται μηνύματα που υποδεικνύουν αν ο κρυφός αριθμός είναι πιο μικρός ή πιο
μεγάλος. Όταν ο χρήστης ανακαλύψει τον αριθμό να εμφανίζεται σχετικό μήνυμα.
#include <stdlib.h>
#include <time.h>
#include <iostream>
int main ()
{
int mystikos, epilogi;
srand ( time(NULL) ); // initialize random seed

mystikos = rand() % 10 + 1; // tixaios apo 1 eow 10: //
do {
cout << "Vres ton arithmo apo to 1 eos 10: ";
cin>>epilogi;
if (mystikos<epilogi) cout<<"Mantepse pio hamila\n";
else if (mystikos>epilogi) cout<<"Mantepse pio psila\n";
} while (mystikos!=epilogi);
cout<<"Mpravo ton vrikes"<<endl;
system("PAUSE");
return 0;
}
Να προστεθούν οι κατάλληλες εντολές ώστε να εμφανίζεται και πόσες προσπάθειες έχει κάνει
συνολικά ο παίκτης μέχρι να μαντέψει σωστά τον αριθμό.

Άσκηση 3.7
Να γραφεί πρόγραμμα με το οποίο να εισάγονται ακέραιοι αριθμοί από το πληκτρολόγιο. Η
διαδικασία εισαγωγής σταματά όταν γίνει εισαγωγή του αριθμού -99 οπότε και εμφανίζεται ο μέσος
όρος των αριθμών που εισήχθησαν.
#include <cstdlib>
#include <iostream>

{
int plithosScores, sum, score;
float average;
sum = 0;
plithosScores = 0;
cout << "Enter a test score ( -99 to quit ): ";

cin >> score;
while ( score != -99 )
{
sum += score;
plithosScores++;
cout << "Enter a test score ( -99 to quit ): ";
cin >> score;
}
average = float(sum) / plithosScores;
cout << "The average of the " << plithosScores << " was " << average
<< endl;
system("PAUSE");
return EXIT_SUCCESS;}

1) Τι γίνεται στην περίπτωση που κανένας αριθμός δεν εισάγεται δηλαδή όταν εισαχθεί αμέσως
ένας αριθμός =-99 ; Να γίνει η κατάλληλη αλλαγή για την περίπτωση αυτή.
2) Να γίνει επέκταση του προγράμματος γράφοντας την ίδια διαδικασία με χρήση της εντολής
do…while και να γίνει έλεγχος ότι και στις δύο περιπτώσεις το αποτέλεσμα είναι το ίδιο.

Πίνακες (Μονοδιάστατοι και δύο διαστάσεων)
Άσκηση 4.1
Να εισάγονται σε πίνακα 6 αριθμοί. Μετά την εμφάνιση του πίνακα να εμφανίζεται το μεγαλύτερο
στοιχείο του πίνακα και η θέση του.
#include <cstdlib>
#include <iostream>
const int LIM = 6;
int main()
{
int table[LIM];
int i, maxpos, minpos;
int max, min;
cout<<"Tha ginei eisagogi "<<LIM<<" arithmon \n\n\n";
for (i = 0; i < LIM; i++) {
cout<<"Dose ton "<<i+1<< " arithmo : ";
cin>>table[i];
}
cout<<" Ta stoixeia tou pinaka einai"<<endl;
for (i = 0; i < LIM; i++)
cout<<table[i]<<" ";
maxpos = 0;
max = table[0];
for (i = 0; i < LIM; i++)

if (table[i] > max) {
max = table[i];
maxpos = i;
}
cout << endl<<endl;

cout <<"Megistos = "<<max << ", stin thesi = "<<maxpos<<endl;
system("PAUSE");
return 0;
}

Να γίνει επέκταση της άσκησης ώστε να εμφανίζεται και το μικρότερο στοιχείο του πίνακα και η
θέση του.
Τι εμφανίζεται αν όλα τα στοιχεία του πίνακα είναι ίσα;

Άσκηση 4.2
Να γίνεται εμφάνιση ενός καταλόγου με τους βαθμούς σπουδαστών σε θεωρία και εργαστήριο. Οι
βαθμοί των σπουδαστών για ευκολία εισάγονται με αρχικοποίηση πινάκων. Η εμφάνιση του
καταλόγου να περιλαμβάνει σχόλια ανάλογα αν ο σπουδαστής πέρασε το μάθημα στην
περίπτωση που και οι δύο βαθμοί του είναι πάνω από 5 ή μόνο το εργαστήριο ή την θεωρία. Η
εμφάνιση του καταλόγου να γίνεται με στοιχισμένη μορφή όπως φαίνεται στο παρακάτω σχήμα.
#include <cstdlib>
#include <iostream>
#include <iomanip.h>
{
cout << showpoint << fixed << right<<setprecision(2);
float theo[15]={6,3,8,2,7,4,9,5,7,4,10,3,7,8,9};
float erga[15]={3,2,7,8,9,6,5,5,5,8,7,10,5,7,3};
float math[15];
cout<<" a/a Theoria Ergastirio Sxolio vathmos
"<<endl<<endl;
for (int i=0;i<15;i++)
{
cout<<setw(3)<<i+1<<" "<<setw(8)<<theo[i]<<" "<<setw(8)<<erga[i]<<"
";
if (theo[i]<5 && erga[i]<5)
cout<<" Apotixia "<<"------"<<endl;
else if (theo[i]<5 )
cout<<" Apot. theoria "<<"------"<<endl;
else if (erga[i]<5)
cout<<" Apot. ergastirio "<<"------"<<endl;
else {
math[i]=(theo[i]+erga[i])/2;
cout<<" Epitixos ";
cout<<math[i]<<endl; }
}
cout<<endl<<endl;
system("PAUSE");
}

Να γίνει αλλαγή της άσκησης ώστε να εμφανίζεται μόνο ο μέσος όρος της θεωρίας και του
εργαστηρίου και σχόλιο “epitixos” αν ο μέσος όρος είναι πάνω του 5 και “anepitixos” στην αντίθετη
περίπτωση

Άσκηση 4.3
Να εμφανίζεται πίνακας δύο διαστάσεων στην οθόνη. Ο πίνακας να αρχικοποιήται μέσα στο
πρόγραμμα.
#include <cstdlib>
#include <iostream>
#include <iomanip>
const int NROW = 3;
const int NCOL = 5;
int main()
{
int k, j;
// ta stoixeia tou pinaka
int arr[NROW][NCOL]
={ 10, 20, 30, 40, 50 ,
11, 21, 31, 41, 51 ,
12, 21, 32, 42, 52 };
// emfanisi tou pinaka
for (k = 0; k < NROW; k++) {
for (j = 0; j < NCOL; j++)
cout << setw(4)<<arr[k][j] << " ";
cout << endl;
}
cout << endl << endl << endl;
system("PAUSE");
}

Να γίνει αλλαγή της άσκησης ώστε να εμφανίζεται το άθροισμα κάθε γραμμής καθώς και η θέση
(γραμμή και στήλη) του μεγαλύτερο στοιχείου του πίνακα

Δείκτες - Πράξεις με δείκτες
Άσκηση 5.1-5.4
Υπολογίστε με το χέρι τα αποτελέσματα στα παρακάτω προγράμματα και γράψτε τα
αποτελέσματα στο αντίστοιχα πλαίσια, όπου αυτά υπάρχουν. Κατόπιν συγκρίνεται τα
αποτελέσματα με αυτό που θα εμφανιστούν όταν το πρόγραμμα εκτελεστεί στον Η/Υ.
#include <cstdlib>
#include <iostream>
#include <stdlib.h>
int main()
{
{//Askisi 61
cout<<"Askisi 71"<<endl;
int k=77;
int* d;
cout<<sizeof(int)<<" "<<sizeof(char)<<" ";
cout<<sizeof(double)<<" "<<sizeof(float)<<endl;
d=&k;
cout<<"k= "<<k<<" *d= "<<*d<<endl;
cout<<"&k= "<<&k<<" d= "<<d<<endl; Askisi 51
system("PAUSE");
}
{//Askisi 62
cout<<endl<<endl;
int k=77, n=3;
int* d1,*d2;
d1=&k;d2=&n; cout<<k<<" "<<n<<" "<<*d1<<" "<<*d2<<endl;
*d2=*d1; cout<<k<<" "<<n<<" "<<*d1<<" "<<*d2<<endl;
k=77;n=3; d2=d1; cout<<k<<" "<<n<<" "<<*d1<<" "<<*d2<<endl;
system("PAUSE");
} Askisi 52
{//Askisi 63
cout<<endl<<endl;
int k=66,n=5;
int* d1,*d2;
d1=&k;
d2=&n;
*d2=*d1;
*d1=44;
cout<<k<<" "<<n<<" "<<*d1<<" "<<*d2<<endl;
system("PAUSE");
} Askisi 53
{//Askisi 64
cout<<endl<<endl;
int a[7];
int* d, k ;
cout<<"program 1"; cout<<endl;
for (k=0;k<7;k++)
{a[k]=2*k;cout<<a[k]<<" ";} Askisi 54
cout<<endl;
d=&a[4]; cout<<*d++<<" ";
cout<<*d<<" ";cout<<endl;
system("PAUSE");
}
}

Ασκήση 5.5
#include <cstdlib>
#include <iostream>
#include <iomanip> Askisi 55
{
int a[]={50,55,60},i;
int* d=&a[0] ;
i=*d+1 ;cout<<i<<" "<<*d<<endl;
i=*(d+1);cout<<i<<" "<<*d<<endl;
//
d=&a[0];
i=*d++; cout<<i<<" "<<*d<<endl;
//
d=&a[0];
i=*(d++); cout<<i<<" "<<*d<<endl;
//
d=&a[0];
i=(*d)++; cout<<i<<" "<<*d<<endl;
//
cout<<i<<endl;
cout<<sizeof(d)<<sizeof(i);
float * df;
cout<<sizeof(df)<<sizeof(float);
cout<<endl<<endl;
system("PAUSE");
}

Άσκηση 5.6
Να εισάγεται αριθμός χ που να μην γίνεται αποδεκτός παρά μόνον αν είναι στο διάστημα 50-100.
Κατόπιν να βρίσκεται το άθροισμα των που διαιρούνται με το 4 από το 0 έως τον αριθμό χ
#include <stdlib.h>
int main()
{
int x,k, s=0;
cout<<"DOSE ARITHMO:";
cin>>x;
while (x<=50||x>100){
cout<<"o arithmos pou edoses einai ektos oriwn"<<endl;
cout<<"DOSE ARITHMO:";
cin>>x;
}
k=x; s=0;
while (k>0){
if (!(k%4)) {
cout<<k<<" ";
s+=k;
}
k--;
}
cout<<endl;
cout<<"ATHRISMA="<<s<<endl;
system("PAUSE");
return 0;
}

Να γίνει η επαναληπτική διαδικασία του πρώτου while με την χρήση του do..while
Να γίνει επέκταση της άσκησης ώστε να εμφανίζεται και ο μέσος όρος των στοιχείων που
αθροίζονται.

Σχέση πίνακα με δείκτες -Απλές συναρτήσεις
Άσκηση 6.1
Παρατηρήστε πως γίνεται εμφάνιση του πίνακα με 3 τρόπους.
Υπόδειξη: Η άσκηση αυτή δεν είναι απαραίτητο να πληκτρολογηθεί στον υπολογιστή
#include <iostream>
#include <stdlib.h>
int main()
{ //apodosi timon se pinaka kai emfanisi me 3 tropous
//1os tropos
float b[4];
for (int k=0;k<4;k++) {
b[k]=4 ;
cout<<"b["<<k<<"]="<<b[k]<<" ";}
cout<<endl;
//2os tropos me xrisi deikti pou orizetai me ton pinaka

for (int m=0;m<4;m++){
*(b+m)=5 ;
cout<<"b["<<m<<"]="<<*(b+m)<<" ";}
cout<<endl;
//3os tropos me xrisi voithitikou deikti
cout<<"times for b "<<endl;
for(float * d=b;d<b+4;d++) {
*d=6; cout<<*d<<" ";}
cout<<endl;
system("PAUSE");
return 0;
}

Άσκηση 6.2
Nα οριστεί και να γίνει χρήση μία συνάρτησης που να υπολογίζει την τρίτη δύναμη ακεραίων
αριθμών
#include <conio.h>
#include <iomanip.h>
int cube(int x)
{
return x*x*x;
}
int main()
{
int k;
for (k=0;k<11; k++)
cout<<"number"<<setw(5)<<k<<" sto kibo= "<<cube(k)<<endl;
system("PAUSE");
return 0;
}

Nα οριστεί και να γίνει χρήση μία συνάρτησης που να υπολογίζει το πηλίκο αριθμών. Η συνάρτηση
να καλείται από το main όπου με χρήση επαναληπτικής διαδικασίας να ευρίσκεται και εμφανίζεται
το πηλίκο των αριθμών από το 20-40 με ένα αριθμό που εισάγεται από το πληκτρολόγια

Άσκηση 6.3
Να οριστεί και να γίνει χρήση συνάρτησης που να υπολογίζει και επιστρέφει τον μεγαλύτερο από
δύο ακέραιους αριθμούς.
#include <iostream>
#include <stdlib.h>
int max2(int ,int);
int main()
{
int k,l;
cout<<"Dose 2 akereous"<<endl;
cin>>k>>l;
cout<<"o megalyros apo tous dio einai ="<<max2(k,l)<<endl;
system("PAUSE");
return 0;
}
int max2(int x,int y)
{
if (x>y)
return x;
else
return y;
}

Να γραφεί πρόγραμμα που να κάνει χρήση της συνάρτησης της παραπάνω άσκησης και να
βρίσκει τον μέγιστο από 3 ακέραιους αριθμούς.

Άσκηση 6.4
Να γίνεται ανταλλαγή στις τιμές δύο ακεραίων μεταβλητών. Οι τιμές τους εισάγονται από το
πληκτρολόγιο. Για την αλλαγή να γίνει χρήση καταλλήλου συνάρτησης.
void allagi( int &, int &);
// Dio parametroi opou ginetai klisi me anafora
int main ()
{
int a, b;
cout<<"Dose dio akeraies times";
cin>>a>>b;
cout<<"a= "<<a<<" b= "<<b<<endl;
allagi(a, b);
cout<<"a= "<<a<<" b= "<<b<<endl;
system("PAUSE");
return 0;
}
void allagi (int & x , int & y )
{
int temp;
temp=x;
x=y;
y=temp;
}

Να γραφεί πρόγραμμα που να καλεί συνάρτηση που μετατρέπει ένα αριθμό που αντιπροσωπεύει
λεπτά της ώρας σε ώρες και δευτερόλεπτα. Ο αριθμός που αντιπροσωπεύει λεπτά εισάγεται από
το πληκτρολόγιο.

Συναρτήσεις Ι
Άσκηση 7.1
Το παρακάτω πρόγραμμα αθροίζει τα στοιχεία σε ένα πίνακα.
#include <cstdlib>
#include <iostream>
int athpin(int pin[ ], int plithos) {

int sum=0;
for (int i=0;i<plithos;i++)
sum=sum+pin[i];
return sum;
}

{
int a[10]={1,2,3,4,5,6,7,8,9,10};
cout<<"To athroisma ton soixeion einai= "<<athpin(a,10)<<"\n";
int b[ ]= {100, 200, 300, 400, 500, 600};

cout<<"To athroisma ton soixeion einai= "<<athpin( b,
sizeof(b)/sizeof(int))<<"\n";
system("PAUSE");
return 0;
}

Άσκηση 7.2
Να γραφεί πρόγραμμα που να καλεί συνάρτηση που μετατρέπει μία τιμή που αντιπροσωπεύει
δευτερόλεπτα σε λεπτά και δευτερόλεπτα (δηλ. τα 70 δευτερόλεπτα είναι 1 λεπτό και 10
δευτερόλεπτα). Να εισάγεται ο αριθμός που αντιπροσωπεύει δευτερόλεπτα στο κύριο
πρόγραμμα.
include <iostream.h>
#include <conio.h>
//=============================================
int dose1() //function
{
int a;
cout<<"dose ton xrono "; cin>>a;
return a;
}
//=============================================
void sectomin(int x, int & a,int & b) //definition of function
{
a=x/60;
b=x%60;
}//=============================================
int main( )
{
int k,l,m;
k=dose1();
sectomin(k,m,l);
cout<<"o xronos eine "<<m<< " lepta kai "<<l<<" defterolepta\n";
system("PAUSE");
}

Να γραφεί παρόμοια άσκηση που να μετατρέπονται ένας αριθμός που αντιπροσωπεύει cm σε ένα
συμμιγή αριθμό που αποτελείται από Km, m, και cm (δηλαδή σε 200101 cm είναι 2km 1m και 1
cm. Όλες οι εμφανίσεις (εκτυπώσεις) των αριθμών να γίνονται μέσα από το main και όχι στις
συναρτήσεις.

Άσκηση 7.3
Να εισάγονται οι βαθμοί δύο τμημάτων που αποτελούνται από 5 και 6 σπουδαστές. Να εμφανίζεται
ο μέγιστος βαθμός και ο μέσος όρος του κάθε τμήματος με χρήση συναρτήσεων average και
megistos. Ποιο τμήμα πέτυχε τον καλύτερο μέσο όρο. Τέλος να εμφανίζεται το πλήθος των
σπουδαστών που πέτυχαν βαθμό ίσο με τον μέγιστο σε κάθε τμήμα με χρήση συνάρτησης
plithos. Όλες οι εμφανίσεις (εκτυπώσεις) των αριθμών να γίνονται μέσα από το main και όχι στις
συναρτήσεις.
#include <iostream>
double average(double v[], int n) { //n einai to plithos sτoixeion v[]
double s = 0.0;
for (int i = 0; i < n; ++i)
s += v[i];
return s / n;
}
double megistos( double v[], int n) {

double max = v[0];
for (int i = 0; i < n; ++i)
if (max < v[i])
max = v[i];
return max;
}
int plithos( double v[], int n) {

int pli=0; double meg;
meg=megistos(v,n);
for (int i = 0; i < n; ++i)
if (v[i] == meg)
pli++;
return pli;
}
int main( int argc, char *argv[]) {
double a[6]={6,8,10,10,7,5};
double b[5]={5,9,9,6,9};
double megA,megB,aveA,aveB;
megA=megistos(a,6); aveA=average(a,6);
aveB=average(b,5); megB=megistos(b,5);
cout << "Megigtos A tmimatos="<<megA<<"O mesos A tmimatos="<<aveA<<
endl<<endl;
cout << "Megigtos B tmimatos="<<megB<<"O mesos B tmimatos = "<<aveB<<
endl<<endl;
if (aveA<aveB)
cout<<"To proto tmima exei kalitero meso \n\n";
else if(aveA>aveB)
cout<<"To deftero tmima exei kalitero meso \n\n";
else
cout<<"Ta dio tmimata exoyn petixei isous mesous \n\n";
int plitA, plitB;

cout<<"To plithos ton bathmon pou isoutai me to megisto " <<
plithos(a,6)<<endl;
cout<<"To plithos ton bathmon pou isoutai me to megisto " <<
plithos(b,5)<<endl;
system("PAUSE");
}

Να γίνει επέκταση του προγράμματος και να οριστούν οι συναρτήσεις elaxistos, που να βρίσκει τον
μικρότερο από τους βαθμούς σε κάθε τάξη, καθώς και plithela που βρίσκει το πλήθος των
σπουδαστών που πέτυχαν βαθμό ίσο με τον ελάχιστο σε κάθε τμήμα. Ο μικρότερος βαθμός κάθε
τάξης και τα πλήθος να εμφανίζονται στην οθόνη. Όλες οι εμφανίσεις (εκτυπώσεις) των αριθμών
να γίνονται μέσα από το main και όχι στις συναρτήσεις.

Συναρτήσεις ΙΙ
Άσκηση 8.3
#include <cstdlib>
#include <iostream>
#include <iomanip>
{
cout<<"Askisi 10.3"<<endl;
int a[]={200,300,400},i;
int* d=&a[0] i=*d+1 ; cout<<" 1 "<<i<<" "<<*d<<endl;

i=*(d+1); cout<<" 2 "<<i<<" "<<*d<<endl;
d=&a[0]; i=*d++; cout<<" 3 "<<i<<" "<<*d<<endl;
d=&a[0]; i=*(d++); cout<<" 4 "<<i<<" "<<*d<<endl;
d=&a[0]; d++; cout<<" 5 "<<*d<<endl;
int * p =a; cout<<" 6 "<<*p+1<<" "<<*(p+1)<<" "<<endl;
i=(*d)++; cout<<" 7 "<<i<<" "<<*d<<endl;
cout<<endl<<endl;
system("PAUSE");
return 0;
}

Άσκηση 8.2
Να γραφούν οι παρακάτω συναρτήσεις
Συνάρτηση που να βρίσκει τον μέσο όρο των στοιχείων ενός πίνακα
Συνάρτηση που να βρίσκει τον μικρότερο και μεγαλύτερο στοιχείο ενός πίνακα
Συνάρτηση που να βρίσκει τον πλήθος των στοιχείων που είναι μεγαλύτερο του μέσου όρου του
πίνακα
Οι συναρτήσεις να χρησιμοποιηθούν για δύο πίνακες πραγματικών αριθμών. Τα αποτελέσματα να
εμφανίζονται με χρήση καταλλήλων μηνυμάτων.
#include <iostream>
double average(double v[], int n)
//n einai to plithos sroixeion tou v[]
{
double s = 0.0;
for (int i = 0; i < n; ++i)
s += v[i];
return s / n;
}
double megmik (double v[], int n, double & max, double & min)
{ max = v[0]; min =v[0];
for (int i = 0; i < n; ++i)
{if (v[i]> max) max = v[i];
if (v[i]< min) min=v[i];
}
int pliMegAver(double pin[],int diaA, double aver)

{
int pli=0; double meg;
for (int i = 0; i < diaA; ++i)
if (pin[i] > aver)
pli++;
return pli;
}
int main( int argc, char *argv[])

{
double a[]={6.5,8.2,10.6,19.7,7.24,26.2};
double b[]={2.1, 40.3, 5.8, 9.2, 17.4};
double meg, mik;

int diaA=sizeof(a)/sizeof(double);
int diaB=sizeof(b)/sizeof(double);
megmik(a,diaA, meg, mik);
cout<<"To max kai to min toy pinaka a einai "<<meg<<" "<<mik<<endl;
megmik(b,diaB, meg, mik);
cout<<"To max kai to min toy pinaka b einai "<<meg<<" "<<mik<<endl;
double aveA=average(a,diaA);
double aveB=average(b,diaB);
cout<<"Oi mesoi ton pinakon einai "<<aveA<<" "<<aveB<<endl;
cout<<"to plithos ton stoixeion > tou mesou einai
"<<pliMegAver(a,diaA,aveA)<<endl;
cout<<"to plithos ton stoixeion > tou mesou einai
"<<pliMegAver(b,diaB,aveB)<<endl;
system("PAUSE");
return EXIT_SUCCESS;}

Το πρόγραμμα να δοκιμαστεί και στους παρακάτω πίνακες
double a[]={5,5,5,9};
double b[]={10,10,10,5,5};

Άσκηση 8.3 Άσκηση για τον σπουδαστή
Στην παρακάτω άσκηση να συμπληρωθούν τα κενά σύμφωνα ώστε το πρόγραμμα :
Να καλεί συνάρτηση που να εμφανίζει ένα ποσό που δίνεται σε ευρώ από πόσα χαρτονομίσματα
των 500, των εκατό, των είκοσι και κέρματα του ενός ευρώ αποτελείται. Η μετατροπή γίνεται ώστε
το αρχικό ποσό να μετατρέπεται στον ελάχιστος αριθμός χαρτονομισμάτων και κερμάτων. Να
εισάγεται ο αριθμός που αντιπροσωπεύει δευτερόλεπτα στο κύριο πρόγραμμα. (πχ 1133 ευρώ
αποτελείται από 2 πεντακοσάρικα, 1 κατοστάρικο, 1 εικοσάρικο και 13 ευρώ)
#include <iostream>
#include <conio.h>
//=============================================
int dose1() //function
{
}
//=============================================
void euro(int x, int & penta, int & eka,int & eiko, int & mono)
//definition of function
{
Pe
}//=============================================
int main( )
{
int arxiko,k,l,m,n;
arxiko=dose1();

Δομές
Άσκηση 9.1
Να εκτελεστεί το παρακάτω πρόγραμμα
#include <iostream>
int main()
{
struct ypallilos
{
char* eponimo;
int age;
double salary;
} yp1;
yp1.eponimo= "Papadopoulos";
yp1.age = 28;
yp1.salary = 1200;
}

Άσκηση 9.2
#include <iostream>
int main()
{
struct ypallilos
{
char* eponimo;
int age;
double salary;
} ;

ypallilos yp2 =yp1;
ypallilos yp3;
yp3.eponimo=yp1.eponimo;
yp3.age=yp1.age;
yp3.salary=yp1. salary;
}

Άσκηση 9.3
#include <iostream>
int main()
{
struct spoudastis
{
char spoud_Name[40];
float spoud_vathmos[2];
};
struct spoudastis sp1;

cout<<" Dose ta stoixia tou spoudasti"<<endl;
cout<<" Eponimo ";
cin.getline(sp1.spoud_Name,40);
cout<<" Dose 2 Vathmous ";
cin>>sp1.spoud_vathmos[0]>>sp1.spoud_vathmos[1];
cout<<endl<< " Stoixeia spoudasti"<<endl;;

cout<<sp1.spoud_Name<<" "<<sp1.spoud_vathmos[0]
<<" "<<sp1.spoud_vathmos[1]<<endl;
}

Άσκηση 9.4
#include <iostream>
int main()
{
struct ypallilos
{
char* eponimo;
int age;
double salary;
} ;
struct ypallilos epix[2]={ //H lexi struct epanalamvanetai

{ "Papadopoulos", 28,1200},
{ "Pappas", 40,1300},
};
}

Άσκηση 9.5
Να εκτελεστεί το παρακάτω πρόγραμμα. Το παρακάτω πρόγραμμα υπολογίζει την διαγώνιο
ορθογωνίου όταν αυτό ορίζεται από τις συντεταγμένες των δύο γωνιών του.
#include <iostream>
#include <math.h>
struct point {
int x;
int y;
};
struct rectangle {
struct point panoAris;
struct point katoDexia;
} ;
int main()
{
struct rectangle rect1;
rect1.panoAris.x=-2; rect1.panoAris.y=3;
rect1.katoDexia.x=8; rect1.katoDexia.y=-1;
double d1= (rect1.panoAris.x-rect1.katoDexia.x);

double d2= (rect1.panoAris.y-rect1.katoDexia.y);
double diag=sqrt(pow(d1,2)+pow(d2,2));
cout<<"diagonios"<<diag<<endl;
}

Άσκηση 9.6
#include <iostream>
struct dstudent
{
char lastName[40];
int testScore;
int programmingScore;
double mesos;
};
void inStoixeia(dstudent& fstud)

{
int score;
fstud.mesos = (fstud.testScore + fstud.programmingScore) / 2.0;
}
{
cout << fstud.lastName << " " << fstud.testScore
}
int main()
{
dstudent stud1,stud2;
inStoixeia(stud1); inStoixeia(stud2);
}

Στο παραπάνω πρόγραμμα να οριστεί να γίνει χρήση πίνακα δομών. Ο πίνακας να περιέχει 5
στοιχεία (δομές). Να γραφούν οι κατάλληλες συναρτήσεις εισόδου και εξόδου για την περίπτωση
αυτή

Άσκηση 9.7
Η άσκηση αυτή είναι το ίδιο πρόγραμμα της προηγούμενης άσκησης όμως τώρα ορίζεται
συνάρτηση που επιστρέφει δομή.
#include <iostream>
struct dstudent
{
char lastName[40];
int testScore;
int programmingScore;
double mesos;
};
//sinartisi pou epistrefei domi
dstudent ReadStoixeia ( )
{
dstudent fstud;
fstud.mesos = (fstud.testScore + fstud.programmingScore) / 2.0;
return fstud;
}
{
cout << fstud.lastName << " " << fstud.testScore
}
int main()
{
dstudent stud1,stud2;
stud1= ReadStoixeia ( ); stud2= ReadStoixeia ( );
}

Να γραφεί πρόγραμμα με το οποίο να ορίζεται δομή που αφορά μία μέτρηση απόστασης σε
χιλιόμετρα μέτρα και εκατοστά. Ο χρήστης εισάγει αποστάσεις με χρήση καταλλήλων μηνυμάτων
και η εισαγωγή σταματά όταν πληκτρολογήσει το Ν στην ερώτηση “Θέλεις να συνεχίσεις την
εισαγωγής Yes/No”. Κατόπιν γίνεται χρήση συνάρτησης που προσθέτει τις αποστάσεις που είναι
συμμιγείς αριθμοί και εμφανίζει το αποτέλεσμα κάνοντας πρόσθεση συμμιγών αριθμών. ( πχ Η
εισαγωγή δύο αποστάσεων με τιμές 5 km 800 m 80 cm και 2 km 300 m 30 cm θα πρέπει να δόσει
σαν αποτέλεσμα το 9 km 101 m 10 cm

Η παραπάνω άσκηση να κάνει χρήση συνάρτησης για να προσθέτει δύο αποστάσεις και κατόπιν
με κατάλληλη χρήση της συνάρτησης να υπολογίζεται το άθροισμα των αποστάσεων που θα
δώσει ο χρήστης.

Κλάσεις
Άσκηση 10.1
Να οριστεί μία κλάση που αφορά ορθογώνια και περιλαμβάνει συναρτήσεις μέλη TimesPlevron με
την οποία εισάγονται δύο τιμές που αφορούν τις δυο πλευρές ενός ορθογωνίου και την συνάρτηση
Emvado με την οποία υπολογίζεται το εμβαδό του ορθογωνίου
#include <cstdlib>
#include <iostream>
// classes example
class KOrthogonio {
int x, y;
public:
void TimesPlevron(int,int);
int Emvado () ;
};
void KOrthogonio::TimesPlevron (int a, int b) {

x = a;
y = b;
}
int KOrthogonio::Emvado() {
return (x*y);
}
int main () {
KOrthogonio rect;
rect.TimesPlevron (10,20);
cout << "To emvado = " << rect .Emvado()<<endl ;
system("PAUSE");
}
Άσκηση 10.2 Άσκηση χωρίς κώδικα

Στην ανωτέρω άσκηση να οριστούν 3 ορθογώνια και να ευρεθούν τα εμβαδά τους

Στην ανωτέρω άσκηση να οριστεί μέθοδος με όνομα Κdeixe. Η μέθοδος αυτή να χρησιμοποιείται
στο main ώστε να υπάρχει δυνατότητα εμφάνισης των διαστάσεων των δύο πλευρών ενός
αντικειμένου.

Άσκηση 10.3
Nα ορισθεί μία κλάση που αφορά τηλεόραση και περιλαμβάνει τις παρακάτω συναρτήσεις μέλη
1) SetKanali που να βάζει ένα κανάλι στην τηλεόραση και
2) GetKanali εμφανίζει το κανάλι.
Οι συναρτήσεις να εφαρμόζονται σε ένα αντικείμενο της κλάσης.
#include <cstdlib>
#include <iostream>
class TV
{
int m_Kanali;
public:
void SetKanali(int Kanali) {
m_Kanali=Kanali;
};
int GetKanali(){
cout<<m_Kanali<<endl;
};
};

{
TV myTV;
myTV.SetKanali(10);
myTV.GetKanali();
system("PAUSE");
}

Άσκηση 10.4
Nα ορισθεί μία κλάση που αφορά σπουδαστές. Κάθε αντικείμενο που ανήκει στην κλάση έχει σαν
δεδομένα τον κωδικό του σπουδαστή τον βαθμό του στα εργαστήρια και τον βαθμό του στην
θεωρία. Η κλάση περιλαμβάνει τις παρακάτω συναρτήσεις μέλη
1) SetData που να θέτει τιμές σε ένα σπουδαστή
2) Mesos που υπολογίζει και επιστρέφει τον μέσο όρο των δύο βαθμών.
3) Kodikos που εμφανίζει τον κωδικό σπουδαστή
4) Vathmoi που εμφανίζει του βαθμούς και τον μέσο όρο
Οι συναρτήσεις να εφαρμοστούν σε ένα αντικείμενο που ορίζεται στο main και που ανήκει στην
κλάση.
#include <cstdlib>
#include <iostream>
class Spoudastis {
int m_kod;
float m_the,m_erga;
public:
void SetData(int kod, float theo, float erga){
m_kod = kod; m_the = theo;m_erga=erga;}
float Mesos(){
float m=(m_the+m_erga)/2;
return (m);}
int Kodikos(){
return (m_kod);}
void Vathmoi(){
cout<<" "<<m_the<<" "<<m_erga<<" "<<endl; }
};

{
int k; float t,e;
cout<< "Dose kodiko kai vathmous \n";
cin>>k>>t>>e;
Spoudastis Spoud1;
Spoud1.SetData(k,t,e);
cout<<"\n\n\nKodikos MesosOros Theoria Ergastirio \n";
cout<< Spoud1.Kodikos()<<" " ;
cout<< Spoud1.Mesos() ;
Spoud1.Vathmoi();
system("PAUSE");
}
Στην ανωτέρω άσκηση να οριστεί και συνάρτηση μέλος της κλάσης που να εμφανίζει το κατάλληλο
μήνυμα εάν ο σπουδαστής
πέρασε θεωρία
πέρασε εργαστήριο
πέρασε το μάθημα
κόπηκε και στα δύο
ανάλογα με τους βαθμούς που πήρε

Άσκηση 10.5
Το πρόγραμμα αυτό είναι επανάληψη της άσκησης 8.1 . Όμως, τώρα, έχουμε αφαιρέσει την
συνάρτηση TimesPlevron (), και έχουμε συμπεριλάβει ένα constructor (κατασκευαστή) που
εκτελεί μια παρόμοια λειτουργία δηλαδή αποδίδει τιμές (αρχικοποιεί) στις μεταβλητές x y κάνοντας
χρήση των παραμέτρων που υπάρχουν στην συνάρτηση constructor.
#include <cstdlib>
#include <iostream>

class KOrthogonio {
int x, y;
public:
KOrthogonio(int , int );
int Emvado ();
};
KOrthogonio::KOrthogonio(int a, int b){

x = a;
y = b;}
int KOrthogonio::Emvado (){

return (x*y);
}
int main () {
KOrthogonio rect1 (10,20);
system("PAUSE");
}
#include <cstdlib>
#include <iostream>
class KOrthogonio {
int x, y;
public:
KOrthogonio(int a, int b){ x = a; y = b;}
};

Άσκηση 10.6
Να γραφεί πρόγραμμα που να υπολογίζει τον όγκο ενός δωματίου με χρήση κλάσης. Για τον λόγο
αυτό να οριστεί μία κλάση Kdomatia που να περιλαμβάνει τις κατάλληλες μεταβλητές μέλη και ένα
constructor με τον οποίο να εισάγονται τιμές στις διαστάσεις του δωματίου. Επίσης η κλάση να
περιλαμβάνει μέθοδο Ogos που να υπολογίζει τον όγκο του δωματίου. Αφού υπολογιστεί ο όγκος
ενός αρχικού δωματίου να υπολογίζεται και ο όγκος ενός δωματίου που έχει τις διπλάσιες
διαστάσεις από το αρχικό.
#include <cstdlib>
#include <iostream>
class Kdomatia // Class definition at global scope

{
public:
double m_Length; // Length of a box
double m_Width; // Width of a box
double m_Height; // Height of a box
// Function to calculate the volume of a box
Kdomatia (double l,double w, double h){
m_Length=l;
m_Width=w;
m_Height=h;
}
// Kdomatia (){}
double Ogos(){
return m_Length*m_Width*m_Height;
}
};

{
Kdomatia dom1 (10.0,20.0,10.0); // Declare dom2 of type Kdomatia

Kdomatia dom2 (0,0,0); // Declare dom2 of type Kdomatia
dom2.m_Height = 2*dom1.m_Height ; // Define dom2

dom2.m_Length = 2*dom1.m_Length; // members in
dom2.m_Width = 2*dom1.m_Length; // terms of dom2
cout << endl << "Ogos tou dom1 = " << dom1.Ogos();
cout << endl << "Ogos tou dom2 = " << dom2.Ogos();
cout <<"\nTo antikeimeno dom2 katalamvanei " << sizeof(dom2) << "
bytes.";
cout << endl;
system("PAUSE");
}

Στο ανωτέρω πρόγραμμα να μετατραπεί η πρόσβαση στις μεταβλητές που αφορούν τις διαστάσεις
του δωματίου από public σε private και να ξαναγραφεί το main ώστε να υπολογίζεται το εμβαδό
ενός δωματίου με διπλάσιες διαστάσεις από το αρχικό.

Εισαγωγή Στον Προγραμματισμό Με c++ Κωνσταντίνος Κουκουλέτσος Τει Πειραιά

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Εισαγωγή Στον Προγραμματισμό Με c++ Κωνσταντίνος Κουκουλέτσος Τει Πειραιά

Uploaded by

Copyright:

Available Formats

ΕΛΛΗΝΙΚΗ ΔΗΜΟΚΡΑΤΙΑ

Ανώτατο Εκπαιδευτικό Ίδρυμα Πειραιά

Εισαγωγή στον Προγραμματισμό

Συνάρτηση main Αρχίζει με {

Τελεστής εισαγωγής (insertion) του ρεύματος ροής

Επεξήγηση προγράμματος (2)

Σχόλιο πολλών γραμμών

Λέξη κλειδί που προκαλεί

Χαρακτήρας διαφυγής Χαρακτήρας διαφυγής

Τα δύο προγράμματα είναι το ίδιο

Δήλωση ακεραίων μεταβλητών

Χρήση τελεστή εξαγωγής (extraction) του

Αλφάβητο της C++

- Μικρά a, b, c, …, z και κεφαλαία A, B, C, …, Z

- Κενό διάστημα (white space) πού είναι οι χαρακτήρες κενό

 Υπάρχει διαφορά μεταξύ κεφαλαίων και μικρών

= Τελεστής απόδοσης τιμής

Όμως 7/3. είναι 2.5

Στην C++ η τιμή false εκφράζεται και απεικονίζεται

Σχεσιακοί και Λογικοί Τελεστές-

Πρόταση if..else (2)

Προσοχή στις εσοχές ο τρόπος στοίχισης διευκολύνει

Πολλαπλά if..else (nested if)

Αντιστοίχιση else με If (2)

Παράδειγμα χρήσης εντολής switch

break προκαλεί το τέλος της switch και

Προσοχή στις δύο case. Εδώ τα δύο

Να γραφεί η παρακάτω εντολή if

Ισοδυναμία if..else με εντολή switch (2)

Να γραφεί η παρακάτω εντολή if

for (εντολή1; συνθήκη επανάληψης; εντολή2)

Εντολή while-Περιπτώσεις-λάθη (1)

Στη περίπτωση αυτή η επανάληψη και εκτύπωσε δεν σταματά

Στην πρώτη δεν εμφανίζεται τίποτε.

Στην δεύτερη εμφανίζεται μία

Στην τρίτη τι γίνεται;

Ο χρήστης βλέπει μήνυμα σε κάθε περίπτωση

Παραδείγματα εφαρμογής do..while (2)

Εναλλακτικά μπορεί να χρησιμοποιηθεί το while και ο χρήστης να

Στην while πρέπει να μπορεί να υπολογίζεται η συνθήκη με την

Εύρεση πλήθους, αθροίσματος και

break και continue (2)

Εισαγωγή και εμφάνιση στοιχείων (2)

 Προσοχή στην ομαδοποίηση

 Αναπαράσταση πίνακα δύο διαστάσεων

Άσκηση 1: Εμφάνιση μεγαλύτερου

Άσκηση 2: Εμφάνιση βαθμολογίας

Τυχαίοι αριθμοί-Ψευδοτυχαίοι (1)

 Η συνάρτηση rand() επιστρέφει ένα ακέραιο

Τυχαίοι αριθμοί-Ψευδοτυχαίοι (3)

Διευθύνσεις και μνήμη

int *dik =NULL;

 Όμως προσθέτοντας ή αφαιρώντας από ένα δείκτη προστίθεται ή

 Πχ. αν ο τύπος του δείκτη είναι ακέραιος προστίθενται 4 bytes στην

2. Όταν ο compiler συναντά a[n] το μετατρέπει σε *(a+n).

Δήλωση δείκτη πίνακα

for (int i=0;i<4,i++)

 Ο δείκτης στην περίπτωση αυτή είναι ένας constant pointer.

Συναρτήσεις της C++

 Η παρακάτω συνάρτηση βρίσκει το άθροισμα δύο ακεραίων αριθμών

Συναρτήσεις που ορίζονται από το

 Το όνομα της συνάρτησης

Κλήση δια τιμής και κλήση με

Παράδειγμα (χρήση παραμέτρων αναφοράς)