Υπολογιστεσ Ιi Προγραμματισμός Με Τη Γλώσσα c++ ε. Λοιδωρίκης, δ. Παπαγεωργίου Πανεπιστήμιο Ιωαννίνων

ΥΠΟΛΟΓΙΣΤΕΣ ΙI
Προγραμματισμός με τη γλώσσα C++
Ε. Λοιδωρίκης, Δ. Παπαγεωργίου
Πανεπιστήμιο Ιωαννίνων
Ένα πρώτο πρόγραμμα
ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

Κατασκευάστε
Κατασκευάστε πρόγραμμα
πρόγραμμα που
που θα
θα
ΔΟΜΗ εμφανίζει στην οθόνη τη λέξη:
εμφανίζει στην οθόνη τη λέξη:
ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ
TOY HELLO
HELLO
ΠΡΟΓΡΑΜΜΑΤΟΣ
1 2
Ένα πρώτο πρόγραμμα Πως γράφεται το πρόγραμμα


Τα προγράμματα C++ γράφονται με "ελεύθερο" τρόπο.
#include <iostream>
Κάθε εντολή μπορεί να γραφεί σε μια ή περισσότερες
using namespace std; γραμμές. Πχ.
int main ( ) cout <<

{ "HELLO \n";
cout << "HELLO \n";
return 0; Σε μια γραμμή μπορούν να γραφούν παραπάνω από
} μια εντολές. Πχ.
int main ( ) { cout << "HELLO \n"; return 0; }
3 4
Πως γράφεται το πρόγραμμα Σχόλια

• Έχει επικρατήσει ένας συγκεκριμένος τρόπος Στη C++ υπάρχουν δύο τύποι σχολίων:
γραφής, έτσι ώστε τα προγράμματα να είναι
ευανάγνωστα. Σχόλια πολλαπλών γραμμών
9 Γράφουμε μία εντολή ανά γραμμή.
9 Κάθε τμήμα εντολών που περικλείεται από Οτιδήποτε περικλείεται μεταξύ /* και */ θεωρείται
άγκιστρα γράφεται πιο δεξιά (πατώντας tab). σχόλιο.
• Στο τέλος κάθε εντολής βάζουμε ερωτηματικό (όχι Παράδειγμα:

στο τέλος κάθε γραμμής).
/* Το πρόγραμμα αυτό
• Προσοχή: Κεφαλαία – μικρά θεωρούνται εμφανίζει στην οθόνη
διαφορετικά. τη λέξη HELLO */
Έτσι γράφουμε: main και όχι ΜΑΙΝ
cout και όχι COUT int main ( ) /* Η επικεφαλίδα του προγράμματος */
5 6
Σχόλια Το κυρίως πρόγραμμα


Σχόλια μιας γραμμής Το κυρίως πρόγραμμα έχει τη μορφή:
Ξεκινάνε με τους χαρακτήρες // και εκτείνονται int main ( )

μέχρι το τέλος της γραμμής. {
… εντολές …
Παράδειγμα: return 0;
// Το πρόγραμμα αυτό }
// εμφανίζει στην οθόνη
Το κυρίως πρόγραμμα έχει ένα προκαθορισμένο
// τη λέξη HELLO
όνομα (main) που δεν μπορεί να αλλάξει.
int main ( ) // Η επικεφαλίδα του προγράμματος
Οι εντολές του προγράμματος γράφονται μέσα σε
ένα ζευγάρι από άγκιστρα { } μετά την
επικεφαλίδα του προγράμματος.
7 8
Το κυρίως πρόγραμμα Η εντολή cout

• Κάθε πρόγραμμα σε C++ αφού ενεργοποιηθεί από το
λειτουργικό σύστημα, εκτελεί τις εντολές του και στο τέλος Με την εντολή cout εμφανίζουμε στην οθόνη ένα μήνυμα.
επιστρέφει στο λειτουργικό σύστημα ένα ακέραιο αριθμό που Το μήνυμα πρέπει να βρίσκεται μέσα σε διπλές αποστρόφους.
δηλώνει αν το πρόγραμμα διεκπεραίωσε επιτυχώς την εργασία Η εντολή cout δεν αλλάζει γραμμή.
του.
Αν γράψουμε:
• Το σύμβολο int στην επικεφαλίδα τη προγράμματος δηλώνει
ότι ο επιστρεφόμενος αριθμός είναι ακέραιος. cout << "HELLO ";
• Κατά σύμβαση ο αριθμός 0 σημαίνει ότι το πρόγραμμα
cout << "WORLD";
λειτούργησε επιτυχώς.
θα εμφανιστεί:
• Η τιμή επιστρέφεται με την εντολή return η οποία μπορεί να
παραληφθεί. Σε αυτή την περίπτωση εννοείται return 0 HELLO WORLD
• Στην πραγματικότητα ένα πρόγραμμα C++ είναι ένα

υποπρόγραμμα που καλείται από το λειτουργικό σύστημα.
9 10
Η εντολή cout Συγγραφή του προγράμματος


Για να αλλάξουμε γραμμή χρησιμοποιούμε το σύμβολο \n Για να γράψουμε το πρόγραμμα χρησιμοποιούμε
(ονομάζεται χαρακτήρας διαφυγής). ένα κειμενογράφο (Text Editor).
Αν γράψουμε: Αποθηκεύουμε το αρχείο δίνοντας ένα όνομα με

την κατάληξη .c
cout << "HELLO \n";
cout << "WORLD"; Πχ. prog.c
lab1.c
θα εμφανιστεί:
HELLO
WORLD
11 12
Μετάφραση του Μετάφραση του

προγράμματος προγράμματος
Για να μεταφράσουμε το πρόγραμμα και να Στην πραγματικότητα η εντολή c++ prog.c
δημιουργήσουμε το εκτελέσιμο χρησιμοποιούμε την πραγματοποιεί δύο λειτουργίες:
εντολή: c++ prog.c
c++ prog.c
Πηγαίος κώδικας Εκτελέσιμος κώδικας

c++ prog.c
prog.c a.out Προεπεξεργασία Μετάφραση
13 14
Μετάφραση του
Οι υπόλοιπες εντολές

προγράμματος
• Οι γραμμές του προγράμματος που ξεκινάνε με το σύμβολο
# ονομάζονται οδηγίες προεπεξεργαστή. using namespace std;
• Ο προεπεξεργαστής διαβάζει τον πηγαίο κώδικα και ενεργεί Σημαίνει να χρησιμοποιηθεί ο προκαθορισμένος
κατάλληλα όπου βρεί οδηγίες. "χώρος ονομάτων" της C++.
• Η γραμμή
#include <iostream> Ο χώρος ονομάτων είναι μια συλλογή από μεταβλητές,
αποτελεί οδηγία για τον προεπεξεργαστή που λέει να συναρτήσεις και άλλες οντότητες που χρησιμοποιούνται
συμπεριλάβει στο σημείο εκείνο τα περιεχόμενα του στο πρόγραμμα.
αρχείου iostream (περιέχει διάφορες δηλώσεις σχετικές με
τις εντολές εισόδου-εξόδου).
Αργότερα θα δούμε και την οδηγία #define
• Στη συνέχεια το προεπεξεργασμένο πρόγραμμα παραδίδεται

στο μεταφραστή για συντακτικό έλεγχο και παραγωγή του
εκτελέσιμου.
15 16
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ
Τύποι δεδομένων
Η γλώσσα προγραμματισμού C++ υποστηρίζει

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ,
τους παρακάτω τύπους δεδομένων:

ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ
1) Ακέραιοι αριθμοί (int).
ΠΡΑΞΕΙΣ
2) Πραγματικοί αριθμοί διπλής ακρίβειας
ΜΕΤΑΒΛΗΤΕΣ (double).
3) Πραγματικοί αριθμοί απλής ακρίβειας (float).
4) Χαρακτήρες (char).
1 2

Ακέραιοι αριθμοί (int) Πράξεις μεταξύ ακεραίων αριθμών
Μεταξύ δύο ακεραίων αριθμών μπορούν να γίνουν

• Πρόκειται για αριθμούς χωρίς δεκαδικά ψηφία. οι παρακάτω πράξεις χρησιμοποιώντας τον
αντίστοιχο τελεστή:
• Για την αναπαράσταση των ακέραιων αριθμών + Πρόσθεση
χρησιμοποιούνται 4 bytes μνήμης. - Αφαίρεση
* Πολλαπλασιασμός
• Λαμβάνουν τιμές στην περιοχή -2147483648 έως / Διαίρεση
2147483647. % Υπόλοιπο διαίρεσης
Το αποτέλεσμα μιας πράξης μεταξύ ακεραίων

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

3 4

Ακέραια διαίρεση Παράδειγμα #1
Η διαίρεση δύο ακεραίων αριθμών δίνει ως
αποτέλεσμα επίσης ένα ακέραιο αριθμό. 3+5 Αποτέλεσμα: 8
Κατά τη διαίρεση δύο ακεραίων αριθμών τυχόν 4-8 Αποτέλεσμα: -4
δεκαδικά ψηφία που προκύπτουν κατά τη
6*2 Αποτέλεσμα: 12
διαίρεση αποκόπτονται.
8/3 Αποτέλεσμα: 2
Παραδείγματα: 7%3 Αποτέλεσμα: 1
9/2 Αποτέλεσμα: 4 (όχι 4.5)
1/3 Αποτέλεσμα: 0 (όχι 0.33333…) 12%5 Αποτέλεσμα: 2
2/3 Αποτέλεσμα: 0 (όχι 0.66666…)
-6/4 Αποτέλεσμα: -1 (όχι –1.5)
Η λειτουργία αυτή ονομάζεται ακέραια διαίρεση.

5 6

Σύνθετες αριθμητικές παραστάσεις Κανόνες υπολογισμού σύνθετων παραστάσεων
Για να υπολογιστούν πιο σύνθετες αριθμητικές Σε μια σύνθετη αριθμητική παράσταση:

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

* / % Υψηλή Από αριστερά προς δεξιά οι πράξεις εντός του πιο εσωτερικού ζεύγους
+ - Χαμηλή Από αριστερά προς δεξιά παρενθέσεων.
7 8

Πραγματικοί αριθμοί διπλής Πραγματικοί αριθμοί: Επιστημονική
ακρίβειας (double) αναπαράσταση
• Πρόκειται για αριθμούς με δεκαδικά ψηφία
Αριθμός Επιστ. αναπαράσταση Σημαίνει
• Απαιτούνται 8 bytes για την αποθήκευσή τους. 32.76 3.276e1 3.276 x 101
-98541.34 -9.854134e4 -9.854134 x 104
• Έχουν περίπου 15 σημαντικά ψηφία. 0.000035 3.5e-5 3.5 x 10-5
• Λαμβάνουν τιμές στην περιοχή -10308…-10-308

10-308…10308
• Στη C++ οποιαδήποτε αριθμητική σταθερά με

δεκαδικά ψηφία θεωρείται πραγματικός αριθμός
διπλής ακρίβειας.
9 10

Πραγματικοί αριθμοί απλής
Παράδειγμα #2
ακρίβειας (float)
• Απαιτούνται 4 bytes για την αποθήκευσή τους.

3.14 Διπλής ακρίβειας (double)
• Έχουν περίπου 7 σημαντικά ψηφία. -1.2e4 Διπλής ακρίβειας (double)
67.51f Απλής ακρίβειας (float)
• Λαμβάνουν τιμές στην περιοχή -1038…-10-38
2.2e-3f Απλής ακρίβειας (float)
10-38…1038
• Για να ξεχωρίσουν από τους πραγματικούς

διπλής ακρίβειας γράφονται με το επίθεμα f
11 12

Πράξεις μεταξύ πραγματικών αριθμών Μικτή αριθμητική
Όταν σε μια πράξη συμμετέχουν αριθμοί από δύο
Μεταξύ πραγματικών αριθμών γίνονται οι πράξεις: διαφορετικούς τύπους δεδομένων, τότε:
+ - * / τα δεδομένα προάγονται αυτόματα στον
ανώτερο από τους δύο τύπους
Η διαίρεση γίνεται κατά το συνήθη τρόπο, δηλαδή και κατά συνέπεια το αποτέλεσμα θα είναι του
αν προκύψουν δεκαδικά ψηφία, αυτά παραμένουν ανώτερου τύπου.
στον αριθμό.
Οι τύποι δεδομένων ιεραρχούνται ως εξής:
Σημείωση: Κάποιοι μεταφραστές επιτρέπουν και το
υπόλοιπο διαίρεσης % ως πράξη, χωρίς αυτό όμως double Ανώτερος
να περιλαμβάνεται στο πρότυπο της γλώσσας. float
int Κατώτερος
13 14

Συναρτήσεις Συναρτήσεις
Για να υπολογίσουμε Γράφουμε
Η γλώσσα προγραμματισμού C++ περιέχει μια
σειρά από ενσωματωμένες μαθηματικές Τετραγωνική ρίζα sqrt(x)
συναρτήσεις. ex Εκθετικό exp(x)
|x| Απόλυτη τιμή abs(x)
Για να χρησιμοποιήσουμε οποιαδήποτε lnx Νεπέρειος λογάριθμος log(x)
μαθηματική συνάρτηση πρέπει να προσθέσουμε
στην αρχή του προγράμματος: logx Λογάριθμος με βάση 10 log10(x)
sinx Ημίτονο sin(x)
#include <cmath> cosx Συνημίτονο cos(x)
tanx Εφαπτομένη tan(x)
sin-1x Τόξο ημιτόνου asin(x)
cos-1x Τόξο συνημιτόνου acos(x)
15
tan-1x Τόξο εφαπτομένης atan(x)
16

Συναρτήσεις Οι αριθμοί π, e
Όλες οι συναρτήσεις δέχονται ως όρισμα αριθμούς Για να υπολογίσουμε τον αριθμό π γράφουμε:
float ή double και επιστρέφουν αποτέλεσμα του
αντίστοιχου τύπου. Πχ. acos(-1.0)
sin(1.0) Σωστό Για να υπολογίσουμε τον αριθμό e (βάση των

sin(1) Λάθος φυσικών λογαρίθμων) γράφουμε:
Οι τριγωνομετρικές συναρτήσεις δέχονται το όρισμα exp(1.0)

σε ακτίνια, όχι μοίρες.
Οι αντίστροφες τριγωνομετρικές συναρτήσεις

επιστρέφουν αποτέλεσμα σε ακτίνια, όχι μοίρες.
17 18

Ύψωση σε δύναμη Παράδειγμα #3
Η ύψωση σε δύναμη ab γίνεται με τη συνάρτηση
Όγκος σφαίρας με ακτίνα r:
pow(a,b)
Η βάση (a) και ο εκθέτης (b) μπορεί να είναι: 4*acos(-1.0)*pow(r,3)/3
Τύπος βάσης Τύπος εκθέτη Τύπος αποτελέσματος

float float float
double double double
Απόσταση μεταξύ των σημείων (x1,y1) και (x2,y2):
float int float
double int double
Προσοχή: Η βάση δεν μπορεί να είναι ακέραιος sqrt( pow(x1-x2,2)+pow(y1-y2,2) )

αριθμός.
Πχ. pow(4,2) είναι ΛΑΘΟΣ
19 20

Χαρακτήρες (char) Χαρακτήρες διαφυγής
• Καταλαμβάνουν 1 byte μνήμης.
• Υπάρχουν 256 διαφορετικοί χαρακτήρες. Χαρακτήρας Τι σημαίνει
• Ορισμένοι χαρακτήρες δεν εμφανίζονται στην \n Αλλαγή γραμμής (new line)
οθόνη (πχ. esc, backspace) \b Μία θέση πίσω (backspace)
• Κάθε χαρακτήρας αντιστοιχεί σε ένα ακέραιο \f Αλλαγή σελίδας (form feed)
αριθμό.
\r Αρχή γραμμής (carriage return)
• Οι χαρακτήρες a..z, Α…Ζ και 0..9 βρίσκονται στη
\t Στηλοθέτης (tab)
σειρά, δηλαδή αντιστοιχούν σε διαδοχικούς
ακέραιους αριθμούς. \\ Ο χαρακτήρας \
• Γράφονται μέσα σε απλές αποστρόφους. Πχ. \' Απλή απόστροφος
'a' '8' 'Ε' \" Διπλή απόστροφος
• Ορισμένοι ειδικοί χαρακτήρες γράφονται \0 Χαρακτήρας που αντιστοιχεί στον ακέραιο 0
χρησιμοποιώντας το σύμβολο \ και ονομάζονται
χαρακτήρες διαφυγής. Πχ. '\n' 21 22

Μεταβλητές Κανόνες ονομάτων
Οι μεταβλητές είναι συμβολικά ονόματα που • Επιτρέπονται μόνο λατινικοί χαρακτήρες,

δίνουμε σε θέσεις μνήμης όπου αποθηκεύονται αριθμοί και το σύμβολο _
αριθμοί (ή άλλοι τύποι δεδομένων). • Ο πρώτος χαρακτήρας πρέπει να είναι γράμμα.
• Κεφαλαία και μικρά θεωρούνται διαφορετικά.
Κάθε μεταβλητή έχει όνομα και τύπο, που
• Δεν υπάρχει μέγιστο μήκος στο όνομα, όμως
δηλώνονται υποχρεωτικά στην αρχή του πρακτικά κάθε μεταφραστής επιβάλλει ένα
προγράμματος. μέγιστο μήκος (πχ 32 χαρακτήρες).
Οι ίδιοι κανόνες ισχύουν και για άλλα ονόματα, πχ.

ονόματα υποπρογραμμάτων.
23 24

Δηλώσεις μεταβλητών Ανάθεση τιμών
Για να δώσουμε τιμή σε μια μεταβλητή
Οι μεταβλητές δηλώνονται στην αρχή κάθε
προγράμματος: χρησιμοποιούμε τον τελεστή ανάθεσης τιμής =
Μεταβλητή = Αριθμητική παράσταση

#include <iostream>
using namespace std;
Αριστερά του = είναι πάντα μια μεταβλητή
int main ( ) Δεξιά του = είναι πάντα μια αριθμητική παράσταση
{
int k, m; Παραδείγματα:
float a;
double x, y, z; r = 5.
d = b*b-4*a*c
… εντολές … area = acos(-1.0)*r*r
}
x1 = (-b+sqrt(d))/(2*a)
25 26

Ανάθεση τιμών στη δήλωση Τελεστές αύξησης και μείωσης
Μπορούμε να δώσουμε αρχική τιμή σε μια Για την ειδική περίπτωση της πράξης μεταξύ
μεταβλητή μέσω της δήλωσής της. Πχ. ακεραίων:
#include <iostream> k = k+1;

η C++ έχει ένα ειδικό τελεστή. Μπορούμε να
int main ( )
{
γράψουμε:
int k=0;
double x=1.45; ++k; (προθεματική μορφή)
ή
… εντολές … k++; (επιθεματική μορφή)
}
Στα δεξιά του = πρέπει να είναι μια σταθερή τιμή.

27 28

Τελεστές αύξησης και μείωσης Τελεστές αύξησης και μείωσης
Στην προθεματική μορφή: • Αντίστοιχα με τον τελεστή αύξησης ++ υπάρχει
Πρώτα αυξάνεται η τιμή της μεταβλητής και ο τελεστής μείωσης -- σε προθεματική και
κατόπιν η τιμή χρησιμοποιείται. επιθεματική μορφή.
Στην επιθεματική μορφή: • Οι τελεστές ++ και -- χρησιμοποιούνται μόνο σε

Πρώτα χρησιμοποιείται η τιμή της μεταβλητής ακέραιους αριθμούς.
και κατόπιν η τιμή της μεταβλητής αυξάνεται.
• Εντός μιας αριθμητικής παράστασης οι τελεστές
Παράδειγμα:
++ και -- έχουν υψηλότερη προτεραιότητα από
k = 5; k = 5; τους τελεστές + - * / %
a = ++k; a = k++;
• Η προσεταιριστικότητα των τελεστών ++ και --
Η k γίνεται 6 Η k γίνεται 6 είναι από δεξιά προς τα αριστερά.
Η a γίνεται 6 Η a γίνεται 5
29 30

Παράδειγμα #4 Παράδειγμα #5
Ποια
Ποια είναι
είναι ηη τιμή
τιμή των
των μεταβλητών
μεταβλητών n,
n, jj Ποια
Ποια είναι
τιμή των
των μεταβλητών
μεταβλητών m,
m, kk
μετά
μετά από
από τις
τις εντολές:
εντολές: μετά
μετά από
από τις
τις εντολές:
εντολές:
nn == 10;
10; mm == 4;
4;
jj == ++n
++n %% 4;
4; kk == 2+
2+ m++;
m++;
Η n γίνεται 11 Η m γίνεται 5
Η j γίνεται 3 Η k γίνεται 6
31 32

Άλλοι τελεστές ανάθεσης τιμής Προτεραιότητες
Η ανάθεση τιμής: k = k+m
Τελεστής Προτεραιότητα Προσεταιριστικότητα
μπορεί να γραφεί στη C++ ως: k += m
++ -- Υψηλή Από δεξιά προς αριστερά
Όμοια υπάρχουν και οι τελεστές: * / % Από αριστερά προς δεξιά
+ - Από αριστερά προς δεξιά
= += -= *= /= %= Χαμηλή Από δεξιά προς αριστερά
Τελεστής Σημαίνει
k -= m k = k-m
k *= m k = k*m
k /= m k = k/m
k %= m k = k%m (μόνο για ακεραίους)
33 34

Είσοδος - έξοδος μεταβλητών Είσοδος - έξοδος μεταβλητών
Οι τιμές των μεταβλητών μπορούν να εμφανιστούν στην Εάν θέλουμε να αλλάξουμε γραμμή θα πρέπει να
οθόνη με την εντολή cout. Πχ. χρησιμοποιήσουμε το χαρακτήρα διαφυγής \n
cout << x ; cout << x << '\n';
Μηνύματα και μεταβλητές μπορεί να εμφανιστούν από Ο χαρακτήρας '\n' έχει το ειδικό όνομα endl που
την ίδια εντολή cout: μπορούμε να χρησιμοποιήσουμε:
cout << "Η τιμή είναι: " << x; cout << x << endl;
Εάν θέλουμε να εμφανίσουμε δύο μεταβλητές στην ίδια

γραμμή θα πρέπει να αφήσουμε κενό ανάμεσα τους:
cout << x << " " << y << endl;
35 36

Είσοδος - έξοδος μεταβλητών Παράδειγμα #6
Για να εισάγουμε μεταβλητές από το πληκτρολόγιο
πρόγραμμα τοτο οποίο
οποίο θαθα
χρησιμοποιούμε την εντολή cin:
υπολογίζει
υπολογίζει τη συνολική επιφάνεια και τον όγκο
τη συνολική επιφάνεια και τον όγκο
cin >> x; κυλίνδρου
κυλίνδρου όταν δίνεται η ακτίνα βάσης r και το
όταν δίνεται η ακτίνα βάσης r και το
ύψος
ύψος h.
h.
ή για περισσότερες μεταβλητές:
cin >> x >> y >> z;

Υπενθύμιση:
Η εντολή cin χρησιμοποιείται συνήθως μαζί με μια Επιφάνεια:

εντολή cout:
Όγκος:
cout << "Εισάγετε τις συντεταγμένες ";
cin >> x >> y >> z;
37 38

#include <iostream>
#include <cmath>
πρόγραμμα τοτο οποίο
οποίο θα
θα
int main ( )
{ μετατρέπει ένα δεδομένο αριθμό
μετατρέπει ένα δεδομένο αριθμό
double r, h;
double pi; δευτερολέπτων
δευτερολέπτων σεσε ώρες,
ώρες, λεπτά
λεπτά και
και
double e, v; δευτερόλεπτα.
δευτερόλεπτα.
cout << "Εισάγετε ακτίνα και ύψος ";
cin >> r >> h;
pi = acos(-1.0);
e = 2*pi*r*h + 2*pi*r*r;
v = pi*r*r*h;
cout << "Το εμβαδόν είναι " << e << endl;

cout << "Ο όγκος είναι " << v << endl;
} 39 40
#include <iostream>
int main ( )
{
int sec, min, hour, ypolsec, ypolmin;
cout << "Πόσα δευτερόλεπτα ? ";

cin >> sec;
min = sec / 60;

ypolsec = sec % 60;
hour = min / 60 ;
ypolmin = min % 60 ;
cout << sec << " δευτερόλεπτα είναι: " << endl;
cout << hour << " ώρες " << endl;
cout << ypolmin << " λεπτά " << endl;
cout << ypolsec << " δευτερόλεπτα " << endl;
} 41
Τι χρειάζεται η εντολή if ;
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΕΝΤΟΛΗ if
Η εντολή if επιτρέπει την επιλεκτική εκτέλεση
εντολών ελέγχοντας μια συνθήκη.
Εντολή if
1 2
#include <iostream>
που θα
θα βρίσκει
βρίσκει το
το int main ( )
μεγαλύτερο από δύο ακέραιους a, b που θα
μεγαλύτερο από δύο ακέραιους a, b που θα {
// Οι δύο αριθμοί
εισάγονται
εισάγονται από
από το
το πληκτρολόγιο.
πληκτρολόγιο.
int a, b;
int max; // Ο μεγαλύτερος
cout << "Εισάγετε δύο ακεραίους ";

cin >> a >> b;
if ( a > b )
max = a;
else
max = b;
cout << "Ο μεγαλύτερος είναι ο " << max << endl;
}
3 4
Συντακτικό της εντολής if 1/4 Τι συγκρίσεις μπορεί να γίνουν ;
Μεταξύ δύο μεταβλητών ή γενικότερα δύο παραστάσεων a και
if ( σύγκριση )
b μπορούν να γίνουν οι παρακάτω συγκρίσεις:
εντολή1 ;
else Σύγκριση Τι σημαίνει
εντολή2 ; a == b a=b
a != b a b
Παρατηρήσεις:
a > b a>b
• Οι εντολές γράφονται μερικά κενά (ή ένα tab) πιο δεξιά για
a < b a<b
ευκρίνεια.
• Δεν βάζουμε ερωτηματικό μετά τη σύγκριση ούτε μετά την a >= b a b
else.
• Το τμήμα else μπορεί να παραληφθεί οπότε η εντολή a <= b a b
γίνεται: Κάθε σύγκριση είναι είτε αληθής είτε ψευδής.
if ( σύγκριση ) Στη C++ το αληθές είναι ο ακέραιος 1 ενώ το ψευδές ο
εντολή ; ακέραιος 0
5 6
Πως λειτουργεί η εντολή if Συντακτικό της εντολής if 2/4

Πρώτα γίνεται η σύγκριση if ( σύγκριση ) {
Σε περίπτωση που θέλουμε
εντολή ;
Εάν η σύγκριση είναι αληθής να εκτελεστούν
if ( σύγκριση ) εντολή ;
εκτελείται η εντολή1 και το περισσότερες από μια
..
εντολή1 ; πρόγραμμα συνεχίζει μετά την . εντολές είτε όταν η
εντολή2. σύγκριση είναι αληθής είτε
else
} else { όταν είναι ψευδής,
εντολή2 ; χρησιμοποιούμε άγκιστρα για
εντολή ;
Εάν η σύγκριση είναι ψευδής να ομαδοποιήσουμε τις
εντολή ;
εκτελείται η εντολή2. εντολές.
..
.
}
7 8
Συντακτικό της εντολής if 3/4 Συντακτικό της εντολής if 4/4
Παράδειγμα: Δύο ένθετες εντολές if

Σημαντική παρατήρηση:
if ( σύγκριση1 )
Η εντολή if από το σημείο που αρχίζει μέχρι το if ( σύγκριση2 ) {
σημείο που τελειώνει (συμπεριλαμβανομένων και εντολή ;
όλων των εντολών που περιέχει) εντολή ;
..
θεωρείται συντακτικά ως μία εντολή. .
Μία εντολή } else { Μία εντολή
εντολή ;
Αυτό έχει σημασία στα σημεία όπου το συντακτικό εντολή ;
της γλώσσας απαιτεί μία εντολή. ..
.
}
9 10
#include <iostream>
πρόγραμμα πουπου θα
θα επιλύει
επιλύει την
την
int main ( )
εξίσωση πρώτου βαθμού
εξίσωση πρώτου βαθμού {
Ax+B=0
Ax+B=0 double a, b; // Οι συντελεστές
double x; // Η λύση
όταν
όταν δίνονται
δίνονται τα
τα ΑΑ και
και Β.
Β.
cout << "Εισάγετε τους συντελεστές \n";
cin >> a >> b;
Υπενθύμιση: Η λύση είναι αν
if ( a != 0 ) {
x = -b/a;
αλλιώς δεν υπάρχει λύση. cout << "Η λύση είναι " << x << endl;
} else
cout << "Δεν υπάρχει λύση \n";
}
11 12
θα βρίσκει
βρίσκει τις
τις #include <iostream>
#include <cmath>
πραγματικές
πραγματικές λύσεις
λύσεις (αν
(αν υπάρχουν)
υπάρχουν) της
της using namespace std;
δευτεροβάθμιας εξίσωσης
δευτεροβάθμιας εξίσωσης
int main ( )
Ax22 +
Ax + Bx
Bx + +CC==0 0 {
όταν
όταν δίνονται
δίνονται τα
τα Α,
Α, BB και
και C.
C. double a, b, c; // Οι συντελεστές
double d; // Η διακρίνουσα
Υπενθύμιση: double x1, x2; // Οι λύσεις
cout << "Εισάγετε τα a,b,c ";

• Αν Α=0 τότε έχουμε μια εξίσωση πρώτου βαθμού. cin >> a >> b >> c;
Συνεχίζεται…
• Οι λύσεις της δευτεροβάθμιας είναι:
13 14
…Συνέχεια …Συνέχεια
if ( a != 0 ) { // Eίναι εξίσωση 2ου βαθμού } else // Eίναι εξίσωση 1ου βαθμού
d = b*b-4*a*c; if ( b != 0 ) {
if ( d > 0 ) { x1 = -c/b;
x1 = (-b+sqrt(d))/(2*a); cout << "Υπάρχει μια λύση:\n";
x2 = (-b-sqrt(d))/(2*a); cout << x1 << endl;
cout << "Υπάρχουν δύο λύσεις:\n"; } else
cout << x1 << endl; cout << "Δεν υπάρχει λύση\n";
cout << x2 << endl; }
} else if ( d == 0 ) {
x1 = -b/(2*a);
cout << "Υπάρχει μία λύση:\n";
cout << x1 << endl;
} else
cout << "Δεν υπάρχουν λύσεις\n";
15 16
Σύνθετες λογικές παραστάσεις Πίνακες αλήθειας ( && )
Μπορούμε να κατασκευάσουμε σύνθετες λογικές

σύγκριση1 σύγκριση2 σύγκριση1 && σύγκριση2
παραστάσεις με τη χρήση των λογικών τελεστών
&& || ! Α Α Α
Α Ψ Ψ
if ( σύγκριση1 && σύγκριση2 ) Ψ Α Ψ
if ( σύγκριση1 || σύγκριση2 ) Ψ Ψ Ψ
if ( ! σύγκριση )
Πρακτικός κανόνας:
Το αποτέλεσμα μιας σύνθετης λογικής παράστασης Το τελικό αποτέλεσμα είναι αληθές όταν
είναι είτε αληθές είτε ψευδές και εξαρτάται από τις και οι δύο
επιμέρους συγκρίσεις. συγκρίσεις είναι αληθείς
17 18
Πίνακες αλήθειας ( || ) Πίνακες αλήθειας (!)

σύγκριση1 σύγκριση2 σύγκριση1 || σύγκριση2
σύγκριση ! σύγκριση
Α Α Α Α Ψ
Α Ψ A Ψ Α
Ψ Α A
Ψ Ψ Ψ
Πρακτικός κανόνας: Ο τελεστής ! αντιστρέφει το αποτέλεσμα της

Το τελικό αποτέλεσμα είναι αληθές όταν σύγκρισης.
είτε η μία είτε η άλλη
σύγκριση είναι αληθείς
19 20
(-a/2,b/2) (a/2,b/2)
Ένα
Ένα παραλληλόγραμμο
παραλληλόγραμμο με με κέντρο
κέντρο την
την αρχή
αρχή των
των
αξόνων
αξόνων έχει
έχει πλευρές
πλευρές a,
a, b.
b. Βρείτε
Βρείτε αν
αν ένα
ένα σημείο
σημείο με
με
συντεταγμένες
συντεταγμένες x,x, yy βρίσκεται
βρίσκεται εντός
εντός του
του
(-a/2,-b/2) (a/2,-b/2)
παραλληλογράμμου.
• Η συντεταγμένη x θα πρέπει να βρίσκεται μεταξύ -a/2 και

a/2
• Όμοια η συντεταγμένη y θα πρέπει να βρίσκεται μεταξύ

-b/2 και b/2
21 22
#include <iostream> …Συνέχεια
using namespace std; a2 = a/2;
b2 = b/2;
int main ( )
{ if ( x>=-a2 && x<=a2 && y>=-b2 && y<=b2 )
double a, b; // Τα μήκη των πλευρών cout << "Το σημείο είναι εντός\n";
double x, y; // Συντεταγμένες σημείου else
double a2, b2; // Το ήμισυ των πλευρών cout << "Το σημείο είναι εκτός\n";
}
cout << "Εισάγετε τα μήκη των πλευρών ";
cin >> a >> b;
cout << "Εισάγετε τις συντεταγμένες ";

cin >> x >> y;
23 24
Προτεραιότητες λογικών τελεστών Προτεραιότητες
Σε μια σύνθετη λογική παράσταση όπως πχ.
a>0 && b>0 || c!=2 Τελεστής Προτεραιότητα Προσεταιριστικότητα
η σειρά των λογικών πράξεων καθορίζεται από την ! ++ -- Υψηλή Από δεξιά προς αριστερά
προτεραιότητα των τελεστών. Για τελεστές ίδιας * / % Από αριστερά προς δεξιά
προτεραιότητας οι πράξεις γίνονται από αριστερά + - Από αριστερά προς δεξιά
προς τα δεξιά. < <= > >= Από αριστερά προς δεξιά
Τελεστής Προτεραιότητα == != Από αριστερά προς δεξιά
! Υψηλή
&&
&& Από αριστερά προς δεξιά
|| Χαμηλή
|| Από αριστερά προς δεξιά
= += -= *= /= %= Χαμηλή Από δεξιά προς αριστερά
Εάν υπάρχουν πράξεις σε παρενθέσεις, αυτές
γίνονται πάντα πρώτες.
25 26
Με
Με ποια
ποια εντολή
εντολή ifif μπορούμε
μπορούμε νανα διαπιστώσουμε
διαπιστώσουμε αν
αν if ( k%2 == 0 )
ένας … είναι άρτιος …
ένας ακέραιος
ακέραιος είναι
είναι άρτιος
άρτιος ήή περιττός
περιττός ;;
else
… είναι περιττός …
Ένας ακέραιος είναι άρτιος αν είναι πολλαπλάσιο Σημείωση:

του δύο, δηλαδή διαιρείται ακριβώς με το δύο
Ο τελεστής % έχει μεγαλύτερη προτεραιότητα από
χωρίς να αφήνει υπόλοιπο. τον τελεστή ==
27 28
#include <iostream>
θα αποφασίζει
αποφασίζει αν
αν int main ( )
ένα
ένα έτος
έτος είναι
είναι δίσεκτο
δίσεκτο ήή όχι.
όχι. {
int year;
cout << "Εισάγετε το έτος\n";

cin >> year;
Υπενθύμιση: if ( year%4 == 0 )
if ( year%100 == 0 )
Ένα έτος θεωρείται δίσεκτο όταν διαιρείται if ( year%400 == 0 )
cout << "Είναι δίσεκτο\n";
ακριβώς με το 4. Όμως από αυτά εξαιρούνται τα else
cout << "Δεν είναι δίσεκτο\n";
έτη που διαιρούνται με το 100, εκτός αν else
διαιρούνται με το 400. cout << " Είναι δίσεκτο \n";
else
cout << " Δεν είναι δίσεκτο \n";
29 } 30
Εναλλακτικά θα μπορούσαμε να γράψουμε:
θα βρίσκει
βρίσκει τη
τη
γωνία
γωνία που
που σχηματίζει
σχηματίζει με
με τον
τον άξονα
άξονα xx ένα
ένα
if (year%4 == 0 && year%100 != 0 || year%400 == 0)
… είναι δίσεκτο …
διάνυσμα
διάνυσμα με
με συντεταγμένες
συντεταγμένες (x,y).
(x,y).
else Η
Η γωνία
γωνία να
να υπολογίζεται
υπολογίζεται σε
σε μοίρες
μοίρες και
και εντός
εντός του
του
… δεν είναι δίσεκτο …
διαστήματος [0,360).
διαστήματος [0,360).
31 32
(x,y)
(x,y)
φ=atan(y/x) φ= atan(y/x)+2π
φ
φ
φ
(x,y)
(x,y)
Η γωνία υπολογίζεται ως atan(y/x). Όμως:
φ= atan(y/x)+π
• Αν x=0 δεν μπορεί να γίνει η διαίρεση. φ
φ
• Σημεία συμμετρικά ως προς την αρχή των αξόνων έχουν την
ίδια εφαπτομένη.
• Η συνάρτηση atan επιστρέφει αποτέλεσμα στην περιοχή -π/2
έως π/2
• Το αποτέλεσμα επιστρέφεται σε ακτίνια και όχι σε μοίρες. (x,y) φ= atan(y/x)+π
33 34
…Συνέχεια
#include <iostream> if ( x==0 )
#include <cmath> if ( y > 0 )
using namespace std; phi = 90;
else if ( y < 0 )
int main ( ) phi = 270;
{ else
double x, y; // Συντεταγμένες σημείου phi = 0;
double pi; // Ο αριθμός π else
double phi; // Η γωνία if ( x > 0 )
if ( y >= 0 )
cout << "Δώστε το σημείο "; phi = atan(y/x)*180/pi;
cin >> x >> y; else
phi = atan(y/x)*180/pi+360;
pi = acos(-1.0); else
Συνεχίζεται… phi = atan(y/x)*180/pi+180;
cout << "Η γωνία είναι " << phi << " μοίρες\n";
35 } 36
Τι κάνει η εντολή switch
Η εντολή switch ελέγχει αν η τιμή μιας ακέραιας
μεταβλητής ισούται με κάποια σταθερά (από ένα
Εντολή switch πλήθος σταθερών) και ανάλογα εκτελεί
συγκεκριμένες εντολές.
37 38
Συντακτικό της εντολής switch Πως λειτουργεί η εντολή switch

switch ( ακέραια παράσταση ) {
case σταθερά1: • Η εντολή switch αποτελείται από μια σειρά από
εντολή ; εντολές και σημεία εισόδου (όπου υπάρχει case).
εντολή ;
..
.
• Ελέγχεται η ακέραια παράσταση με τις
break ; αντίστοιχες σταθερές στις case, και
case σταθερά2: προσδιορίζεται το σημείο εισόδου.
εντολή ;
εντολή ; • Κατόπιν εκτελούνται όλες οι εντολές μέχρι το
..
. τελικό άγκιστρο, ή μέχρι να βρεθεί break.
break;
default: • Εάν δεν ταιριάζει καμία case, τότε το σημείο
εντολή ; εισόδου είναι το default.
εντολή ; Μπορεί να παραληφθεί
.. • Το break μας βγάζει από την εντολή switch.
.
}
39 40
#include <iostream>
που θα
θα υπολογίζει
υπολογίζει το
το
#include <cmath>
όγκο ενός από τα παρακάτω:
όγκο ενός από τα παρακάτω:
Ορθογώνιο
Ορθογώνιο παραλληλεπίπεδο
παραλληλεπίπεδο
int main ( )
{
Σφαίρα
Σφαίρα int n; // Επιλογή σχήματος
Κύλινδρος
Κύλινδρος double a, b, c; // Πλευρές ορθογωνίου
double pi; // Ο αριθμός π
double r, h; // Για τον κύλινδρο
double v; // Ο όγκος
cout << "Επιλέξτε αντικείμενο: \n";
cout << "1. Ορθογώνιο παραλληλόγραμμο \n";
cout << "2. Σφαίρα \n";
cout << "3. Κύλινδρος \n";
41 Συνεχίζεται… 42
…Συνέχεια
…Συνέχεια
cin >> n; case 3:
switch (n) { cout << "Ακτίνα και ύψος ? \n";
case 1: cin >> r >> h;
cout << "Μήκη πλευρών ? \n"; pi = acos(-1.0);
cin >> a >> b >> c; v = pi*r*r*h;
v = a*b*c; cout << "Ο όγκος είναι: " << v << endl;
cout << "Ο όγκος είναι: " << v << endl; break;
break; default:
case 2: cout << "Λανθασμένη επιλογή. \n";
cout << "Ακτίνα σφαίρας? \n"; }
cin >> r; }
pi = acos(-1.0);
v = 4*pi*r*r*r/3;
cout << "Ο όγκος είναι: " << v << endl;
break;
43 44
Εντολές επανάληψης
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΕΝΤΟΛΕΣ ΕΠΑΝΑΛΗΨΗΣ

Στη C++ υπάρχουν 3 διαφορετικές εντολές
επανάληψης:
• while
Εντολές επανάληψης
• for
• do-while
1 2

που για
για δεδομένο
δεδομένο
ακέραιο
ακέραιο Ν θα εμφανίζει στην οθόνη τους
Ν θα εμφανίζει στην οθόνη τους
αριθμούς
αριθμούς από
από 11 έως
έως ΝΝ
Εντολή while
3 4
Παράδειγμα #1 Συντακτικό της εντολής while 1/2

#include <iostream>
while ( συνθήκη )
εντολή ;
int main ( )
{
int n, k;
cout << "Εισάγετε το Ν ";
cin >> n; • Δεν βάζουμε ερωτηματικό μετά τη σύγκριση.
• Ως συνθήκη μπορούμε να χρησιμοποιήσουμε οποιαδήποτε
k = 1; απλή ή σύνθετη λογική παράσταση.
while ( k <= n ) { • Συντακτικά η while (μαζί με την εντολή που περιλαμβάνει)
cout << k << endl; θεωρείται ως μία εντολή.
++k; • Ανάλογα με τη συνθήκη μπορεί να μην γίνει καμία
}
επανάληψη.
}
5 6
Συντακτικό της εντολής while 2/2 Πως λειτουργεί η εντολή while


Σε περίπτωση που θέλουμε Αρχικά υπολογίζεται η συνθήκη.
while ( συνθήκη ) {
να εκτελεστούν
εντολή ;
περισσότερες από μια Εάν η συνθήκη είναι αληθής
εντολή ; while ( συνθήκη )
εντολές, χρησιμοποιούμε εκτελείται η εντολή και το
.. εντολή ;
. άγκιστρα για να πρόγραμμα επιστρέφει στο while.
} ομαδοποιήσουμε τις
εντολές.
Εάν η συνθήκη είναι ψευδής
τερματίζεται η λειτουργία της
εντολής while.
7 8
Παράδειγμα #1 (ξανά)

Μπορούμε να διακρίνουμε τρία σημεία στην εντολή
while:
k = 1; Αρχική τιμή Εντολή for

while ( k <= n ) { Συνθήκη
cout << k << endl;
++k; Αύξηση
}
9 10
Τι χρειάζεται ; Παράδειγμα #1 (με for)


Η εντολή for ενσωματώνει τα τρία σημεία της
#include <iostream>
εντολής while που είδαμε στο παράδειγμα: using namespace std;
int main ( )
• Αρχική τιμή {
• Συνθήκη επανάληψης int n, k;
• Αύξηση της μεταβλητής
cout << "Εισάγετε το Ν ";
cin >> n;
for ( k = 1 ; k <= n ; ++k )

cout << k << endl;
}
11 12
Συντακτικό της εντολής for 1/2 Συντακτικό της εντολής for 2/2

for ( αρχική τιμή ; συνθήκη ; αύξηση )
εντολή ; Σε περίπτωση που θέλουμε να εκτελεστούν
περισσότερες από μια εντολές, χρησιμοποιούμε
Παρατηρήσεις: άγκιστρα για να ομαδοποιήσουμε τις εντολές.
• Ως αρχική τιμή μπορούμε να βάλουμε οποιαδήποτε εντολή

ανάθεσης τιμής. for ( αρχική τιμή ; συνθήκη ; αύξηση ) {
• Ως συνθήκη μπορούμε να χρησιμοποιήσουμε οποιαδήποτε εντολή ;
απλή ή σύνθετη λογική παράσταση. εντολή ;
• Ως αύξηση βάζουμε οποιαδήποτε εντολή που τροποποιεί
..
.
(αυξάνει ή μειώνει) την τιμή της μεταβλητής.
• Συντακτικά η for (μαζί με την εντολή που περιλαμβάνει) }
θεωρείται ως μία εντολή.
• Οποιοδήποτε τμήμα από τα αρχική τιμή, συνθήκη, αύξηση
μπορεί να παραληφθεί. 13 14
Πως λειτουργεί η εντολή for 1/2 Πως λειτουργεί η εντολή for 2/2

for ( αρχική τιμή ; συνθήκη ; αύξηση )
εντολή ; Προσοχή:
Στην εντολή for δεν γράφουμε την αρχική τιμή,

Αρχικά ανατίθεται η αρχική τιμή. τελική τιμή και βήμα αύξησης της μεταβλητής.
Ελέγχεται η συνθήκη.
Γράφουμε:
Εάν η συνθήκη είναι αληθής εκτελείται η εντολή,
εκτελείται η αύξηση και το πρόγραμμα επιστρέφει • Μια εντολή για να αναθέσουμε αρχική τιμή.
στην for για να ελέγξει και πάλι τη συνθήκη. • Μια συνθήκη που όσο είναι αληθής γίνονται
επαναλήψεις.
Εάν η συνθήκη είναι ψευδής τερματίζεται η • Μια εντολή που αυξάνει ή μειώνει την τιμή της
λειτουργία της εντολής for. μεταβλητής.
15 16
Σχέση των εντολών for και while Παράδειγμα #2

Η παρακάτω εντολή for: Η παρακάτω εντολή for:
for ( αρχική τιμή ; συνθήκη ; αύξηση ) for ( k = 0 ; k < 10 ; ++k )

εντολή ; cout << k << endl ;
Είναι ισοδύναμη με: Είναι ισοδύναμη με:
αρχική τιμή ; k = 0;
while ( συνθήκη ) { while ( k < 10 ) {
εντολή ; cout << k << endl ;
αύξηση ; ++k;
} }
17 18

1) for ( k=1; k<=7; k=k+2 )
Πόσες
Πόσες επαναλήψεις
επαναλήψεις θα θα γίνουν
γίνουν από
από τις
τις παρακάτω
παρακάτω 4 επαναλήψεις: 1, 3, 5, 7
εντολές
εντολές for
for ;; Ποια
Ποια είναι
τιμή της
της μεταβλητής
μεταβλητής σε
σε
κάθε
κάθε επανάληψη
επανάληψη ;;
2) for ( k=10; k<17; k+=3 )
3 επαναλήψεις: 10, 13, 16
1) for ( k=1; k<=7; k=k+2 ) 3) for ( m=-2; m<2; m++ )

2) for ( k=10; k<17; k+=3 ) 4 επαναλήψεις: -2, -1, 0, 1
3) for ( m=-2; m<2; m++ )
4) for ( m=1; m<=0; m+=25 ) 4) for ( m=1; m<=0; m+=25 )
Καμία επανάληψη
5) for ( n=-8; n>=-10; n=n+2 )
5) for ( n=-8; n>=-10; n=n+2 )
Άπειρες επαναλήψεις
19 20

Πόσες
Πόσες επαναλήψεις
επαναλήψεις θα θα γίνουν
γίνουν από
από τις
τις παρακάτω
παρακάτω 1) for ( k=1; k<=15 ; )
εντολές
εντολές for ; Ποια είναι η τιμή της μεταβλητής σε
for ; Ποια είναι η τιμή της μεταβλητής σε Άπειρες επαναλήψεις
κάθε
κάθε επανάληψη
επανάληψη ;;
2) for ( k=0; ; ++k )
Άπειρες επαναλήψεις
1) for ( k=1; k<=15 ; ) 3) for ( ; ; )

2) for ( k=0; ; ++k ) Άπειρες επαναλήψεις
3) for ( ; ; )
21 22
Συντακτικό της εντολής do-while 1/2

do
εντολή ;
while ( συνθήκη );
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΕΝΤΟΛΕΣ
Εντολή do-while
• Βάζουμε ερωτηματικό μετά την εντολή, αλλά και στο

τέλος της do-while.
• Συντακτικά η do-while (μαζί με την εντολή που
περιλαμβάνει) θεωρείται ως μία εντολή.
23 24
Συντακτικό της εντολής do-while 2/2 Πως λειτουργεί η εντολή do-while 1/2

Σε περίπτωση που θέλουμε να εκτελεστούν Αρχικά εκτελείται η εντολή.
περισσότερες από μια εντολές, χρησιμοποιούμε
άγκιστρα για να ομαδοποιήσουμε τις εντολές. Κατόπιν υπολογίζεται η συνθήκη.
do
εντολή ; Εάν η συνθήκη είναι αληθής το
do {
while ( συνθήκη ); πρόγραμμα επιστρέφει στο do.
εντολή ;
εντολή ;
.. Εάν η συνθήκη είναι ψευδής
.
τερματίζεται η λειτουργία της
} while ( συνθήκη ); εντολής do-while.
25 26
Πως λειτουργεί η εντολή do-while 2/2 Παράδειγμα #5


Προσοχή:
Μια
Μια συνηθισμένη
συνηθισμένη χρήση
χρήση της
της do-while:
do-while:
Στην εντολή do-while η εντολή εκτελείται
τουλάχιστον μία φορά όποια και αν είναι η Σε
Σε περίπτωση
περίπτωση εισαγωγής
εισαγωγής λανθασμένων
λανθασμένων
συνθήκη. δεδομένων
δεδομένων να
να ζητείται
ζητείται ξανά
ξανά ηη εισαγωγή
εισαγωγή τους.
τους.
Στις εντολές while και for η εντολή μπορεί να

μην εκτελεστεί και καμία φορά ανάλογα με
τη συνθήκη.
27 28

Για να ελέγξουμε αν ο χρήστης πληκτρολόγησε
Ας υποθέσουμε ότι κάποιο πρόβλημα ζητάει να ένα θετικό ακέραιο και να ζητήσουμε ξανά τον
εισάγουμε ένα θετικό ακέραιο: αριθμό σε περίπτωση λάθους:
do {
cout << "Εισάγετε ένα θετικό ακέραιο "; cout << "Εισάγετε ένα θετικό ακέραιο ";
cin >> n; cin >> n;
if ( n <= 0 ) cout << "ΛΑΘΟΣ \n";
} while ( n <= 0 );
Πρακτικός κανόνας:
Στις ανωτέρω εντολές if και do-while γράφω την
ίδια συνθήκη.
29 30
Η εντολή break Παράδειγμα #6


Αν για οποιοδήποτε λόγο χρειάζεται να "βγούμε" Υπολογίστε
Υπολογίστε το
το άθροισμα
άθροισμα
από μια εντολή επανάληψης, χρησιμοποιούμε την
εντολή break. Συνήθως χρησιμοποιείται με κάποια
εντολή if. μόνο
μόνο για
για τις
τις περιττές
περιττές τιμές
τιμές k.
k.
Σημείωση:
for ( k=1 ; ; ++k ) { Το ζητούμενο άθροισμα είναι:
..
.
if ( … ) break;
}
31 32

Υπολογίστε
το άθροισμα:
άθροισμα:
s = 0 ; // Αθροιστής
for ( k=1 ; k<=n ; k+=2 )
s += 1.0/k ;
Σημείωση:
Το άθροισμα συγκλίνει στο π/4.
Παρατήρηση:
Κάθε όρος έχει αντίθετο πρόσημο από τον
προηγούμενο.
33 34

#include <iostream>
using namespace std; Κατασκευάστε
που θα
το
int main ( ) Ν-οστό
Ν-οστό όρο
όρο της
της ακολουθίας:
ακολουθίας:
{
int k, n;
double s, p;
cout << "Εισάγετε το n "; με

με πρώτο
πρώτο όρο
όρο xx11=1
=1
cin >> n;
s = 0;
p = 1.0; // Αρχικό πρόσημο
Σημείωση:
for ( k=1; k<=n ; k+=2 ) { Η ακολουθία αυτή συγκλίνει γρήγορα στην τιμή
s += p/k; // Άθροιση
p = -p; // Αλλαγή προσήμου
}
cout << s << endl;
}
35 36

#include <iostream>
using namespace std; Ακολουθία
Ακολουθία Fibonacci
Fibonacci
int main ( ) Υπολογίστε
το Ν-στο
Ν-στο όρο
όρο της
της ακολουθίας:
ακολουθίας:
{
int k, n; FFkk = F
= Fk-1 + F
k-1 + Fk-2
k-2
double x; με
με F00 = 0 και
F = 0 και FF11 =
= 11
cout << "Πόσοι όροι? ";
cin >> n;
Χρησιμοποιούμε δύο μεταβλητές:
x = 1.0; • fb για τον προηγούμενο όρο (Fk-1)
for ( k=2; k<=n; ++k )
x = (3*x+4)/(2*x+3); • fa για τον προ-προηγούμενο όρο (Fk-2)
cout << x << endl;

}
37 38


#include <iostream>
Υπολογισμός
Υπολογισμός ολοκληρώματος
ολοκληρώματος
int main ( )
{ Υπολογίστε
Υπολογίστε προσεγγιστικά
προσεγγιστικά το
το ολοκλήρωμα
ολοκλήρωμα
int fa, fb, fc;
int n, i;
cout << "Ποιόν όρο? ";

cin >> n; όταν
όταν δίνεται
δίνεται ηη συνάρτηση
συνάρτηση f(x)
f(x) και
και τα
τα όρια
όρια
fa = 0; ολοκλήρωσης a, b χρησιμοποιώντας
ολοκλήρωσης a, b χρησιμοποιώντας τον τον
fb = 1; κανόνα
κανόνα του
του παραλληλογράμμου.
for ( i=2; i<=n; ++i ) {
fc = fa+fb; // Ο νέος όρος.
fa = fb; // Ο προηγούμενος γίνεται προ-προηγούμενος Το ζητούμενο ολοκλήρωμα ισούται με το εμβαδόν
fb = fc; // Ο νέος όρος γίνεται προηγούμενος.
} της περιοχής μεταξύ της συνάρτησης και του
cout << fc << endl; άξονα x.
} 39 40

Ποιο είναι το μήκος κάθε υποδιαστήματος ;
Αλγόριθμος:
1. Χωρίζουμε το διάστημα [α,b] σε N ίσα υποδιαστήματα.
2. Υπολογίζουμε το εμβαδόν του κάθε ορθογωνίου παραλληλο-
γράμμου θεωρώντας ως ύψος την τιμή της συνάρτησης στο
μέσον του.
3. Αθροίζουμε όλα τα επιμέρους εμβαδά.
41 42


Ποιο είναι το μέσον του k υποδιαστήματος ;
h Ποιο είναι το εμβαδόν του υποδιαστήματος k ;
α b
Το 1o υποδιάστημα ξεκινάει στο: α
Το 2o υποδιάστημα ξεκινάει στο: α+h
Το 3o υποδιάστημα ξεκινάει στο: α+2h Ποιο είναι το συνολικό εμβαδόν ;
Το 4o υποδιάστημα ξεκινάει στο: α+3h
…
Το k υποδιάστημα ξεκινάει στο: α+(k-1)h
Το μέσον του k υποδιαστήματος είναι:
43 44

#include <cmath>
using namespace std; h = (b-a)/n; // Μήκος υποδιαστήματος
s = 0.;
int main ( ) for ( k=1; k<=n; ++k ) {
{ x = a + k*h - h/2; // Μέσον του υποδιαστήματος
double a, b; // Τα όρια ολοκλήρωσης f = sin(x); // Τιμή της συνάρτησης
double h; // Μήκος υποδιαστήματος s += h*f; // Άθροιση επιμέρους εμβαδού
double x, f; // Μέσον υποδιαστήματος και τιμή συνάρτησης }
double s; // Τιμή ολοκληρώματος cout << s << endl;
int n; // Πλήθος υποδιαστημάτων }
int k;
cout << "Εισάγετε τα όρια a, b \n";

cin >> a >> b;
cout << "Πλήθος διαστημάτων? \n";
cin >> n;
45 46


Υπολογισμός
Υπολογισμός διπλού
διπλού ολοκληρώματος
ολοκληρώματος Μπορούμε να θεωρήσουμε το διπλό ολοκλήρωμα ως:
Υπολογίστε προσεγγιστικά
προσεγγιστικά το
το διπλό
διπλό ολοκλήρωμα
ολοκλήρωμα
όπου η συνάρτηση προς ολοκλήρωση g(y) είναι:

όταν
δίνεται ηη συνάρτηση
συνάρτηση f(x,y)
f(x,y) και
και τα
τα όρια
όρια
ολοκλήρωσης
ολοκλήρωσης xa,
xa, xb,
xb, ya,
ya, yb
yb χρησιμοποιώντας
χρησιμοποιώντας τον τον
κανόνα
κανόνα τουτου παραλληλογράμμου.
Εφαρμόζουμε την τεχνική του απλού

ολοκληρώματος δύο φορές. Εφαρμόζουμε την τεχνική του απλού ολοκληρώματος δύο φορές.
47 48

#include <cmath>
using namespace std; xh = (xb-xa)/n; // Μήκος διαστήματος στο x
yh = (yb-ya)/n; // Μήκος διαστήματος στο y
int main ( ) s = 0;
{ for ( j=1; j<=n; ++j ) {
double xa, xb; // Τα όρια ολοκλήρωσης στο x y = ya+j*yh-yh/2;
double ya, yb; // Τα όρια ολοκλήρωσης στο y sx = 0;
int n; // Πλήθος υποδιαστημάτων for ( i=1; i<=n; ++i ) {
double xh, yh; // Μήκη υποδιαστημάτων x = xa+i*xh-xh/2;
double sx, s; f = x*x*sin(x*y); // Υπολογισμός συνάρτησης
int i, j; sx += xh*f;
double x, y, f; }
s += yh*sx;
cout << "Εισάγετε τα όρια "; }
cin >> xa >> xb >> ya >> yb ; cout << s << endl;
cout << "Πόσα υποδιαστήματα? "; }
cin >> n ;
Συνεχίζεται… 49 50


άθροισμα
Παρατηρείστε ότι ο κάθε όρος του αθροίσματος
μπορεί να γραφεί σε σχέση με τον προηγούμενο.
όταν
δίνεται το
το xx και
και το
το Ν.
Ν. Παράδειγμα:
Το ανωτέρω άθροισμα είναι η σειρά Taylor του ex
προηγούμενος προηγούμενος
3ος όρος 4ος όρος
όρος όρος
51 52

#include <iostream>
Γενικά:
int main ( )
{
double x, s, t;
int n, k;
cout << "Εισάγετε τα x, n \n";

cin >> x >> n;
s = 1.;
t = 1.;
for ( k=1; k<=n; ++k ) {
t *= x/k;
Αναδρομική σχέση με ένα προηγούμενο όρο. s += t;
}
Προσοχή: δεν ζητούνται οι επιμέρους όροι αλλά το άθροισμά τους. cout << s << endl;
}
53 54
Παράδειγμα #12 (επίλογος) Παράδειγμα #13


Πόσοι όροι χρειάζονται για προσεγγίσουμε το ex με
6 δεκαδικά ψηφία ; Υπολογίστε
Υπολογίστε και
και πάλι
πάλι το
άθροισμα
Αντί να προκαθορίσουμε το Ν θα μπορούσαμε να

συγκρίνουμε εντός του for το άθροισμα με την
ακριβή τιμή exp(x) και να σταματήσουμε όταν η όταν
δίνεται το
το x.
x. ΉΉ άθροιση
άθροιση να
να σταματάει
σταματάει
διαφορά γίνει μικρότερη από 10-6 όταν ο προστιθέμενος όρος γίνει
όταν ο προστιθέμενος όρος γίνει
μικρότερος
μικρότερος από 10-6 κατ'
από 10
-6
κατ' απόλυτη
απόλυτη τιμή.
τιμή.
Εναλλακτικά, για να μην χρησιμοποιήσουμε τη
συνάρτηση exp(x), μπορούμε να σταματήσουμε
όταν ο προστιθέμενος όρος t είναι τόσο μικρός που
δεν μπορεί να επηρεάσει τα προηγούμενα ψηφία.
55 56

#include <iostream>
άθροισμα
int main ( )
{
double x, e, s, t;
int k;
cout << "Εισάγετε το x \n"; μέχρι

μέχρι τον
τον όρο
όρο τάξης
τάξης Ν,
Ν, όταν
δίνεται το
το xx και
και το
το N.
N.
cin >> x;
s = 1;
t = 1; Υπενθύμιση:
e = 1.e-6; Το ανωτέρω άθροισμα αποτελεί μια προσέγγιση του
for ( k=1; abs(t)>=e; ++k ) {
t *= x/k;
s += t; για (διωνυμική σειρά)
}
cout << s << endl;
} 57 58


Παρατηρούμε ότι ο κάθε όρος του αθροίσματος Γενικά:
μπορεί να γραφεί σε σχέση με τον προηγούμενο.
3ος όρος προηγούμενος όρος

59 60
#include <iostream>
int main ( )
{
int k, n;
double x, s, t;
cout << "Εισάγετε τα x, n ";

cin >> x >> n;
s = 1;
t = 1;
for ( k=1; k<=n; ++k ) {
t = -t*x*(2*k-1)/(2*k);
s += t;
}
cout << s << endl;
}
61
Τι είναι οι πίνακες;
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΜΟΝΟΔΙΑΣΤΑΤΟΙ ΠΙΝΑΚΕΣ

Απλές μεταβλητές:
3.2 a
Μονοδιάστατοι πίνακες 1.0 e Ονόματα

μεταβλητών
Κεντρική 0.001 z
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ -
μνήμη
..
.
1 2
Τι είναι οι πίνακες; Τι είναι οι πίνακες;


Πίνακες: Μια ομάδα διαδοχικών θέσεων αποθήκευσης στην
κεντρική μνήμη, στην οποία αναφερόμαστε με ένα
κοινό όνομα.
Κάθε στοιχείο του πίνακα ξεχωρίζει από τα

x
υπόλοιπα με τη χρήση ενός δείκτη. Έτσι για ένα
Κεντρική
πίνακα που ονομάζεται x:
μνήμη
Όνομα Το πρώτο στοιχείο είναι το x[0]

πίνακα Το δεύτερο στοιχείο είναι το x[1]
..
. Σημείωση:
3
Όλα τα στοιχεία του πίνακα είναι του ιδίου τύπου. 4
Δήλωση Ορισμένες παρατηρήσεις

Πριν χρησιμοποιήσουμε ένα πίνακα πρέπει να τον • Το 100 είναι το πλήθος των στοιχείων του πίνακα
και όχι ο δείκτης του τελευταίου στοιχείου.
δηλώσουμε. Για να δηλώσουμε ένα πίνακα που
ονομάζεται x και αποτελείται από 100 στοιχεία • Τα στοιχεία του πίνακα είναι τα:
x[0], x[1], x[2], … x[99].
διπλής ακρίβειας γράφουμε:
• Το κάθε στοιχείο του πίνακα μπορεί να
double x[100]; χρησιμοποιηθεί όπως και μια μεταβλητή του
αντίστοιχου τύπου. Πχ.
x[0] = 4;
a = 3*x[0]+2*x[1];
Τύπος Όνομα Πλήθος cin >> x[4];
στοιχείων πίνακα στοιχείων
• Από τα 100 στοιχεία μπορούμε να
χρησιμοποιήσουμε στο πρόγραμμα λιγότερα.
5 6
Δήλωση Ανάθεση τιμών στα στοιχεία πίνακα


Ανάθεση τιμών κατά τη δήλωση:
Το πλήθος των στοιχείων μπορεί να δηλωθεί με τη
χρήση συμβολικών σταθερών:
int a[10]={4,7,1,-3,0};
#define NMAX 100
double x[ΝΜΑΧ];
Η ανωτέρω δήλωση αναθέτει αρχικές τιμές στα 5
πρώτα από τα 10 στοιχεία του πίνακα a
Η γραμμή #define απευθύνεται στον προεπεξεργαστή
και ορίζει μια συμβολική σταθερά - όχι μεταβλητή -
Προσοχή: όχι ερωτηματικό στο τέλος του #define
7 8
Ανάθεση τιμών στα στοιχεία πίνακα Ανάθεση τιμών στα στοιχεία πίνακα

Απευθείας ανάθεση: Εισαγωγή από το πληκτρολόγιο:
x[0] = 1.2; Εισάγουμε ένα-προς-ένα τα στοιχεία:

#define NMAX 100
x[1] = 2.5;
double x[NMAX];
x[2] = z+2*x[0];
cout << "Πόσα στοιχεία ? ";
for ( k=0; k<n; ++k ) cin >> n;
if ( n>NMAX || n<1 ) {
x[k] = k*k/2; cout << "Λανθασμένος αριθμός \n";
return 1;
}
for ( k=0; k<n; ++k ) {
cout << "Εισάγετε το στοιχείο " << k << endl;
cin >> x[k];
9
} 10
Εμφάνιση των στοιχείων πίνακα


στην οθόνη
Εμφανίζουμε ένα-προς-ένα τα στοιχεία:

Βρείτε
Βρείτε το
το μέσο
μέσο όρο
όρο μιας
μιας σειράς
σειράς αριθμών
αριθμών που
που
#define NMAX 100 εισάγονται από το πληκτρολόγιο.
εισάγονται από το πληκτρολόγιο.
double x[NMAX];
for ( k=0; k<n; ++k )

cout << x[k] << endl;
11 12

s = 0;
#define NMAX 100 for ( k=0; k<n; ++k )
int main ( ) s += x[k];
{ avg = s/n;
double x[NMAX];
int n, k; cout << "Ο μέσος όρος είναι: " << avg << endl;
double s, avg;
}
cout << "Πόσα στοιχεία ? ";
cin >> n;
if ( n > NMAX || n < 1 ) {
cout << "Λάθος \n";
return 1;
}
for ( k=0; k<n; ++k) {
cout << "Εισάγετε το στοιχείο " << k << endl;
cin >> x[k];
}

for ( k=0; k<n; ++k )
cout << k << " " << x[k] << " "
Συμπληρώστε
Συμπληρώστε το
το προηγούμενο
προηγούμενο παράδειγμα
παράδειγμα έτσι
έτσι << abs(avg-x[k]) << endl;
ώστε να εμφανίζει στην οθόνη πόσο απέχει κάθε
ώστε να εμφανίζει στην οθόνη πόσο απέχει κάθε
αριθμός
αριθμός που
που εισάγαμε
εισάγαμε από
από το
το μέσο
μέσο όρο.
όρο. Τυπικό αποτέλεσμα στην οθόνη για 4 στοιχεία:
0 1.7 0.8805
1 0.85 1.7305
2 3.6 1.0195
3 4.172 1.5915
Παρατηρείστε ότι οι τρεις στήλες των

αποτελεσμάτων δεν είναι στοιχισμένες.
15 16
Μορφοποίηση της εξόδου Οι βασικότεροι χειριστές

• setw(n)
Για αν μορφοποιήσουμε κατά βούληση την
Η επόμενη έξοδος θα καταλαμβάνει n θέσεις στην οθόνη.
εμφάνιση των αποτελεσμάτων μας στην οθόνη
• setprecision(n)
χρησιμοποιούμε τους χειριστές στην εντολή cout. Όλες οι επόμενες έξοδοι θα γίνουν με n δεκαδικά ψηφία.
• fixed
Πχ. για να εμφανίσουμε έναν ακέραιο ώστε να Όλες οι επόμενες έξοδοι θα γίνουν με την κλασσική
καταλαμβάνει 5 θέσεις στην οθόνη: αναπαράσταση.
• scientific
cout << setw(5) << k << endl; Όλες οι επόμενες έξοδοι θα γίνουν με την επιστημονική
αναπαράσταση.
Σημείωση: Για να χρησιμοποιήσουμε τους χειριστές

χειριστής
μορφοποίησης πρέπει να δηλώσουμε:
17
#include <iomanip> 18
Παράδειγμα #2 (με μορφοποίηση) Παράδειγμα #3


cout << fixed << setprecision(7);
for ( k=0; k<n; ++k ) Βρείτε
Βρείτε το
το μικρότερο
μικρότερο στοιχείο
στοιχείο ενός
ενός πίνακα
πίνακα με
με nn
cout << setw(3) << k << " " στοιχεία.
στοιχεία.
<< setw(10) << x[k] << " "
<< setw(10) << abs(avg-x[k]) << endl;
Τυπικό αποτέλεσμα στην οθόνη για 4 στοιχεία:
0 1.7000000 0.8805000
1 0.8500000 1.7305000
2 3.6000000 1.0195000
3 4.1720000 1.5915000
19 20

min = x[0]; Βρείτε
Βρείτε το
το μικρότερο
μικρότερο στοιχείο
στοιχείο ενός
ενός πίνακα
πίνακα με
με nn
for ( k=1; k<n; ++k)
στοιχεία
στοιχεία και
και τη
τη θέση
θέση στην
στην οποία
οποία βρίσκεται
βρίσκεται αυτό.
αυτό.
if ( x[k] < min )
min = x[k];
21 22

min = x[0]; Προσαρμογή
Προσαρμογή ελαχίστων
ελαχίστων τετραγώνων
τετραγώνων
kmin = 0;
for ( k=1; k<n; ++k)
if ( x[k] < min ) { Δεδομένων
Δεδομένων Ν Ν σημείων
σημείων (x
(xi,y ) στο επίπεδο
i,yi i) στο επίπεδο
min = x[k]; προσδιορίστε
προσδιορίστε τη
τη βέλτιστη
βέλτιστη ευθεία
ευθεία που
που
kmin = k; ελαχιστοποιεί
ελαχιστοποιεί τις
τις αποστάσεις
αποστάσεις από από τα
τα σημεία.
σημεία.
}
23 24

Η βέλτιστη ευθεία έχει εξίσωση:
y
Οι συντελεστές α, b δίνονται από:
25 26

#include <iostream>
using namespace std; …Συνέχεια
#define NMAX 100 sx = sy = sxx = sxy = 0;
for ( k=0; k<n; ++k ) {
int main ( ) sx += x[k];
{ sy += y[k];
double x[NMAX], y[NMAX];
sxx += x[k]*x[k];
int n, k;
sxy += x[k]*y[k];
double sx, sy, sxx, sxy;
}
double a, b;
cout << "Πόσα σημεία έχετε "; a = (n*sxy-sx*sy)/(n*sxx-sx*sx);

cin >> n; b = (sxx*sy-sx*sxy)/(n*sxx-sx*sx);
if ( n < 1 || n > NMAX ) {
cout << "Λάθος \n"; cout << "Οι συντελεστές είναι: \n";
return 1; cout << a << endl;
} cout << b << endl;
for ( k=0; k<n; ++k ) { }
cout << "Δώστε το σημείο " << k << endl;
cin >> x[k] >> y[k];
}

Το ολικό φορτίο είναι:
Σύστημα
Σύστημα φορτισμένων
φορτισμένων σωματιδίων
σωματιδίων
Θεωρήστε
Θεωρήστε ένα ένα σύστημα
σύστημα που που αποτελείται
αποτελείται από
από N N Το κέντρο μάζας είναι:
φορτισμένα
φορτισμένα σωματίδια,
σωματίδια, το το καθένα
καθένα με φορτίο qqi,i,
με φορτίο
και
και μάζα
μάζα mmi.i. Η
Η θέση
θέση του
του κάθε
κάθε σωματιδίου
σωματιδίου
προσδιορίζεται
προσδιορίζεται από από τις συντεταγμένες xxi,i, yyi,i, zzi.i.
τις συντεταγμένες
Βρείτε:
Βρείτε:
α)
α) το ολικό φορτίο του συστήματος
το ολικό φορτίο του συστήματος Η ηλεκτροστατική ενέργεια είναι:
β) το κέντρο μάζας του συστήματος
β) το κέντρο μάζας του συστήματος
γ)
γ) την
την ολική
ολική ηλεκτροστατική
ηλεκτροστατική ενέργεια
ενέργεια
29 30
Παράδειγμα #6 (Δηλώσεις) Παράδειγμα #6 (Εισαγωγή)


#include <cmath>
using namespace std; cout << "Πόσα σωματίδια? \n";
cin >> n;
#define NMAX 100 // Μέγιστο πλήθος σωματιδίων if ( n < 1 || n > NMAX ) {
cout << "Λανθασμένος αριθμός\n";
int main ( ) return 1;
{ }
int n; // Πλήθος σωματιδίων for ( k=0; k<n; ++k ) {
double x[NMAX], y[NMAX], z[NMAX];// Συντεταγμένες cout << "Δώστε συντεταγμένες, μάζα και φορτίο "
double m[NMAX], q[NMAX]; // Μάζες και φορτία << "για το σωματίδιο " << k << endl;
int k, i, j; cin >> x[k] >> y[k] >> z[k] >> m[k] >> q[k];
double sx, sy, sz, sm; }
double xm, ym, zm; // Κέντρο μάζας
double qtot; // Ολικό φορτίο Συνεχίζεται…
double e; // Ηλεκτρ. ενέργεια.
double d;
31 32
Παράδειγμα #6 (Ολικό φορτίο) Παράδειγμα #6 (Κέντρο μάζας)

…Συνέχεια …Συνέχεια
qtot = 0; sx = sy = sz = sm = 0;
for ( k=0; k<n; ++k ) for ( k=0; k<n; ++k ) {
qtot += q[k]; sx += m[k]*x[k];
cout << "Το ολικό φορτίο είναι " << qtot << endl; sy += m[k]*y[k];
sz += m[k]*z[k];
Συνεχίζεται… sm += m[k];
}
xm = sx/sm;
ym = sy/sm;
zm = sz/sm;
cout << "Το κέντρο μάζας είναι "
<< xm << " " << ym << " " << zm << endl;
33 34
Παράδειγμα #6 (Ηλ. ενέργεια)


…Συνέχεια
e = 0;
for ( i=0; i<n-1; ++i )
for ( j=i+1; j<n; ++j ) {
Πίνακες χαρακτήρων
d = sqrt( pow(x[i]-x[j],2)+pow(y[i]-y[j],2)+
pow(z[i]-z[j],2) );
e += q[i]*q[j]/d;
}
cout << "Η ηλεκτροστατική ενέργεια είναι "
<< e << endl;
}
35 36
Μεταβλητές τύπου char Πίνακες χαρακτήρων (συμβολοσειρές)

• Που χρησιμεύουν: • Που χρησιμεύουν:
Για την αποθήκευση μεμονωμένων χαρακτήρων. Για την αποθήκευση σειρών χαρακτήρων (λέξεων,
φράσεων, κειμένου).
• Δήλωση:
char c; • Δήλωση:
#define MAX 100
• Εισαγωγή από το πληκτρολόγιο: char s[MAX];
cin >> c;
• Εισαγωγή από το πληκτρολόγιο (μόνο μια λέξη):
• Εμφάνιση στην οθόνη: cin >> s;
cout << c;
• Εμφάνιση στην οθόνη:
• Ανάθεση τιμής: cout << s;
c = 'A'; // Ο χαρακτήρας Α
c = '4'; // Ο χαρακτήρας 4
c = '\n'; // Ο χαρακτήρας αλλαγής γραμμής
c = '\0'; // Ο χαρακτήρας με αριθμό 0
37 38
Ποιος τοποθετεί το χαρακτήρα

Χαρακτήρας τερματισμού

τερματισμού ;
Από το μέγιστο δηλωμένο μέγεθος ενός πίνακα χαρακτήρων Εξαρτάται πως δίνω τιμή στη συμβολοσειρά:
μπορεί να χρησιμοποιήσουμε λιγότερες θέσεις. Μετά το τέλος
των χρησιμοποιημένων θέσεων τοποθετείται ο χαρακτήρας
τερματισμού. Πχ για ένα πίνακα 10 χαρακτήρων: • cin >> s;
Ο χαρακτήρας τερματισμού τοποθετείται αυτόματα από
Θέσεις: 0 1 2 3 4 5 6 7 8 9 την cin.
Περιεχόμενο: H E L L O • Μπορώ να δώσω τιμές με απευθείας ανάθεση (δεν

συνιστάται):
s[0] = 'H';
s[1] = 'E';
s[2] = 'L';
Χαρακτήρας τερματισμού s[3] = 'L';
Χαρακτήρας που αντιστοιχεί στον ακέραιο 0 s[4] = 'O';
Συμβολίζεται: \0 s[5] = '\0';
39 40

#include <iostream>
που θα
θα δέχεται
δέχεται ως
ως using namespace std;
είσοδο μια συμβολοσειρά και θα βρίσκει το μήκος

είσοδο μια συμβολοσειρά και θα βρίσκει το μήκος #define MAX 100
της.
της. int main ( )
{
char s[MAX];
int k;
Παρατήρηση:
cout << "Δώστε μια λέξη ";
Θα πρέπει να βρούμε σε ποια θέση του πίνακα cin >> s;
βρίσκεται ο χαρακτήρας τερματισμού.
for ( k=0; s[k] != '\0'; ++k )
;
cout << "Το μήκος είναι " << k << endl;

}
41 42
Συναρτήσεις για συμβολοσειρές Συναρτήσεις για συμβολοσειρές


• strlen ( s ) • gets ( s )
Επιστρέφει το πλήθος των χαρακτήρων της συμβολοσειράς s Εισαγωγή από το πληκτρολόγιο της συμβολοσειράς s (μια
(Δεν συμπεριλαμβάνεται ο χαρακτήρας τερματισμού). ολόκληρη φράση μέχρι να πατήσουμε Enter). Τοποθετεί
αυτόματα και το χαρακτήρα τερματισμού.
• strcpy ( s1, s2 )
Αντιγράφει τη συμβολοσειρά s2 στη s1.
• strcmp ( s1, s2 )
Για να χρησιμοποιήσουμε την ανωτέρω συνάρτηση πρέπει να
Συγκρίνει τις συμβολοσειρές s1 και s2 και επιστρέφει:
βάλουμε:
-1 αν η s1 είναι λεξικογραφικά μικρότερη από την s2.
0 αν η s1 είναι λεξικογραφικά ίση με την s2. #include <cstdio>
1 αν η s1 είναι λεξικογραφικά μεγαλύτερη από την s2.
Για να χρησιμοποιήσουμε τις ανωτέρω συναρτήσεις για

συμβολοσειρές πρέπει να βάλουμε:
#include <cstring>
43 44

Ακέραιος Χαρακτήρας
Πως μετατρέπουμε ένα χαρακτήρα .. ..
. .
Κατασκευάστε από κεφαλαίο σε μικρό;
που θα
θα δέχεται
δέχεται ως
ως 48 0
49 1
είσοδο μια συμβολοσειρά και θα μετατρέπει τυχόν
είσοδο μια συμβολοσειρά και θα μετατρέπει τυχόν 50 2
Βασιζόμαστε στο ότι:
κεφαλαίους
κεφαλαίους χαρακτήρες
χαρακτήρες σε
σε μικρούς.
μικρούς. 51 3
52 4
.. ..
• Υπάρχει αντιστοιχία χαρακτήρων . .
αριθμών. 65 A
66 B
• Στον πίνακα αντιστοίχισης 67 C
υπάρχουν τρεις ομάδες 68 D
69 E
χαρακτήρων: κεφαλαία, μικρά, .. ..
. .
ψηφία. 97 a
98 b
• Οι χαρακτήρες κάθε ομάδας 99 c
βρίσκονται σε διαδοχικές θέσεις 100 d
του πίνακα. 101
. e
.
45 .. .. 46

Για να μετατρέψουμε ένα χαρακτήρα (char c) από
Πως αποφασίζουμε αν ένας χαρακτήρας (char c)
κεφαλαίο σε μικρό:
είναι κεφαλαίος ;
• Βρίσκουμε πόσο απέχει από την αρχή των
κεφαλαίων (δηλαδή από το Α):
d = c-'A'; Πρέπει να βρίσκεται μεταξύ των χαρακτήρων Α και Ζ
• Προσθέτουμε την απόσταση αυτή στην αρχή των
μικρών (δηλαδή στο a): if ( c >= 'A' && c <= 'Z' )
new = 'a'+d;
• Ή συνολικά:
new = 'a'-'A'+c;
Στις αριθμητικές πράξεις χρησιμοποιούμε

χαρακτήρες. Εκεί εννοείται ο αντίστοιχος ακέραιος. 47 48

#include <cstdio>
#include <cstring> len = strlen(s);
using namespace std; for (k=0; k<len; ++k)
if (s[k]>='A' && s[k]<='Z')
#define MAX 100 snew[k] = s[k]-'A'+'a';
else
main ( ) snew[k] = s[k];
{
char s[MAX] ; snew[len] = '\0';
char snew[MAX]; cout << snew << endl;
int len, k; }
cout << "Εισάγετε μια συμβολοσειρά ";

gets(s);
49 50

#include <iostream>
που θα
θα δέχεται
δέχεται ως
ως
#include <cstdio>
#include <cstring>
είσοδο μια συμβολοσειρά και θα μετράει πόσοι:
είσοδο μια συμβολοσειρά και θα μετράει πόσοι: using namespace std;
1)
1) Κεφαλαίοι
Κεφαλαίοι χαρακτήρες
χαρακτήρες #define MAX 100
2)
2) Μικροί
Μικροί χαρακτήρες
χαρακτήρες int main ()
3)
3) Αριθμητικά
Αριθμητικά ψηφία
ψηφία {
char str[MAX];
4) Σύμβολα
4) Σύμβολα int len; // Μήκος αλφαριθμητικού
int n1; // Πλήθος κεφαλαίων
υπάρχουν
υπάρχουν στη
στη συμβολοσειρά.
συμβολοσειρά. int n2; // Πλήθος μικρών
int n3; // Πλήθος ψηφίων
int n4; // Πλήθος σύμβόλων
int k;
cout << "Εισάγετε μια συμβολοσειρά ";

gets(str);
51 52
…Συνέχεια
n1 = n2 = n3 = n4 = 0;
len = strlen(str);
for (k=0; k<len; ++k)
if (str[k]>='A' && str[k]<='Z')
++n1;
else if (str[k]>='a' && str[k]<='z')
++n2;
else if (str[k]>='0' && str[k]<='9')
++n3;
else
++n4;
cout << "Δώσατε: " << str << endl;

cout << n1 << " Κεφαλαία \n";
cout << n2 << " Μικρά \n";
cout << n3 << " Ψηφία \n";
cout << n4 << " Σύμβολα \n";
}
53
Τι είναι ;
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΣΥΝΑΡΤΗΣΕΙΣ
• Αυτόνομα τμήματα κώδικα (υποπρογράμματα) που
πραγματοποιούν μια καθορισμένη εργασία.
• Χρήσιμες για περιπτώσεις που ο ίδιος υπολογισμός
επαναλαμβάνεται πολλές φορές μέσα στο πρόγραμμα.
• Βοηθούν στην τμηματική ανάπτυξη και έλεγχο μεγάλων
Συναρτήσεις προγραμμάτων.
• Παράδειγμα: οι ενσωματωμένες συναρτήσεις sin, cos,
sqrt, abs, κλπ
• Κάθε συνάρτηση μπορεί να δέχεται ως είσοδο μία ή
περισσότερες μεταβλητές και μπορεί να επιστρέφει ένα
αποτέλεσμα (ή παραπάνω).
• Κάθε πρόγραμμα C++ αποτελείται από μία η περισσότερες
συναρτήσεις.
1 2
double convert ( double cm )
Κατασκευάστε συνάρτηση
συνάρτηση που
που θα
θα δέχεται
δέχεται
{
εκατοστά και θα τα μετατρέπει σε ίντσες. double inch;
εκατοστά και θα τα μετατρέπει σε ίντσες.
inch = cm/2.54;
Υπενθύμιση: return inch;
1 in = 2.54 cm }
Συνάρτηση
Είσοδος Έξοδος
convert
double cm
3 4
Παράδειγμα #1 Παράδειγμα #1 (πλήρες)
#include <iostream>
Η επικεφαλίδα της συνάρτησης: using namespace std;
double convert ( double ); // Πρωτότυπο συνάρτησης
int main ( )
double convert ( double cm ) {
double a, b;
cout << "Πόσα εκατοστά ? ";

Τύπος Όνομα Τύπος και όνομα cin >> a;
αποτελέσματος συνάρτησης μεταβλητών εισόδου b = convert(a); // Κλήση συνάρτησης

(τυπικές παράμετροι) cout << a << " εκατοστά είναι " << b << " ίντσες \n";
}

{
double inch;
// Κώδικας συνάρτησης
inch = cm/2.54;
return inch;
5 } 6
Η δομή ενός προγράμματος με

Η μορφή μιας συνάρτησης συναρτήσεις
δηλώσεις #include
τύπος αποτελέσματος όνομα συνάρτησης ( παράμετροι ) πρωτότυπα συναρτήσεων Το κυρίως πρόγραμμα main
{ int main ( ) είναι μια συνάρτηση που
καλείται από το λειτουργικό
δηλώσεις τοπικών μεταβλητών {
… εντολές … σύστημα.
}
return τιμή αποτελέσματος
}
συνάρτηση1
συνάρτηση2
7 8
Το πρωτότυπο της συνάρτησης Μεταβλητές της συνάρτησης
Οι μεταβλητές που ορίζονται εσωτερικά σε μια συνάρτηση
• Χρειάζεται έτσι ώστε ο μεταφραστής να
αποτελούν τοπικές μεταβλητές της συνάρτησης και δεν έχουν
γνωρίζει τι τύπου ορίσματα δέχεται η σχέση με μεταβλητές που έχουν το ίδιο όνομα σε άλλες
συνάρτηση και τι τύπου αποτέλεσμα συναρτήσεις.
επιστρέφει.
int main ( )
• Είναι ίδιο με την επικεφαλίδα της συνάρτησης {
χωρίς τα ονόματα των μεταβλητών. int k;
… … …
• Τα πρωτότυπα γράφονται πριν από το main } Διαφορετικές μεταβλητές
αλλά γενικά πριν χρησιμοποιήσουμε τις double abc ( double x ) (με διαφορετική τιμή)
συναρτήσεις. {
int k;
• Στο τέλος του πρωτότυπου μπαίνει
… … …
ερωτηματικό.
9
} 10
Τι τύπου αποτέλεσμα επιστρέφει Κλήση και επιστροφή της

μια συνάρτηση ; συνάρτησης
• Για να χρησιμοποιήσουμε μια συνάρτηση πρέπει να την
καλέσουμε. Πχ. η συνάρτηση
• Μια συνάρτηση μπορεί να επιστρέψει
αποτέλεσμα οποιουδήποτε από τους τύπους καλείται ως:
δεδομένων που χειρίζεται η γλώσσα (double, a = convert(b)
int, κλπ). • Οι μεταβλητές στην επικεφαλίδα της συνάρτησης (cm)
ονομάζονται τυπικές παράμετροι.
• Ο τερματισμός λειτουργίας της συνάρτησης και
• Οι μεταβλητές που δίνουμε κατά την κλήση (b) ονομάζονται
η επιστροφή του αποτελέσματος γίνεται με την πραγματικές παράμετροι ή ορίσματα της κλήσης. Το πλήθος
εντολή return. και οι τύποι των ορισμάτων κατά την κλήση πρέπει να
συμβαδίζουν με αυτά που δηλώθηκαν στο πρωτότυπο και
την επικεφαλίδα της συνάρτησης.
• Κάθε συνάρτηση μπορεί να κληθεί πολλές φορές με
διαφορετικά ορίσματα. Πχ:
x = convert(y)
11 q = convert(3*w-t) 12
Κλήση και επιστροφή της
συνάρτησης
Η κλήση και η επιστροφή της συνάρτησης γίνεται ως εξής:
• Οι πραγματικές παράμετροι αντιγράφονται στις τυπικές Κατασκευάστε

που θα
θα δέχεται
δέχεται ως
ως
παραμέτρους. Πχ αν η συνάρτηση
είσοδο μια γωνία σε ακτίνια και θα την μετατρέπει
είσοδο μια γωνία σε ακτίνια και θα την μετατρέπει
κληθεί ως: σε
σε μοίρες.
μοίρες.
a = convert(b)
τότε η τιμή της b αντιγράφεται στην cm. Ο τρόπος αυτός
μεταβίβασης τιμών ονομάζεται μεταβίβαση κατ' αξία. Υπενθύμιση:
• Ο υπολογιστής εγκαταλείπει το σημείο που βρισκόταν και Μοίρες = Ακτίνια*180/π
πηγαίνει στον κώδικα της συνάρτησης.
• Εκτελούνται οι εντολές της συνάρτησης και μόλις βρεθεί η

εντολή return, ο υπολογιστής επιστρέφει στο σημείο από
όπου κλήθηκε η συνάρτηση.
13 14
#include <iostream>
#include <cmath>
double moires ( double ); // Πρωτότυπο

Υλοποιήστε
Υλοποιήστε σε
σε C++
C++ τη
τη συνάρτηση:
συνάρτηση:
int main ( )
{
double a;
cout << "Πόσα ακτίνια ? ";

cin >> a;
cout << a << " ακτίνια είναι " << moires(a)

<< " μοίρες \n";
}
double moires ( double rad )

{
return rad*180/acos(-1.0);
} 15 16
double f ( double x )
Εμφανίστε
Εμφανίστε στην
στην οθόνη
οθόνη πίνακα
πίνακα τιμών
τιμών της
της
{
return (7*x*x-3*x+6)/sqrt(1+x*x); προηγούμενης
προηγούμενης συνάρτησης, από x=0 έως 10
συνάρτησης, από x=0 έως 10
} ανά 0.1
ανά 0.1
17 18
Αποτέλεσμα στην οθόνη:
#include <iostream>
#include <cmath>
#include <iomanip> 0.0 6.0000000
using namespace std; 0.1 5.7413646
0.2 5.5696982
double f ( double ); 0.3 5.4883446
0.4 5.4965820
int main ( ) 0.5 5.5901699
{ 0.6 5.7623525
double x; 0.7 6.0049700
0.8 6.3094200
cout << fixed; 0.9 6.6673485
for (x=0; x<=10; x+=0.1) 1.0 7.0710678
cout << setw(5) << setprecision(1) << x << " " 1.1 7.5137551
<< setw(10) << setprecision(7) << f(x) 1.2 7.9895013
<< endl; 1.3 8.4932709
} 1.4 9.0208168
1.5 9.5685784
… …
19 20
Συναρτήσεις που δεν επιστρέφουν
αποτέλεσμα
Μια συνάρτηση μπορεί να μην επιστρέφει
αποτέλεσμα. Λέμε ότι είναι συνάρτηση τύπου void. Κατασκευάστε
συνάρτηση πουπου θα
θα δέχεται
δέχεται ως
ως
είσοδο έναν ακέραιο n και θα εμφανίζει στην
είσοδο έναν ακέραιο n και θα εμφανίζει στην
Μια συνάρτηση που δεν επιστρέφει αποτέλεσμα οθόνη
οθόνη nn φορές
φορές τη
τη φράση:
φράση:
δεν καλείται με τον ίδιο τρόπο όπως οι άλλες Κατανοώ
Κατανοώ τη γλώσσα C++
τη γλώσσα C++
συναρτήσεις, αλλά η κλήση της μοιάζει με εντολή.
21 22
Παράδειγμα #5 Συναρτήσεις χωρίς παραμέτρους

#include <iostream>
Υπάρχουν συναρτήσεις που εκτελούν μια
void katanoo ( int ); // Πρωτότυπο συνάρτησης
συγκεκριμένη εργασία χωρίς να δέχονται
παραμέτρους.
int main ( )
{
int k;
cout << "Πόσες φορές ? ";

cin >> k;
katanoo(k); // Κλήση συνάρτησης

}
void katanoo ( int n )

{
int i;
// Κώδικας συνάρτησης
for (i=1; i<=n; ++i)
cout << "Κατανοώ τη γλώσσα C++ \n"
}
23 24
double golden ( )
{
που θα
υπολογίζει και
και return (sqrt(5.0)-1)/2;
θα επιστρέφει το λόγο της χρυσής τομής
θα επιστρέφει το λόγο της χρυσής τομής }
Το αντίστοιχο πρωτότυπο θα δηλωθεί ως:
double golden ( void );
Η κλήση της συνάρτησης:
a = golden();
25 26
#include <iostream>
#include <cmath>
που θα
θα δέχεται
δέχεται ως
ως
double metro ( double, double, double );
είσοδο τις τρεις καρτεσιανές συντεταγμένες
είσοδο τις τρεις καρτεσιανές συντεταγμένες ενόςενός
διανύσματος
διανύσματος καικαι θα
το μέτρο
μέτρο του.
του.
int main ( )
{
double x, y, z;
cout << "Εισάγετε συντεταγμένες ";

cin >> x >> y >> z;
cout << "Το μέτρο είναι " << metro(x,y,z) << endl;
}
double metro ( double x, double y, double z)

{
return sqrt(x*x+y*y+z*z);
}
27 28
Ποιος μπορεί να καλέσει μια
συνάρτηση ;
Κατασκευάστε τη τη συνάρτηση
συνάρτηση
Μια συνάρτηση μπορεί να κληθεί είτε από το κυρίως double
double gonia ( double x1, double y1,
gonia ( double x1, double y1, double
double z1, z1,
πρόγραμμα main ή από οποιαδήποτε άλλη double
double x2, double y2, double z2
x2, double y2, double z2 ))
συνάρτηση. που
που θα
υπολογίζει τη τη γωνία
γωνία (σε
(σε μοίρες)
μοίρες) μεταξύμεταξύ δύο δύο
διανυσμάτων
διανυσμάτων rr11,, rr22 με
με συντεταγμένες
συντεταγμένες (x (x11,y
,y11,z
,z11)) και
και (x
(x22,y
,y22,z
,z22).
).
Κατασκευάστε πρώτα μια συνάρτηση για το εσωτερικό γινόμενο

και χρησιμοποιείστε τις συναρτήσεις metro και moires που
φτιάξαμε πριν.
29 30
double ginomeno ( double x1, double y1, double z1, double gonia ( double x1, double y1, double z1,
double x2, double y2, double z2 ) double x2, double y2, double z2 )
{ {
double m1, m2;
return x1*x2 + y1*y2 + z1*z2; double g, t, phi, mphi;
}
m1 = metro(x1,y1,z1);
m2 = metro(x2,y2,z2);
if ( m1*m2 == 0 )
mphi = 0;
else {
g = ginomeno(x1,y1,z1,x2,y2,z2);
t = g/(m1*m2);
if ( t > 1 ) t = 1;
if ( t < -1 ) t = -1;
phi = acos(t);
mphi = moires(phi);
}
return mphi;
31 } 32
Τι χρειάζονται οι εντολές:
#include <iostream>
#include <cmath>
if ( t > 1 ) t = 1;
double metro ( double,double,double );
if ( t < -1 ) t = -1; double ginomeno ( double,double,double,double,double,double );
double gonia ( double,double,double,double,double,double );
double moires ( double );
Κάποιες φορές λόγω σφαλμάτων στρογγύλευσης μπορεί το t
(δηλαδή το cosφ) να υπολογιστεί ως: int main ( )
1.0000000000000001 {
double x1, y1, z1, x2, y2, z2;
Σε αυτή την περίπτωση η κλήση της συνάρτησης acos που
ακολουθεί θα δώσει λάθος. cout << "Εισάγετε συντεταγμένες ";
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
cout << "Η γωνία είναι "

<< gonia(x1,y1,z1,x2,y2,z2) << endl;
}
33 34
Δίνεται
Δίνεται ηη συνάρτηση
συνάρτηση
Πως καλούνται οι συναρτήσεις στο παράδειγμα.
main Υπολογίστε
Υπολογίστε μια
μια προσέγγιση
προσέγγιση της
της πρώτης
πρώτης παραγώγου,
παραγώγου,
χρησιμοποιώντας
χρησιμοποιώντας τοντον ορισμό
ορισμό
gonia
χρησιμοποιώντας
χρησιμοποιώντας ένα
ένα μικρό
μικρό h.
h. Κατόπιν
Κατόπιν υπολογίστε
υπολογίστε την
την
παράσταση
παράσταση
metro ginomeno moires
35
για
για οποιοδήποτε
οποιοδήποτε xx ζητηθεί.
ζητηθεί. 36
Θα κατασκευάσουμε τρεις συναρτήσεις: double f ( double x )
{
• Για τη συνάρτηση f(x) return (x*x+2*x+6)/sqrt(1+x*x);
double f ( double x ) }
• Για την παράγωγο f'(x) double deriv ( double x )

{
double deriv ( double x ) double h;
• Για την παράσταση Φ if ( x == 0 )

double phi ( double x ) h = 1.0e-5;
else
h = 1.0e-5*x;
return (f(x+h)-f(x-h))/(2*h);
}
37 38
#include <iostream>
double phi ( double x ) #include <cmath>
{ using namespace std;
double fx, dx;
double f ( double );
fx = f(x); double deriv ( double );
dx = deriv(x); double phi ( double );
return (2*fx+dx)/(3*fx-dx);
} int main ( )
{
double x;
Γιατί δεν γράψαμε το παρακάτω ; cout << "Ποιό x ? ";

cin >> x;
return (2*f(x)+deriv(x))/(3*f(x)-deriv(x));
cout << phi(x) << endl;
}
39 40
Τοπικές και καθολικές μεταβλητές Δήλωση καθολικών μεταβλητών
• Κάθε συνάρτηση έχει τις δικές της μεταβλητές (τοπικές Οι καθολικές μεταβλητές δηλώνονται εκτός οποιασδήποτε
μεταβλητές). συνάρτησης.
• Οι τοπικές μεταβλητές ισχύουν μόνο μέσα στη συνάρτηση #include <iostream>

στην οποία δηλώθηκαν και για όσο λειτουργεί η using namespace std;
συνάρτηση.
double x, y, z; // Καθολικές μεταβλητές
• Όταν η συνάρτηση τερματίσει τη λειτουργία της οι τοπικές
μεταβλητές καταστρέφονται και χάνουν τα περιεχόμενά int main ( )
τους. {
• Μπορούμε να δηλώσουμε μεταβλητές που δεν ανήκουν σε }
καμία συνάρτηση (καθολικές μεταβλητές).
double add ( double a, double b )
• Οι καθολικές μεταβλητές μπορούν να χρησιμοποιηθούν {
από όλες τις συναρτήσεις και τα περιεχόμενά τους … εντολές …
παραμένουν καθ' όλη τη διάρκεια του προγράμματος. }
41 42
Καθολικές μεταβλητές Αναδρομικότητα

• Εάν υπάρχει σε μια συνάρτηση δηλωμένη τοπική • Μια συνάρτηση μπορεί να καλέσει το εαυτό της. Όταν
μεταβλητή με το ίδιο όνομα με κάποια καθολική συμβαίνει αυτό έχουμε μια αναδρομική κλήση της
μεταβλητή, τότε στη συνάρτηση αυτή χρησιμοποιείται η συνάρτησης.
τοπική και όχι η καθολική μεταβλητή.
• Αναδρομική κλήση μπορούμε να έχουμε όταν μια
• Κατά συνέπεια η συνάρτηση αυτή δεν μπορεί να έχει συνάρτηση καλέσει τον εαυτό της μέσω κάποιας άλλης
πρόσβαση στην αντίστοιχη καθολική μεταβλητή. συνάρτησης. Πχ
Η συνάρτηση a καλεί την b
• Με τη χρήση καθολικών μεταβλητών μπορούμε να
Η συνάρτηση b καλεί την c
δώσουμε μεταβιβάσουμε τιμές στις συναρτήσεις, κάτι
όμως που αν γίνεται συστηματικά οδηγεί σε δυσνόητα Η συνάρτηση c καλεί την a
προγράμματα με δυσκολία στην εκσφαλμάτωση. • Στην πραγματικότητα δεν καλείται πάλι η ίδια συνάρτηση,
αλλά ένα δεύτερο (ή τρίτο…) αντίγραφό της, το οποίο
δημιουργείται αυτόματα όταν χρειαστεί.
43 44
Κατασκευάστε τη
τη συνάρτηση
συνάρτηση Με τον παραδοσιακό (όχι αναδρομικό τρόπο)
int
int parag ( int nn ))
parag ( int
που
που θα
το nn παραγοντικό
παραγοντικό int parag ( int n )
{
int p, k;
p = 1;
for (k=2; k<=n; ++k)
p*=k;
return p;
}
45 46
Παράδειγμα #10 Υπερφόρτωση συναρτήσεων

• H C++ επιτρέπει τον ορισμό συναρτήσεων με το ίδιο
Χρησιμοποιώντας αναδρομικότητα:
όνομα, αλλά διαφορετικές παραμέτρους και λειτουργία,
Παρατηρούμε ότι n! = n (n-1)! στο ίδιο πρόγραμμα. Η τεχνική αυτή ονομάζεται
υπερφόρτωση συναρτήσεων.
int parag ( int n ) • Οι γνωστές μαθηματικές συναρτήσεις είναι ήδη
{ υπερφορτωμένες αφού μπορούν να κληθούν με ορίσματα
if ( n > 1 ) τύπου float ή double. Τα αντίστοιχα πρωτότυπα για την
sqrt θα ήταν:
return n*parag(n-1);
float sqrt ( float )
else double sqrt ( double )
return 1;
• Κατά την κλήση της συνάρτησης, ανάλογα με τον τύπο
}
των ορισμάτων ο μεταφραστής αποφασίζει ποια από τις
διαφορετικές εκδοχές της συνάρτησης θα καλέσει στην
47 πραγματικότητα. 48
Για την περίπτωση ακέραιων
συνάρτηση ηη οποία
οποία θα
υπολογίζει int mod ( int a, int b )
το
το υπόλοιπο της διαίρεσης του a από τον
υπόλοιπο της διαίρεσης του a από τον b.
b. Η
Η
{
return a % b;
συνάρτηση
συνάρτηση θα θα πρέπει
πρέπει να
να καλείται
καλείται είτε
είτε με
με ακέραια
ακέραια }
ορίσματα
ορίσματα ήή με
με πραγματικούς
πραγματικούς διπλής
διπλής ακρίβειας.
ακρίβειας.
Θα κατασκευάσουμε δύο διαφορετικές συναρτήσεις με το ίδιο

όνομα οι οποίες όμως θα δέχονται διαφορετικούς τύπους
παραμέτρων.
49 50
Παράδειγμα #11 Τελεστής αλλαγής τύπου

Για την περίπτωση πραγματικών διπλής ακρίβειας
• Mε τον τελεστή (τύπος) μπροστά από μια παράσταση
double mod ( double a, double b ) αλλάζουμε την παράσταση στον δεδομένο τύπο. Ο τύπος
{ μπορεί να είναι int, float, double, char κλπ.
int p;
double y; • Έτσι με τον τελεστή (int) αλλάζουμε μια παράσταση σε
ακέραια. Τα δεκαδικά ψηφία αποκόπτονται.
p = (int) (a/b); // Ακέραιο πηλίκο a/b
y = a - p*b; // Το υπόλοιπο • Η αλλαγή τύπου έχει υψηλότερη προτεραιότητα από τις
return y; πράξεις. Πχ.
} (int)x+0.5
είναι διαφορετικό από το
(int)(x+0.5)
• Όταν αλλάζουμε μια παράσταση σε κατώτερο τύπο (πχ.

από double σε float) χάνουμε σε ακρίβεια.
51 52
Το κυρίως πρόγραμμα
#include <iostream>
int mod ( int, int ); // Πρωτότυπα

double mod ( double, double );
int main ( )
{
int k;
double d;
k = mod(25,7); // Κλήση με ακέραιους

cout << k << endl;
d = mod(7.4,2.2); // Κλήση με double

cout << d << endl;
}
53
Τι περιλαμβάνει μια μεταβλητή;
• Πρώτα να δούμε τι ακριβώς συμπεριλαμβάνει μια μεταβλητή

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΔΕΙΚΤΕΣ
– τύπος
• Καθορίζει το μέγεθος στην μνήμη σε Bytes
– τιμή
ΔΕΙΚΤΕΣ • Η αριθμητική τιμή που αποθηκεύεται στην μνήμη
• Τι ξεχάσαμε; Το πού αποθηκεύεται στην μνήμη...

– διεύθυνση
• Κάθε μεταβλητή χαρακτηρίζεται από 3 ιδιότητες:

– τύπος, τιμή, διεύθυνση
1 2
Διεύθυνση μεταβλητής Δείκτης
• Η ανάθεση της διεύθυνσης μιας μεταβλητής γίνεται κατα την • Μεταβλητή που «δείχνει» σε κάποια θέση μνήμης
εκτέλεση. Ο χρήστης δεν γνωρίζει που αποθηκεύεται. • Συστατικά δείκτη
– Τύπος
• Μήπως όμως θα ‘πρεπε; • Καθορίζει τι τύπου μεταβλητή έχει αποθηκευθεί εκεί που
δείχνει (π.χ. int ή double)
• Η C++ μας δίνει την δυνατότητα να γνωρίζουμε την διεύθυνση – Τιμή
μιας μεταβλητής, και να χρησιμοποιήσουμε αυτή την γνώση για • Μια διεύθυνση μνήμης
καλύτερο προγραμματισμό.
– Λίστες, βάσεις δεδομένων, γραφικά, λειτουργικά συστήματα
• Για να έχει νόημα ένας δείκτης θα πρέπει να «δείχνει» σε
κάποια υπάρχουσα μεταβλητή
• Δείκτης: μια νέα μεταβλητή, που αντί για αριθμητικές τιμές,
αποθηκεύει διευθύνσεις μνήμης
3 4
Δήλωση δείκτη Ανάθεση τιμών σε δείκτη
• Αναθέτουμε σε δείκτη την διεύθυνση μιας μεταβλητής. Η
• Χρησιμοποιείται ο τελεστής αστέρι «*» μεταβλητή αυτή πρέπει:
– Δυστυχώς είναι το ίδιο με τον τελεστή πολλαπλασιασμού, οπότε – να υπάρχει
θέλει προσοχή – να είναι του ίδιου τύπου
• Δηλώνεται όπως και οι απλές μεταβλητές αλλά με το αστέρι
μπροστά • Η ανάθεση γίνεται με τον τελεστή «&»
Παράδειγμα: δηλώστε δύο ακέραιους και δύο δείκτες σε ακέραιους

Παράδειγμα: δηλώστε δύο ακέραιους και δύο δείκτες σε ακέραιους
Κατόπιν αναθέστε στους δείκτες τις διευθύνσεις των ακεραίων
int main(){ int main(){
int n, m; int n, m;
int *k, *j; int *k, *j;
.
. k = &n;
} j = &m;
5 6
}
Πράξεις με δείκτες Πράξεις με δείκτες

• Μια βασική λειτουργία/πράξη με δείκτες είναι: • Επιτρέπεται η απευθείας ανάθεση της διεύθυνσης ενός δείκτη
– ποια η τιμή της μεταβλητής εκεί πού δείχνει ένας δείκτης; σε άλλον δείκτη
– ...δηλαδή επιτρέπεται το «=»
• Ο τελεστής «*» χρησιμοποιείται για να μας δώσει την
αριθμητική τιμή στην θέση που δείχνει ο δείκτης
int main(){
int n, m;
int main(){ int *k, *j;
int n, m; n = 7; m = 8;
int *k, *j;
n = 7; m = 8; k = &n; j = k;
k = &n; j = &m; cout << *k << *j <<endl;

}
cout << *k << *j <<endl;
7 Τι αποτέλεσμα θα δώσει το παραπάνω; 8
}
Ανάθεση με δείκτες ΠΡΟΣΟΧΗ στην ανάθεση με δείκτες
• Μπορούμε να αναθέτουμε αριθμητική τιμή σε μεταβλητές Τα δύο παρακάτω μοιάζουν. Το ένα όμως είναι τραγικά λάθος.
– Απευθείας (όπως κάναμε μέχρι τώρα) Ποιο και γιατί;
– Μέσω δεικτών προς τις μεταβλητές αυτές
Τα δύο παρακάτω είναι ουσιαστικά ταυτόσημα
int n; int n;
int main(){ int main(){ int *k; int *k;
int n; int n;
int *k; int *k; k = &n; *k =7;
*k =7; k = &n;
k = &n; k = &n;
n = 7; *k =7; cout <<n<<*k<<endl; cout <<n<<*k<<endl;
} }
cout <<n<<*k<<endl; cout <<n<<*k<<endl;
Το δεύτερο: αναθέτει την τιμή 7 στην διεύθυνση όπου δείχνει ο δείκτης k,
} }
πριν όμως καθοριστεί το πού δείχνει ο k. Άρα κατά την εκτέλεση του *k =7,
9 10
το 7 θα αποθηκευτεί σε κάποια τυχαία θέση στην μνήμη... Πολύ κακό..!!
Παράδειγμα #1: Διάταξη μεταβλητών

Ανακεφαλαίωση: Τελεστές δεικτών και δεικτών στην μνήμη (1/3)
• Εισάγαμε δύο νέους τελεστές για δείκτες
– Τελεστής «*»
int main(){
• Κατά την δήλωση του τύπου επισημαίνει ότι είναι δείκτης
int n1, n2, n3;
• Μέσα στο πρόγραμμα σημαίνει: «δώσε την τιμή στην διεύθυνση που int *k1, *k2;
δείχνει ο δείκτης»
– Τελεστής «&» k1 = &n1; θέση Α1 Α2 Α3 Α4 Α5
• «δώσε την διεύθυνση της μεταβλητής» k2 = &n2; όνομα n1 n2 n3 k1 k2
n1 = 5; τιμή 5 10 15 A1 A2
*k = m; Βάλε την τιμή της m εκεί όπου δείχνει ο k *k2 = 10;
m = *k; Δώσε στην m την τιμή στην οποία δείχνει ο k n3 = 15;
.
k = &m; Δώσε στον k την διεύθυνση του m .
}
• Προτεραιότητα: Οι τελεστές * και & έχουν την υψηλότερη
προτεραιότητα, μετά τους ++, --, - 11 12
– εάν δεν είμαστε σίγουροι, χρησιμοποιούμε παρενθέσεις
Παράδειγμα #1: Διάταξη μεταβλητών Παράδειγμα #1: Διάταξη μεταβλητών
και δεικτών στην μνήμη (2/3) και δεικτών στην μνήμη (3/3)
. .
. .
θέση Α1 Α2 Α3 Α4 Α5 θέση Α1 Α2 Α3 Α4 Α5
*K1 = 1; όνομα n1 n2 n3 k1 k2 k1 = &n3; όνομα n1 n2 n3 k1 k2
*K2 = 2; τιμή 1 2 15 A1 A2 *K1 = 11; τιμή 1 2 11 A3 A2
. .
. .
} }
13 14
Παράδειγμα #2: βρείτε τις σωστές και

λάθος εκφράσεις
Δείκτες και πίνακες
#include <iostream> • Πολύ στενή σχέση
int main(){
• Τι είναι πίνακας;
double a1, a2;
double *b1, *b2; – Ομαδοποίηση μεταβλητών που καταλαμβάνουν διαδοχικές
a1,a2 θέσεις στην μνήμη
b1 = &a1; σωστή - -
b2 = &a2; σωστή - - • Στην C++ το όνομα του πίνακα (χωρίς τις αγκύλες) είναι ένας
*a1 = 33; λάθος: ο α1 δεν είναι δείκτης δείκτης προς την διεύθυνση του πρώτου στοιχείου
a1 = 22; σωστή 22 -
a2 = 20; σωστή 22 20 int main(){ int main(){
b2 = *a1; λάθος: το *α1 δεν έχει νόημα int n[10]; int n[10]; int *k;
b2 = a1; λάθος: ο b2 είναι δείκτης, o a1 μεταβλητή
b2 = 40; λάθος: ο b2 είναι δείκτης, οχι μεταβλητή n[0] = 100; k = n; (ή k = &n[0];)
b2 = b1; σωστή 22 20 . *k = 100;
*b2 = 40; σωστή 40 20 . .
*b1 = 30; σωστή 30 1520 } } 16
a2 = *b1; σωστή 30 30
Προσπέλαση πινάκων με δείκτες Ποιά η διαφορά δεικτών και πινάκων;
• Αφού γνωρίζουμε την διεύθυνση του πρώτου στοιχείου του • Πολύ μικρή. Στην πράξη, επιτρέπεται να χρησιμοποιούμε
πίνακα, μπορούμε να χρησιμοποιήσουμε μόνο δείκτες για την αγκύλες και στους δείκτες, σαν να ήταν πίνακες
προσπέλασή του;
int main(){
int n[10]; int m, *k;
• Στην C++ επιτρέπεται η αριθμητική δεικτών
– τo k+1 «δείχνει» στην δεύτερη θέση (4 bytes παρακάτω εαν k=n;
δείχνει σε ακέραιο), το k+2 στην τρίτη, κοκ n[2] = 300;
int n[10]; int n[10]; int *k; m = n[2];
m = *(k+2); ισοδύναμες εκφράσεις
n[0] = 100; k = n; m = k[2];
n[1] = 200; *k = 100; }
n[2] = 300; *(k+1) = 200;
. *(k+2) = 300; • Η μόνη ουσιαστική διαφορά δείκτη και πίνακα;
} } – Στον δείκτη επιτρέπεται να αλλάξει τιμή: π.χ. k=k+1;
17 – Στον πίνακα δεν επιτρέπεται: το n=n+1; είναι λάθος 18
Δηλαδή, το k+1 ≡ &n[1]; k+2 ≡ &n[2]; κτλ
Παράδειγμα #3: ανάθεση τιμών σε

πίνακα χρησιμοποιώντας δείκτες
Γράψτε κώδικα που εκτελεί το παρακάτω χρησιμοποιώντας
αποκλειστικά αριθμητική δεικτών

int main(){
int n[100];
for (int i=0; i<100; ++i) n[i] = 10 * i;
}
Λύση
int main(){
int n[100]; int *k;
k = n;
for (int i=0; i<100; ++i){
*k = 10 * i;
++k;
}
19
}
Κλήση συνάρτησης κατ’ αξία
ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΣΥΝΑΡΤΗΣΕΙΣ ΙΙ
• Μέχρι τώρα είδαμε την κλήση συνάρτησης «κατ’ αξία»
– Στην λίστα εισόδου μεταφέρονται μόνο οι τιμές των
μεταβλητών
Παράδειγμα: συνάρτηση που υπολογίζει το τετράγωνο αριθμού

ΣΥΝΑΡΤΗΣΕΙΣ ΙΙ
double square(double x){
x = x * x;
return x;
}
• Κατά την κλήση της συνάρτησης, δημιουργείται ένα αντίγραφο

του x, το οποίο περνάει μέσα στην συνάρτηση. Όταν η
συνάρτηση επιστρέφει στο κυρίως πρόγραμμα, το αντίγραφο
καταστρέφεται.
1 2
Κλήση συνάρτησης κατ’ αναφορά Δήλωση συνάρτησης

• Εναλλακτικός τρόπος κλήσης συνάρτησης είναι «κατ’ αναφορά»
– Στην λίστα εισόδου μεταφέρονται οι διευθύνσεις των • Στην γενική περίπτωση στην λίστα εισόδου έχουμε
μεταβλητών (δηλαδή δείκτες) μεταβλητές και δείκτες
Παράδειγμα: συνάρτηση που μετατρέπει έναν αριθμό στο τύπος όνομα(τύπος *δείκτης, τύπος μεταβλητή, …){
τετράγωνό του εντολές;
void square(double *x){ return …;
*x = (*x) * (*x); }
}
• Το πρωτότυπο της συνάρτησης δηλώνεται όπως και πρίν
τύπος όνομα(τύπος *δείκτης, τύπος μεταβλητή, …);

• Κατά την κλήση της συνάρτησης, μεταφέρεται η διεύθυνση του
x. Οποιαδήποτε αλλαγή στην τιμή του x παραμένει και όταν η
συνάρτηση επιστρέφει στο κυρίως πρόγραμμα.
3 4
Κλήση συνάρτησης Παράδειγμα #1: μετατροπή συντεταγμένων
• Εάν καλούμε μια συνάρτηση από το κυρίως πρόγραμμα η
συνάρτηση που μετατρέπει πολικές συντεταγμένες σε καρτεσιανές
οποία δέχεται δείκτες, τότε πρέπει στην είσοδο να δώσουμε
διευθύνσεις • Οι πολικές συντεταγμένες ορίζονται από την ακτίνα ρ και την
γωνία θ
Παράδειγμα: συνάρτηση που μετατρέπει έναν αριθμό
στο τετράγωνό του.
Οι καρτεσιανές συντεταγμένες
#include <iostream> square (&x); δίνονται συναρτήσει των πολικών:
using namespace std; cout <<“στο τετράγωνο
y
x = ρ cos(θ)
int main(){ είναι” << x <<endl; y = ρ sin(θ)
} ρ
void square(double *x);
int main(){ void square(double *x){ θ να γραφτεί η συνάρτηση η οποία

double x; *x = (*x) * (*x); να δέχεται δύο δείκτες (για την
cout << “δώσε έναν } x ακτίνα και την γωνία), και να τα
μετατρέπει σε καρτεσιανές
ρητό αριθμό” <<endl;
cin >> x; 5 6
Παράδειγμα #1: μετατροπή συντεταγμένων Παράδειγμα #2: Ανταλλαγή της τιμής

#include <iostream>
δύο μεταβλητών
void polar_to_cartesian(double *r, double *t);
int main(){ Η συνάρτηση να δέχεται δύο ρητούς και να ανταλλάσσει τις τιμές
double r, t; τους
cout << “δώσε πολικές συντεταγμένες” << endl; (θα μας χρειαστεί αργότερα για ταξινόμηση)
cin >> r >> t;
void swap(double *x, double *y){
polar_to_cartesian(&r, &t); double z = *x ;
cout << “σε καρτεσιανές είναι” << r << t << endl; *x = *y ;
} *y = z ;
}
void polar_to_cartesian(double *r, double *t){
double x = (*r) * cos(*t);
double y = (*r) * sin(*t);
*r = x; *t = y;
}
7 8
Συνάρτηση που δέχεται πίνακες Παράδειγμα #3: Μέγιστο πίνακα
• Για να περάσουμε έναν πίνακα σε μια συνάρτηση αρκεί να double xmax (double *x, int n){
περάσουμε: double m = x[0];
– την διεύθυνση του πρώτου στοιχείου (δηλαδή δείκτης) for (int i = 1; i < n; ++i)
– το πλήθος των στοιχείων του πίνακα (δηλαδή ακέραιος) if(x[i] > m) m = x[i];
• εάν είναι πολυδιάστατος, τότε περνάμε τα ανάλογα πλήθη return m;
}
• Μέσα στην συνάρτηση χρησιμοποιούμε αριθμητική δεικτών και ένα πρόγραμμα που το καλεί
για να προσπελάσουμε όλα τα στοιχεία του πίνακα
#include <iostream>
– Υπενθυμίζεται ότι το *(k+i) και το k[i] είναι ταυτόσημα
double xmax(double *x, int n);
• Για παράδειγμα, για να περάσουμε έναν πίνακα ρητών x με n int main(){
στοιχεία, η συνάρτηση θα δηλωθεί ως int n; double x[1000];
τύπος όνομα (double *x, int n){ cout << “πόσα στοιχεία θα εισάγετε” << endl;
εντολές; cin >> n;
return …; for (int i=0; i<n; ++i) cin >> x[i];
} cout << “το μέγιστο είναι” << xmax(x, n); << endl;
9 } 10
Παράδειγμα #4: μέσος όρος στοιχείων Παράδειγμα #5: εσωτερικό γινόμενο

πίνακα δύο πινάκων
Ορίστε συνάρτηση που γυρνάει τον Ορίστε συνάρτηση που δέχεται δύο πίνακες (και το πλήθος των
μέσο όρο των στοιχείων ενός πίνακα στοιχείων τους) και επιστρέφει το εσωτερικό τους γινόμενο
έστω πίνακες x[i] και y[i], με i=0, 1, 2, … n-1
To εσωτερικό γινόμενο P:
double average (double *x, int n){
i <n
if (n == 0) return 0; P = ∑ x [i ] * y [i ]
i =0
double s = 0 ;
for (int i = 0 ; i<n ; i++) s += x[i];
double array_product (double *x, double *y, int n){
return s/n ;
double p = 0;
}
for (int i = 0; i < n; ++i) p += x[i] * y[i];
return p;
}
11 12
Παράδειγμα #6: σύστημα n σωματιδίων Παράδειγμα #7: σύστημα n σωματιδίων
Έστω σύστημα n σωματιδίων, με τις συντεταγμένες τους Έστω σύστημα n σωματιδίων, με τις συντεταγμένες τους
αποθηκευμένες σε τρεις πίνακες: x, y, z. Γράψτε συνάρτηση που αποθηκευμένες σε τρεις πίνακες: x, y, z. Γράψτε συνάρτηση που
δέχεται τους τρεις πίνακες και έναν ακέραιο i, έτσι ώστε να δέχεται τους τρεις πίνακες, το πλήθος των στοιχείων τους n, και
υπολογίζει την απόσταση του σωματιδίου i από την αρχή των έναν ακέραιο i, έτσι ώστε να υπολογίζει την μέση απόσταση του
αξόνων σωματιδίου i απο τα άλλα σωματίδια.
double dist_ave (double *x, double *y, double *z, int n, int i){
double dist (double *x, double *y, double *z, int i){
double d = sqrt(x[i]*x[i] + y[i]*y[i] + z[i]*z[i]); if (n < 2) return 0;
return d;
} double s = 0;
for (int j = 0; j<n; ++j)
if (j != i)
s += sqrt( pow(x[i]-x[j], 2) +
pow(y[i]-y[j], 2) + pow(z[i]-z[j], 2) );
return s/(n-1);
13 } 14
πέρα απο απλές μεταβλητές...
• Μέχρι εδώ έχουμε δεί δύο τύπους μεταβλητών:

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΔΟΜΕΣ
– int (ακέραιος, 4 bytes)
– double (ρητός διπλής ακρίβειας, 8 bytes)
• Σε πολλά προβλήματα χρειαζόμαστε πάνω απο μια μεταβλητή για

ΔΟΜΕΣ να καθορίσουμε ένα μέγεθος. Π.χ.
– δίανυσμα (3 ρητοί: x, y, z)
– μιγαδικός (2 ρητοί: real, imaginary)
– άτομο (5 ρητοί: x, y, z, m, q)
• Πράξεις με αυτά τα μεγέθη σημαίνει

– Πράξεις με πολλές μεταβλητές
– το αποτέλεσμα εμπεριέχει πολλές μεταβλητές
1
• Είναι βολικό να δημιουργήσουμε νέες, πολυσύνθετες μεταβλητές
2
Ορισμός δομής Παράδειγμα #1: διάνυσμα

struct vector{
• Νέου τύπου μεταβλητή:
double x;
– Ορίζεται απο τον προγραμματιστή double y;
– Εμπεριέχει οποιοδήποτε αριθμό και συνδιασμό άλλων double z;
μεταβλητών διαφόρων τύπων };
• Στο «όνομα» χρησιμοποιούμε κάτι που είναι περιγραφικό.
• Στην δήλωση μιας δομής χρησιμοποιείται η δευσμευμένη λέξη
της C++: struct • Επιλέξαμε «vector». Στο εξής, το vector καθιστά νέο τύπο
– δηλαδή, στο εξή υπάρχουν: int, double, vector
• Γενικός τρόπος δήλωσης
• Μέσα στο σώμα της δομής, ορίζουμε τα μέλη της δομής
struct όνομα{
τύπος μεταβλητή1 ; – τύπο και όνομα
τύπος μεταβλητή2 ; – χρησιμοποιούμε ονόματα που είναι περιγραφικά
. – για τις x,y,z συνιστώσες, χρησιμοποιούμε απλά x, y, z.
.
3
}; • Ο ορισμός δομής είναι εντολή, άρα τελειώνει με ερωτηματικό 4
Δήλωση μεταβλητών δομής Προσπέλαση μελών δομής
• Πράξεις επιτρέπονται μόνο μεταξύ απλών μεταβλητών
• Ο ορισμός της δομής γίνεται πρίν την main. – δηλαδή μεταξύ των μελών της δομής
• Στο κυρίως πρόγραμμα δηλώνουμε μια μεταβλητή δομής
όπως και στις απλές μεταβλητές • Πως όμως φτάνουμε στα απλά μέλη της δομής;
– Π.χ. Για να δηλώσουμε δύο διανύσματα: – χρησιμοποιούμε τον τελεστή της τελείας «.»
#include <iostream> – χρησιμοποιούμε τα ίδια σύμβολα με αυτά που ορίσαμε
using namespace std; • Π.χ. για ανάθεση τιμών σε διάνυσμα
struct vector { #include <iostream>

double x, y, z; using namespace std;
};
struct vector {double x, y, z;};
vector v, u; vector v, u;
. v.x = 3.0; v.y = 4.0; v.z = 5.0;
. u.x = 11.0; u.y = 12.0; u.z = 13.0;
5 6
} }
Είσοδος/έξοδος τιμών δομής Πράξεις μεταξύ δομών
• Μπορούμε να εισάγουμε και κατευθείαν απο το πληκτρολόγιο • Μόνο η πράξη «=» επιτρέπεται μεταξύ μεταβλητών της ίδιας δομής.
Παράδειγμα: – γίνεται μια προς μια αντιγραφή των μελών της μιας στην άλλη
cout<<“εισάγετε τις συνιστώσες διανύσματος”<< endl; cin >> v.x >> v.y >> v.z;
cin >> v.x >> v.y >> v.z; u = v;
cout << u.x <<“ “<< u.y <<“ “<< u.z << endl;
• Μπορούμε να εξάγουμε τιμές στην οθόνη
• Στην πράξη, αυτό που εκτελείται είναι
cout<<“οι συνιστώσες του διανύσματος είναι”<< endl; cin >> v.x >> v.y >> v.z;
cout << u.x <<“ “<< u.y <<“ “<< u.z << endl; u.x = v.x;
u.y = v.y;
u.z = v.z;
ΠΡΟΣΟΧΗ: οι συναρτήσεις cout και cin δέχονται μόνο απλές cout << u.x <<“ “<< u.y <<“ “<< u.z << endl;
μεταβλητές, ΟΧΙ δομές. Τα παρακάτω είναι ΛΑΘΟΣ:
cin >> v;
Cout << u; 7 • Καμία άλλη πράξη, π.χ. «+, -, *, /» δεν επιτρέπεται 8
Παράδειγμα #1: πρόσθεση
διανυσμάτων Άλλα παραδείγματα δομών
#include <iostream> • Σύμβολα και ονοματολογία είναι επιλογή του προγραμματιστή.

using namespace std; • Σημαντικό να περιγράφουν το μέγεθος στο οποίο αντιστοιχούν
struct vector {double x, y, z;}; struct complex{

int main(){ – Δομή για μιγαδικούς double real, imag;
vector v, u, w; };
cout <<“εισάγετε συνιστώσες 2 διανυσμάτων”<< endl; struct ion{
cin >> v.x >> v.y >> v.z; – Δομή για ιόντα double x, y, z, m, q;
cin >> u.x >> u.y >> u.z; };
w.x = v.x + u.x;
w.y = v.y + u.y; – Δομή για προϊόντα σε αποθήκη, που περιλαμβάνει κωδικό
w.z = v.z + u.z; προϊόντος, έτος κατασκευής, τιμή πώλησης
struct item{
cout <<“οι συνιστώσες του αθροίσματος είναι”<< endl; int code, year;
cout << w.x <<“ “<< w.y <<“ “<< w.z << endl; double price;
9 10
} };
Παράδειγμα #2: μέσος όρος του

Πίνακες δομών μέτρου διανυσμάτων (1/2)
• Όταν ορίζουμε μια δομή, ορίζουμε μια νέου τύπου μεταβλητή Πρόγραμμα που διαβάζει n διανύσματα, και υπολογίζει τον μέσο
όρο των μέτρων τους
• Όπως και στις απλές μεταβλητές, μπορούμε να ορίσουμε #include <iostream>
πίνακα απο τις νέες μεταβητές using namespace std;
• Η προσπέλαση γίνεται πάλι με την τελεία, αμέσως μετά την struct vector {double x, y, z;};
δεικτοδότηση του πίνακα
int main(){
int n; vector v[1000];
• Παράδειγμα: δήλωση πίνακα με 1000 διανύσματα cout << "εισάγετε τον αριθμό διανυσμάτων“ << endl;
int main(){ cin >> n;
vector v[1000];
v[0].x = 3.0; v[0].y = 4.0; v[0].z = 5.0; if(n==0) cout << ”ο μέσος όρος είναι 0” << endl;
v[1].x = 3.0; v[1].y = 4.0; v[1].z = 5.0; else if (n > 1000) cout << “πιό λίγα διανύσματα” <<endl;
. else {
. for (int i=0; i<n; ++i)
11 12
} cin >> v[i].x >> v[i].y >> v[i].z;
Παράδειγμα #2: μέσος όρος του
μέτρου διανυσμάτων (2/2)
Δομές μέσα σε δομές
• Μια δομή συνιστά μια νέα μεταβλητή

double s = 0;
• Με την σειρά της, μια δομή μπορεί να αποτελέσει μέλος μιας
for (int i=0; i<n; ++i) πιο σύνθετης δομής.
s += sqrt(v[i].x * v[i].x + – Παράδειγμα: ιόν με θέση, μάζα και φορτίο
v[i].y * v[i].y +
v[i].z * v[i].z); struct vector {
double x, y, z;
cout << ”ο μέσος όρος είναι” << s/n << “\n”; };
}
} struct ion{
vector r;
double m, q;
};
13 • Διαδοχική προσπέλαση γίνεται με διαδοχικές τελείες 14
Παράδειγμα #3: Δομή για ιόντα (1/2) Παράδειγμα #3: Δομή για ιόντα (2/2)
if (n < 1 || n > 1000) return 1;
Πρόγραμμα που διαβάζει n ιόντα, και υπολογίζει τη συνολική μάζα
και φορτίο, και τη μέση απόσταση απο την αρχή των αξόνων for (int i=0; i<n; ++i)
#include <iostream> cin >> a[i].r.x >> a[i].r.y >> a[i].r.z >>
using namespace std; a[i].m >> a[i].q;
struct vector { double x, y, z; }; double sm = 0; double sq = 0; double sd = 0;

for (int i=0; i<n; ++i){
struct ion { vector r; double m, q; }; sm += a[i].m;
sq += a[i].q;
sd += sqrt(v[i].r.x * v[i].r.x +
int main(){ v[i].r.y * v[i].r.y +
int n; ion a[1000]; v[i].r.z * v[i].r.z);}
cout << "εισάγετε τον αριθμό των ιόντων“ << endl; cout << ”η συνολική μάζα είναι” << sm << endl;
cin >> n; cout << ”το συνολικό φορτίο είναι” << sq << endl;
15
cout << ”η μέση απόσταση είναι” << sd/n << endl; 16
}
Παράδειγμα #4: πράξεις με μιγαδικούς
Παράδειγμα #4: πράξεις με μιγαδικούς (1/2)
Πρόγραμμα που διαβάζει δύο μιγαδικούς, και τυπώνει το #include <iostream>
άθροισμα, την διαφορά, και το γινόμενό τους using namespace std;
z~1 = z 1r + iz 1i struct complex { double real, imag; };
z~2 = z 2r + iz 2i int main(){

complex z1, z2, zsum, zdif, zprod;
cout << "εισάγετε δύο μιγαδικούς“ << endl;

z~1 + z~2 = (z 1r + z 2r ) + i (z 1i + iz 2i ) cin >> z1.real >> z1.imag;
cin >> z2.real >> z2.imag;
z~1 − z~2 = (z 1r − z 2 r ) + i (z 1i − iz 2i )
zsum.real = z1.real + z2.real;
zsum.imag = z1.imag + z2.imag;
z~1 ⋅ z~2 = (z 1r + iz 1i ) ⋅ (z 2r + iz 2i ) = zdif.real = z1.real – z2.real;
( z 1r z 2 r − z 1i z 2 i ) + i ( z 1r z 2 i + z 1i z 2 r ) 17 zdif.imag = z1.imag – z2.imag; 18
Παράδειγμα #4: πράξεις με μιγαδικούς

(2/2)
Γιατί δεν επιτρέπονται άλλες πράξεις;
• Ανάλογα το φυσικό πρόβλημα που επιλύουμε, μια πράξη
μπορεί να έχει διαφορετικό νόημα
zprod.real = z1.real*z2.real - z1.imag*z2.imag;
• Παράδειγμα, ο πολλαπλασιασμός:
zprod.imag = z1.real*z2.imag + z1.imag*z2.real;
– Σε διανύσματα, το εσωτερικό γινόμενο είναι ρητός
r r
cout << “το άθροισμα είναι” << endl;
cout << zsum.real << “ ” << zsum.imag << endl;
a ⋅ b = a x b x + a y b y + a z b z = ρητός αριθμός
cout << “η διαφορά είναι” << endl; – Σε μιγαδικούς, το γινόμενο είναι μιγαδικός
z~1 ⋅ z~2 = (z 1r + iz 1i ) ⋅ (z 2r + iz 2 i ) =
cout << zdif.real << “ ” << zdif.imag << endl;
cout << “το γινόμενο είναι” << endl;

cout << zprod.real << “ ” << zprod.imag <<
(z 1r z 2 r − z 1i z 2 i ) + i (z 1r z 2 i + z 1i z 2 r ) = μιγαδικός
endl;
• Στην C++ ο χρήστης μπορεί να «προγραμματίσει» τις πράξεις
μεταξύ μεταβλητών δομής.
}
– Με χρήση συναρτήσεων
19 – Με ολοκληρωμένο ορισμό αντικειμένων (τάξεις) 20
Παράδειγμα #5: συναρτήσεις για πρόσθεση
Συναρτήσεις με δομές και αφαίρεση και γινόμενο διανυσμάτων
vector sum (vector v, vector u){
• Ορισμός, δήλωση και κλήση μιας συνάρτησης με δομές γίνεται vector w;
όπως και με τις απλές μεταβλητές w.x = v.x + u.x;
– Στην λίστα εισόδου μπορούμε να έχουμε δομές w.y = v.y + u.y;
– Στην έξοδο μπορούμε να έχουμε δομή w.z = v.z + u.z;
– Οι πράξεις μέσα στην συνάρτηση γίνονται όπως είδαμε πριν με return w;
τον τελεστή της τελείας «.» }
vector dif (vector v, vector u){
• Παράδειγμα: συνάρτηση που υπολογίζει το μέτρο διανύσματος vector w;
w.x = v.x - u.x;
double magnitude (vector v){ w.y = v.y - u.y;
double d = sqrt(v.x*v.x + v.y*v.y + v.z*v.z); w.z = v.z - u.z;
return d; return w;
} }
double product (vector v, vector u){
21 return v.x*u.x + v.y*u.y + v.z*u.z; 22
}
Υπερφόρτωση συναρτήσεων: Παράδειγμα #6: Πλήρες πρόγραμμα για

πολυμορφισμός πράξεις με διανύσματα (1/2)
• Μπορούμε να γράψουμε μια βιβλιοθήκη με συναρτήσεις για κάθε Πρόγραμμα που διαβάζει δύο διανύσματα, και τυπώνει το μέτρο
είδους μεταβλητής double sum (double x, double y){ του καθενός, το μέτρο του αθροίσματος, το μέτρο της διαφοράς,
– μια απλούς ρητούς return x + y; καθώς και και το εσωτερικό τους γινόμενο.
} #include <iostream>
complex sum (complex z1, complex z2){
complex z3;
struct vector {double x, y, z;};
z3.real = z1.real + z2.real;
– για μιγαδικούς
z3.imag = z1.imag + z2.imag;
vector sum (vector, vector);
return z3;
vector dif (vector, vector);
}
double product (vector, vector);
vector sum (vector v, vector u){ double magnitude (vector);
vector w;
w.x = v.x + u.x; int main(){
– για διανύσματα w.y = v.y + u.y; vector v, u;
w.z = v.z + u.z; cout <<“εισάγετε συνιστώσες 2 διανυσμάτων”<< endl;
return w; 23 cin >> v.x >> v.y >> v.z; 24
} cin >> u.x >> u.y >> u.z;
Παράδειγμα #6: Πλήρες πρόγραμμα για Μια συνάρτηση μπορεί να καλεί άλλη
πράξεις με διανύσματα (2/2) συνάρτηση
Παράδειγμα: συνάρτηση που υπολογίζει τη γωνία μεταξύ δύο
r
cout << “τα μέτρα των διανυσμάτων είναι” << endl;
r r r r ⎛ ar ⋅b ⎞
cout << magnitude(v) <<“ ” << magnitude(u) << endl; a ⋅b =| a | ⋅ | b | ⋅ cos θ ⇒ θ = a cos⎜⎜ r r ⎟⎟
cout << “το μέτρο του αθροίσματος είναι” << endl; ⎝ | a | ⋅ |b | ⎠
cout << magnitude( sum(v, u) ); double angle (vector a, vector b){
double theta, m1, m2;
cout << “το μέτρο της διαφοράς είναι” << endl; m1 = magnitude(a);
cout << magnitude( dif(v, u) ); m2 = magnitude(b);
cout << “το γινόμενο είναι” << endl; if (m1 == 0 || m2 == 0) theta = 0;

cout << product(v, u); else if (m1*m2 == 0) theta = 90;
else theta = acos( product(a,b)/(m1*m2) )*
} 180/acos(-1.0);
25 return theta; 26
}
Δείκτες σε δομές Εισαγωγή πίνακα δομής σε συνάρτηση
• Όπως και στην περίπτωση των πινάκων απλών μεταβλητών,

• Όπως και στις απλές μεταβλητές, μπορούμε να δηλώσουμε δείκτη
ένας πίνακας δομής εισέρχεται ώς δείκτης
σε μεταβλητή δομής χρησιμοποιώντας τον τελεστή αστέρι «*».
– Παράδειγμα: μέσος όρος των μέτρων ενός πίνακα
– Ο δείκτης είναι η διεύθυνση του πρώτου στοιχείου της δομής
– παράδειγμα, δείκτης σε διάνυσμα
struct vector { double x, y, z; }; double ave_magn(vector *v, int n){
int main(){ double s = 0;

vector v, *p; for (int i=0; i<n; ++i)
s += sqrt(v[i].x * v[i].x +
// ανάθεση διεύθυνσης v[i].y * v[i].y +
p = &v; v[i].z * v[i].z);
.
. return s/n;
} }
27 28
Παράδειγμα #7: μέσος όρος μέτρων
Παράδειγμα #8: ιόντα
Πλήρες πρόγραμμα που υπολογίζει τον μέσο όρο των μέτρων ενός Πρόγραμμα που διαβάζει n ιόντα και υπολογίζει το κέντρο μάζας,
πίνακα διανυσμάτων την ολική ηλεκτροστατική ενέργεια, και την δύναμη που ασκείται
#include <iostream> σε κάθε ιόν
#include <cmath>
using namespace std; • Θα χρειαστούμε:
struct vector {double x, y, z;}; – Την δομή για ιόντα
double ave_magn(vector *, int); – Συνάρτηση για κέντρο μάζας
– Συνάρτηση για απόσταση δύο ιόντων
int main(){
– Συνάρτηση για ηλεκτροστατική ενέργεια ενός ιόντος
int n; vector v[1000];
cout << "εισάγετε τον αριθμό διανυσμάτων“ << endl; – Συνάρτηση για την συνολική δύναμη που νοιώθει ένα ιόν
cin >> n;
n −1 qq n −1 q i q j (x j − x i )
E j = ∑ r i jr F jx = ∑
if(n==0 || n>1000) return 1;
for (int i=0; i<n; ++i) cin>>v[i].x>>v[i].y>>v[i].z; r r
i =0 | r j − ri | i =0 | r j − ri |3
cout << ave_magn(v, n) <<endl; i≠j i≠j
29 30
}
Παράδειγμα #8: συναρήσεις για ιόντα Παράδειγμα #8: συναρήσεις για ιόντα
(1/5) (2/5)
• Συνάρτηση για κέντρο μάζας
μx =
∑i x i m i
• Δομή για ιόντα
∑i m i
vector centermass (ion *a, int n){
vector cm; double m;
struct vector { double x, y, z; };
struct ion { vector r; double m, q; }; cm.x = cm.y = cm.z = m = 0;
cm.x += a[i].r.x * a[i].m;
• Συνάρτηση για κέντρο μάζας cm.y += a[i].r.y * a[i].m;
– Το κέντρο μάζας έχει x, y, z συντεταγμένες ⇒ vector cm.z += a[i].r.z * a[i].m;
m += a[i].m;
– Στην είσοδο δέχεται πίνακα με ιόντα
}
– Υπολογίζει και τις τρεις συνιστώσες cm.x = cm.x / m;
cm.y = cm.y / m;
μx =
∑i x i mi , ... και παρόμοια για μ , μ cm.z = cm.z / m;
∑i m i
y z
return cm;
31 32
}
Παράδειγμα #8: συναρήσεις για ιόντα Παράδειγμα #8: συναρήσεις για ιόντα
(3/5) (4/5)
• Συνάρτηση για απόσταση δύο διανυσμάτων r r • Συνάρτηση για ηλεκτροστατική ενέργεια ενός ιόντος
d =| v − u |
double dist (vector v, vector u){ n −1 q q
Ej =∑ r r
i j
return sqrt( pow(v.x-u.x, 2) +
pow(v.y-u.y, 2) + i =0 | r j − ri |
pow(v.z-u.z, 2)); i≠j
}
double energy (ion *a, int n, int j){
• ή με τις συναρτήσεις dif και magnitude double e = 0;
double dist (vector v, vector u){ for (int i=0; i<n; ++i) if(i != j)
return magnitude( dif(v, u) ); e += a[i].q * a[j].q / dist(a[j].r, a[i].r);
}
return e;
}
33 34
Παράδειγμα #8: συναρήσεις για ιόντα Παράδειγμα #8: πρόγραμμα για ιόντα
(5/5) n −1 q q ( x − x ) (1/3)
Fj = ∑
x i j j i
• Hλεκτροστατική δύναμη πάνω σε ιόν r r
i =0 | r j − ri |3 • Πλήρες πρόγραμμα για ιόντα
vector force (ion *a, int n, int j){ i≠j
vector f, fi; #include <iostream>
f.x = f.y = f.z = 0; #include <cmath>
for (int i=0; i<n; ++i) if(i != j){ using namespace std;
fi.x = a[i].q*a[j].q * (a[j].r.x - a[i].r.x)/
pow( dist(a[j].r, a[i].r), 3); struct vector { double x, y, z; };
struct ion { vector r; double m, q; };
fi.y = a[i].q*a[j].q * (a[j].r.y - a[i].r.y)/
pow( dist(a[j].r, a[i].r), 3); vector sum (vector, vector);
vector dif (vector, vector);
fi.z = a[i].q*a[j].q * (a[j].r.z - a[i].r.z)/ double magnitude (vector);
pow( dist(a[j].r, a[i].r), 3); double dist (vector, vector);
f = sum(f, fi); vector centermass (ion *, int);

} double energy (ion *, int, int);
return f; 35
vector force (ion *, int, int); 36
} συνεχίζεται...
Παράδειγμα #8: πρόγραμμα για ιόντα Παράδειγμα #8: πρόγραμμα για ιόντα
(2/3) (3/3)
int main(){
int n; ion a[1000];
vector f, m;
cout << "εισάγετε τον αριθμό των ιόντων“ << endl;
cout << “το ιόν” << i << “έχει ενέργεια” <<endl;
cin >> n; cout << energy(a, n, i);
if (n < 1 || n > 1000) return 1; f = force(a, n, i);
cout << “και υφίσταται δύναμη” << endl;
for (int i=0; i<n; ++i) cout << f.x <<“ ”<< f.y <<“ ”<< f.z << endl;
cin >> a[i].r.x >> a[i].r.y >> a[i].r.z >> }
a[i].m >> a[i].q; }
m = centermass(a, n);
cout << “το κέντρο μάζας έχει συντεταγμένες” <<endl;
cout << m.x <<“ ”<< m.y <<“ ”<< m.z <<endl;
37 38
συνεχίζεται...
Παράδειγμα #9: μοριακή δυναμική:

Παράδειγμα #9: μοριακή δυναμική
εξισώσεις κίνησης
• Έχουμε χτίσει όλη τη βάση ώστε να δημιουργήσουμε έναν • Ολοκλήρωση εξισώσεων κίνησης:
κώδικα μοριακής δυναμικής: – Ανάπτυγμα Taylor για την απόσταση
– ιόντα, λόγω των μεταξύ τους δυνάμεων εκτελούν τροχιές r r r 1r
στον χώρο r (t + Δt ) = r (t ) + v (t )Δt + a (t )( Δt )2
• Χρειαζόμαστε για κάθε ιόν: 2
– Θέση (διάνυσμα)
– Μάζα (ρητός) – Ανάπτυγμα για την ταχύτητα
– Φορτίο (ρητός) r r r
– Ταχύτητα (διάνυσμα) v (t + Δt ) = v (t ) + a (t )Δt
– Επιτάχυνση (διάνυσμα)
• Η πλήρης δομή για ένα ιόν – ΣΗΜΕΙΩΣΗ: εφαρμόζοντας αυτούς τους τύπους επιτυγχάνουμε
λύση με ακρίβεια πρώτης τάξης, όχι ικανοποιητική. Με μικρή
struct vector { double x, y, z; }; τροποποίηση μπορούμε να επιτύχουμε ακρίβεια δεύτερης
struct ion { vector r, vel, acc; double m, q; };
39 τάξης, αλλά δεν είναι επι του παρόντως. 40
συνάρτηση για πολλαπλασιασμό
η στιγμιαία επιτάχυνση σε κάθε ιόν
διανύσματος με ρητό
r
Θα χρειαστεί να πολλαπλασιάσουμε διάνυσμα με ρητό. Π.χ. v ⋅ dt Χρειαζόμαστε μια συνάρτηση για να υπολογίζει την στιγμιαία
Χρειαζόμαστε μια συνάρτηση για να το κάνει αυτό επιτάχυνση σε κάθε ιόν
vector mult(vector r, double f){ ⎧x → x ⋅ f
r.x *= f; r.y *= f; r.z *= f; r ⎪ r
r ⋅ f ⇒ ⎨y → y ⋅ f r
}
return r;
⎪ z → z ⋅f a i = f i / mi
⎩
Υπάρχει πάντα η πιθανότητα κάποιος να την καλέσει λάθος, εισάγοντας πρώτα void acceleration (ion *a, int n){
τον ρητό και μετά το διάνυσμα. Για να μην προκαλέσει λάθος αυτό, μπορούμε
να υπερφορτώσουμε την συνάρτηση δηλώνοντάς την δεύτερη φορά. for (int i=0; i<n; ++i)
a[i].acc = mult( force(a,n,i), 1.0/a[i].m);
vector mult(double f, vector r){
r.x *= f; r.y *= f; r.z *= f; }
return r;
}
41 42
Τώρα όπως και να την καλέσει κανείς, είναι σωστό!
Παράδειγμα #9: μοριακή δυναμική: Παράδειγμα #9: μοριακή δυναμική:

ανανέωση ταχύτητας κάθε ιόντος ανανέωση θέσης κάθε ιόντος
Χρειαζόμαστε μια συνάρτηση για να υπολογίζει την νέα ταχύτητα Χρειαζόμαστε μια συνάρτηση για να υπολογίζει την νέα θέση του
του κάθε ιόντος κάθε ιόντος
r r r 1r
r r r r (t + Δt ) = r (t ) + v (t )Δt + a (t )( Δt )2
v (t + Δt ) = v (t ) + a (t )Δt 2
void position (ion *a, int n, double dt){
void velocity (ion *a, int n, double dt){
vector r1 = mult( a[i].vel , dt);
vector v1 = mult( a[i].acc, dt ); vector r2 = mult( a[i].acc , 0.5*dt*dt);
a[i].vel = sum( a[i].vel, v1 ); a[i].r = sum( a[i].r, sum(r1, r2));

} }
} 43 44
}
Δείκτες σε δομές: Μια προσεκτικότερη
Παράδειγμα #9: μοριακή δυναμική
ματιά: ανάθεση τιμών μέσω δείκτη
Έχοντας δώσει αρχικές τιμές σε θέση, μάζα και φορτίο, το κυρίως
• Χρησιμοποιούμε και πάλι το αστέρι και την τελεία
πρόγραμμα όσο αναφορά την δυναμική εξέλιξη του συστήματος
των ιόντων είναι πολύ απλό: – Επειδή η τελεία έχει μεγαλύτερη προτεραιότητα, απαραίτητες
είναι οι παρενθέσεις
int main(){ vector v, *p;
int n, nsteps; p = &v;
ion a[1000]; cin >> (*p).x >> (*p).y >> (*p).z;
double dt;
το *(p.x) όπως και το p.x δεν έχουν νόημα καθώς το p είναι δείκτης
.
.
for (int j=0; j<nsteps; ++j){ • Πιο συμπαγής συμβολισμός
acceleration (a, n); – η C++ μας προσφέρει έναν πιο συμπαγή συμβολισμό με τον
position (a, n, dt); τελεστή του βέλους «->»
velocity (a, n, dt);
vector v, *p;
}
p = &v;
.
cin >> p->x >> p->y >> p->z;
. 45 46
} – Το βέλος «δείχνει» στα «συστατικά» της δομής
Δείκτες όταν έχουμε δομές μέσα σε δομές Χρησιμότητα δεικτών σε δομές

• Για πρόσβαση σε αριθμητικές τιμής μέσω δείκτη, • Πολλές δομές μπορεί να είναι μεγάλες. Τότε, εάν εισέρχονται σε
χρησιμοποιούμε το βέλος για το πρώτο «επίπεδο», και συνάρτηση, η δημιουργία αντιγράφων μπορεί να είναι χρονοβόρα.
κατόπιν την τελεία, όσες φορές χρειαστεί.
– Λύση είναι να εισάγουμε έναν δείκτη προς την δομή
struct vector { double x, y, z; }; – Παράδειγμα, η συνάρτηση sum για πρόσθεση δύο διανυσμάτων
struct ion { vector r; double m, q; };
int main(){ vector sum (vector *v, vector *u){
ion a, *p; vector w;
w.x = v->x + u->x;
p = &a; w.y = v->y + u->y;
p->r.x = 3.0; w.z = v->z + u->z;
p->r.y = 4.0; return w;
p->r.z = 5.0; }
p->m = 6.0;
p->q = 7.0; – Στο κυρίως πρόγραμμα θα καλεστεί
. int main(){
. vector v, u, w;
47 48
} w = sum (&v, &u);
Πίνακας δομής και δείκτες
• Όπως και στην περίπτωση των απλών μεταβλητών, ένας πίνακας
έχει πολλά κοινά με έναν δείκτη
– Το όνομα του πίνακα είναι δείκτης στο πρώτο του στοιχείο

– Ισχύει η αριθμητική δεικτών
Παράδειγμα, πίνακας διανυσμάτων

struct vector { double x, y, z; };
int main(){
vector v[1000]; vector *p;
p = v;
ταυτόσημα
p = &v[0];
v[2].x = 3;
(p+2)->x = 3; ταυτόσημα
49
p[2].x = 3;
πέρα απο απλές δομές...
• Στο προηγούμενο κεφάλαιο γενικεύσαμε τις μεταβλητές

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΑΞΕΙΣ
– Δομές: σύνθετες μεταβλητές
– Συναρτήσεις που δέχονται και επιστρέφουν δομές
ΤΑΞΕΙΣ • Τώρα γενικεύουμε μεταβλητές και συναρτήσεις

– Τάξεις: αντικείμενα που περιέχουν
• Μεταβλητές
• Συναρτήσεις που επεξεργάζονται τις μεταβλητές
• Μια τάξη εισάγει ένα αντικείμενο με συγκεκριμένες ιδιότητες και

λειτουργίες → αντικειμενοστρεφής προγραμματισμός
1 2
Ορισμός τάξης Ορισμός τάξης

• Ο γενικός ορισμός μιας τάξης είναι
• Μια τάξη ορίζεται με παρόμοιο τρόπο που ορίζεται και η δομή
class όνομα{ Ιδιωτικά μέλη της τάξης.
– Χρησιμοποιείται η δεσμευμένη λέξη «class»
τύπος μεταβλητή1 ; Δεν μπορούμε να τα
– Μέλη της τάξης μπορεί να είναι μεταβλητές και συναρτήσεις τύπος μεταβλητή2 ; προσπελάσουμε, παρά
τύπος όνομα-συνάρτησης1(...); μόνο μέσω των δημόσιων
• Τα μέλη μιας τάξης χωρίζονται σε δύο είδη τύπος όνομα-συνάρτησης2(...); συναρτήσεων της τάξης
→ ενθυλάκωση
– «private»: ιδιωτικά μέλη: δεν είναι ορατά έξω από την τάξη .
.
– «public»: δημόσια μέλη: είναι ορατά από οποιοδήποτε
public: Δημόσια μέλη της τάξης.
σημείο του προγράμματος Μπορούμε να τα
τύπος μεταβλητή3 ;
τύπος μεταβλητή4 ; προσπελάσουμε άμεσα
• Εξ ορισμού η C++ θεωρεί οτι τα μέλη μιας τάξης είναι private, τύπος όνομα-συνάρτησης3(...); από οποιοδήποτε σημείο
εκτός και εάν δηλωθούν public του προγράμματος.
τύπος όνομα-συνάρτησης4(...);
– Σε αντιδιαστολή, τα μέλη μιας δομής θεωρούνται εξ ορισμού . Οι δημόσιες συναρτήσεις
«public» . επεξεργάζονται ιδιωτικά
3 }; μέλη της τάξης 4
Απλές τάξεις Σχέση δομής και τάξης
• Μια τάξη είναι μια γενίκευση της δομής. Άρα ότι μάθαμε με τις
• Στην πιο απλή περίπτωση, μια τάξη έχει δομές, μπορούμε να το κάνουμε με τάξεις.
– Ιδιωτικές μεταβλητές:
• δεδομένα «προστατευμένα» από το υπόλοιπο πρόγραμμα • Παράδειγμα, ένα «δημόσιο» διάνυσμα μπορεί να γραφτεί
• Επεξεργασία μόνο με προκαθορισμένο τρόπο ισοδύναμα με δύο τρόπους
– Δημόσιες συναρτήσεις:
• Συναρτήσεις που επεξεργάζονται τις ιδιωτικές μεταβλητές
– Με δομή: struct vector { double x, y, z; };
• Συνιστούν την γέφυρα επικοινωνίας των μεταβλητών με το
έξω πρόγραμμα
class vector {
class όνομα{ public:
– Με τάξη:
ιδιωτικές μεταβλητές; double x, y, z;
public: };
δημόσιες συναρτήσεις; Τα παραπάνω είναι απολύτως ίδια. Τα παραδείγματα του προηγούμενου
}; 5 κεφαλαίου θα μπορούσαν να είχαν γραφτεί με την αντίστοιχη τάξη6
Συναρτήσεις-μέλη της τάξης Δήλωση συνάρτησης μέλους
• Μέσα στην τάξη δηλώνουμε τα πρωτότυπα των συναρτήσεων- • Μια συνάρτηση που είναι μέλος μιας τάξης έχει άμεση πρόσβαση
μελών στα ιδιωτικά μέλη της τάξης
– Παράδειγμα, ένα ιδιωτικό διάνυσμα, με μια συνάρτηση μέλος για – Δεν χρειάζεται τελείες κτλ
την εισαγωγή τιμών στο διάνυσμα
class vector{ • Ως εκ τούτου, ανήκει στην τάξη και πρέπει να δηλωθεί ανάλογα
double x, y, z; – Ο μεταφραστής πρέπει να ξέρει την τάξη που ανήκει
public:
void set( double x1, double y1, double z1) ;
}; • Δήλωση συνάρτησης (έξω από την τάξη, έξω από την main):
τύπος τάξη::όνομα (λίστα εισόδου){
εντολές;
– Τα x, y, z είναι ιδιωτικά, και δεν μπορούμε να τους δώσουμε
return …;
τιμές κατευθείαν από το πρόγραμμα με τον τελεστή της τελείας.
}
– Θα χρησιμοποιήσουμε την συνάρτηση set, στην οποία δίνουμε
στην λίστα εισόδου τις επιθυμητές τιμές Το καινούριο στοιχείο: πριν το όνομα της συνάρτηση γράφουμε
7 8
– Η set θα πρέπει να αντιγράψει τις τιμές στα x, y, z το όνομα της τάξης, χωρισμένα με δύο άνω-κάτω τελείες
Δήλωση συνάρτησης μέλους Κλήση συνάρτηση μέλους
• Στο προηγούμενο παράδειγμα του διανύσματος • Η κλήση γίνεται με τον τελεστή της τελείας, όπως γίνονταν
και στις δομές.
class vector{
• Μόνη διαφορά, ότι η συνάρτηση έχει πάντα παρενθέσεις
double x, y, z;
public: – Με την λίστα εισόδου εάν υπάρχει
void set( double x1, double y1, double z1) ; – Άδειες παρενθέσεις εάν δεν υπάρχει είσοδος
};
void vector::set (double x1, double y1, double z1){

x = x1; • Παράδειγμα #1:
y = y1;
Πρόγραμμα που δηλώνει τάξη για διάνυσμα με δύο συναρτήσεις:
z = z1;
- μια για εισαγωγή τιμών
}
- μια για υπολογισμό του μέτρου του διανύσματος
• Η συνάρτηση έχει άμεση πρόσβαση στα x, y, z. Τα γνωρίζει
εξ ορισμού επειδή ανήκουν στην ίδια τάξη 9 10
Παράδειγμα #1: διάνυσμα (1/2) Παράδειγμα #1: διάνυσμα (2/2)

#include <iostream>
#include <cmath> int main(){
using namespace std; vector v, u;
double a, b, c;
class vector{
double x, y, z; cout<<“εισάγετε συνιστώσες διανύσματος”<< endl;
public: cin >> a >> b >> c;
void set(double, double, double); v.set(a, b, c);
double magn();
}; cout<<“εισάγετε συνιστώσες διανύσματος”<< endl;
cin >> a >> b >> c;
void vector::set (double x1, double y1, double z1){ u.set(a, b, c);
x = x1;
y = y1; cout <<“το μέτρο του πρώτου διανύσματος”<<endl;
z = z1; cout << v.magn() << endl;
}
double vector::magn(){ cout <<“το μέτρο του δεύτερου διανύσματος”<<endl;
return sqrt(x*x + y*y +z*z); 11 cout << u.magn() << endl; 12
} συνεχίζεται... }
Παράδειγμα με συνάρτηση
Συνάρτηση δόμησης
δόμησης
#include <iostream>
• Κατά την δημιουργία ενός αντικειμένου, οι εσωτερικές
#include <cmath>
μεταβλητές δεν έχουν αρχική τιμή
– Στο προηγούμενο χρησιμοποιήσαμε την set για να δώσουμε
αρχικές τιμές class vector{
– η συνάρτηση set καλείται μέσα στο πρόγραμμα double x, y, z;
public:
• Μπορούμε να προγραμματίσουμε έτσι ώστε κατά την δήλωση του vector();
αντικειμένου, οι εσωτερικές μεταβλητές να παίρνουν εξ ορισμού void set(double, double, double);
κάποια συγκεκριμένη αρχική τιμή double magn();
};
• Συνάρτηση δόμησης vector::vector(){ x = y = z = 0;}

– ίδιο όνομα με αυτό της τάξης
– χωρίς τύπο void vector::set (double x1, double y1, double z1){
– με ή χωρίς λίστα εισόδου x = x1; y = y1; z = z1; }
13 14
double vector::magn(){ return sqrt(x*x + y*y +z*z); }
Παράδειγμα με συνάρτηση
Παράδειγμα #2: λίστα αποθήκης
δόμησης
int main(){ Στη δήλωση, τα διανύσματα Πρόγραμμα για οργάνωση και χειρισμό αντικειμένων σε αποθήκη
v, u αρχικοποιούνται στο
vector v, u;
. (0,0,0). • Θα ορίσουμε μια νέα τάξη που θα περιλαμβάνει
– Μεταβλητές για κάθε αντικείμενο:
• Η συνάρτηση δόμησης μπορεί και να έχει είσοδο • κόστος αγοράς
class vector{ double x, y, z; • Τιμή πώλησης
public: • Αριθμός αντικειμένων στην αποθήκη
vector(double x1, double y1, double z1); • Χρηματικό ισοζύγιο
.
– Συναρτήσεις για επεξεργασία των παραπάνω
};
• Συνάρτηση για αρχικές συνθήκες
vector::vector(double x1, double y1, double z1){
• Συνάρτηση για πώληση
x = x1; y = y1; z = z1; }
• Συνάρτηση για αγορά
• Τώρα όμως θα πρέπει να δοθούν οι τιμές κατά την δήλωση
• Συνάρτηση που να δείχνει την κατάσταση
int main(){ Στη δήλωση, τα διανύσματα
vector v(0,0,0), u(1,1,1); v, u αρχικοποιούνται στο
(0,0,0) και (1,1,1) 15 16
.
Παράδειγμα #2: λίστα αποθήκης (1/5) Παράδειγμα #2: λίστα αποθήκης (2/5)
#include <iostream>
void item::sell(){
class item{
double cost; int n;
double price; cout << ”πόσα κομμάτια προς πώληση;” << endl;
int stock; cin >> n;
double cash;
public: if ( stock<n ) cout<< “έχουμε μόνο” << stock <<endl;
item();
void reset(); else {
void sell(); stock -= n;
void buy(); cash += n * price;
void info(); }
}; }
item::item(){ cost = price = stock = cash = 0; } 17 18
Παράδειγμα #2: λίστα αποθήκης (3/5) Παράδειγμα #2: λίστα αποθήκης (4/5)
void item::reset(){
cout << “παλιές τιμές αγοράς και πώλησης” << endl;
cout << cost << “ ” << price << endl;
cout << “εισάγετε νέες τιμές” << endl;
void item::buy(){
cin >> cost >> price;
}
int n;
cout << ”πόσα κομμάτια προς αγορά;” << endl;
cin >> n;
void item::info(){
cout << stock <<“ έχουν μείνει στην αποθήκη ” <<endl;
stock += n;
cout << cost <<“ ευρώ η τιμή αγοράς ” <<endl;
cash -= n * cost;
cout << price <<“ ευρώ η τιμή πώλησης ” <<endl;
}
cout << cash <<“ ευρώ το ισοζύγιο ” <<endl;
}
19 20
Παράδειγμα #2: λίστα αποθήκης
Παράδειγμα #2: λίστα αποθήκης (5/5)
Εκτέλεση και αποτελέσματα
int main(){
item a[1000]; int i, j; > Aριθμός προϊόντος; > Aριθμός προϊόντος;
> 1 > 1
do { > Eντολή; 0-4: e-s-b-r-i > Eντολή; 0-4: e-s-b-r-i
cout<< “Aριθμός προϊόντος;” <<endl; cin >> i; > 3 > 1
cout<<“Eντολή; 0-4: e-s-b-r-i”<<endl; cin >> j; > παλιές τιμές αγοράς και > πόσα κομμάτια προς πώληση;”
πώλησης > 3
switch (j){ > 0 0
case 1: a[i].sell(); break; > εισάγετε νέες τιμές > Aριθμός προϊόντος;
case 2: a[i].buy(); break; > 3 4 > 1
case 3: a[i].reset(); break; > Eντολή; 0-4: e-s-b-r-i
case 4: a[i].info(); break; > Aριθμός προϊόντος; > 4
} > 1 > 2 έχουν μείνει στην αποθήκη
} > Eντολή; 0-4: e-s-b-r-i > 3 ευρώ η τιμή αγοράς
while( j > 0 ); > 2 > 4 ευρώ η τιμή πώλησης
} > πόσα κομμάτια προς αγορά; > -3 ευρώ το ισοζύγιο
21 > 5 22
Παράδειγμα #2: Λίστα

Παράδειγμα #2: Λίστα προτεραιότητας
προτεραιότητας (1/4)
• Μια λίστα προτεραιότητας (ή λίστα αναμονής, ή «ουρά») • Θα ονομάσουμε την τάξη μας queue (ουρά)
– Δέχεται νούμερα, που προστίθενται στο τέλος
class queue {
– Τραβάει νούμερα από την αρχή της ουράς double q[1000];
– Η σειρά που ακολουθείται είναι «πρώτο μπαίνει, πρώτο βγαίνει) int sloc, rloc;
public:
• Από μεταβλητές θα χρειαστούμε queue();
void qput(double);
– έναν πίνακα για να αποθηκεύουμε τα νούμερα
double qget();
– έναν ακέραιο για την θέση όπου βάζουμε τον επόμενο };
– έναν ακέραιο για την θέση απ’ όπου τραβάμε τον επόμενο
• Από συναρτήσεις θα χρειαστούμε
– μια συνάρτηση όταν ένας νέος αριθμός μπαίνει στη λίστα • Η συνάρτηση δόμησης πρέπει να δίνει τις κατάλληλες αρχικές
– μια συνάρτηση για να τραβάμε έναν αριθμό από την λίστα τιμές κατά την δήλωση μιας νέας ουράς.
• και οι δύο πρέπει να ελέγχουν μην ξεπεραστούν όρια. – Αρχικά είναι άδεια, άρα sloc=rloc=0;
– μια συνάρτηση να δίνει αρχικές τιμές. 23 queue::queue(){ sloc = rloc = 0; } 24
Παράδειγμα #2: Λίστα Παράδειγμα #2: Λίστα
προτεραιότητας (2/4) προτεραιότητας (3/4)
• Η συνάρτηση qput δέχεται έναν ρητό και τον προσθέτει στο • Η συνάρτηση qget τραβάει έναν ακέραιο από την αρχή της ουράς
τέλος της ουράς – Ελέγχει ότι η ουρά δεν είναι άδεια
– Ελέγχει ότι η ουρά δεν έχει γεμίσει – Η θέση στην αρχή της ουράς είναι η rloc
– Η θέση στο τέλος της ουράς είναι η sloc
double queue::qget(){
void queue::qput(double a){
if(rloc == sloc){
if(sloc == 1000){
cout<< ”η λίστα είναι άδεια ”;
cout<< ”η λίστα είναι γεμάτη” << endl;
return 0;
return;
}
}
double r = q[rloc];
q[sloc] = a;
rloc++;
sloc++;
return r;
}
}
25 26
Παράδειγμα #2: Λίστα Παράδειγμα #2: Λίστα

προτεραιότητας (4/4) προτεραιότητας 2
• Ένα παράδειγμα προγράμματος που χρησιμοποιεί την τάξη queue
• Ένα δεύτερο παράδειγμα προγράμματος με την τάξη queue
queue a, b; queue a; int i; double x;
a.qput(10); do { cout<<”Επόμενη εντολή; 0-2 e-p-g“<<endl;
b.qput(19); cin >> i;
a.qput(20);
b.qput(1); switch (i) {
case 1:
cout<<”η λίστα a περιέχει τους αριθμούς: “; cout<< “δώστε αριθμό” <<endl;
cout << a.qget() << “ “ << a.qget() <<endl; cin >> x; a.qput(x); break;
case 2:
cout<<”η λίστα b περιέχει τους αριθμούς: “; cout<< “επόμενος αριθμός στην ουρά ”;
cout << b.qget() << “ “ << b.qget() << endl; cout << a.qget() << endl; break;
} }
Στην εκτέλεση του παραπάνω θα λάβουμε }
> η λίστα a περιέχει τους αριθμούς: 10 20 27
while ( i > 0 );
28
> η λίστα b περιέχει τους αριθμούς: 19 1 }
Παράδειγμα #2: Λίστα
Παράδειγμα #3: Μέτρηση καρτών
προτεραιότητας 2: εφαρμογή
> Επόμενη εντολή; 0-2 e-p-g > Επόμενη εντολή; 0-2 e-p-g
Πρόγραμμα που μετράει κάρτες σε παιχνίδι
> 1 > 2
• Έστω το παιχνίδι «21»,το οποίο παίζεται ως εξής:
> δώστε αριθμό > επόμενος αριθμός στην ουρά 7
> 4 – τραβάς όσα φύλλα επιθυμείς
> Επόμενη εντολή; 0-2 e-p-g
– ο πιο κοντά στο 21 κερδίζει
> Επόμενη εντολή; 0-2 e-p-g > 2
> 1 > επόμενος αριθμός στην ουρά 5 – παίζουν τα φύλλα από 1 μέχρι και 10
> δώστε αριθμό – παίζουν n τράπουλες
> 7 > Επόμενη εντολή; 0-2 e-p-g
> 2
> Επόμενη εντολή; 0-2 e-p-g > η λίστα είναι άδεια 0 Θα φτιάξουμε μια τάξη που θα μετράει τα φύλλα
> 2 • Από μεταβλητές θα χρειαστούμε
> επόμενος αριθμός στην ουρά 4 > Επόμενη εντολή; 0-2 e-p-g
– έναν πίνακα για να αποθηκεύει πόσα φύλλα περάσανε
> 1
> Επόμενη εντολή; 0-2 e-p-g > δώστε αριθμό – έναν ακέραιο για πόσα φύλλα ακόμα παίζουν
> 1 > 15 • Από συναρτήσεις θα χρειαστούμε
> δώστε αριθμό
– μια συνάρτηση δόμησης για αρχικές τιμές
> 5 > Επόμενη εντολή; 0-2 e-p-g
> 2 – μια συνάρτηση όταν ένα νέο φύλλο περνάει
> επόμενος αριθμός στην ουρά 15 – μια συνάρτηση που συμβουλεύει να τραβήξουμε ή όχι
Παράδειγμα #3: Μέτρηση καρτών Παράδειγμα #3: Μέτρηση καρτών

(1/4) (2/4)
• Συνάρτηση για καταμέτρηση φύλλου που πέρασε
#include <iostream>
– στην είσοδο το j είναι το φύλλο που περνάει
– αφαιρείται ένα από τα j που παραμένουν
class game{ – αφαιρείται ένα από τον συνολικό αριθμό που παραμένει
int cards[11];
int num; void game::add( int j ){
public:
game(int); if( cards[j] == 0 ){
void add(int); cout << “τέλειωσε αυτή η κάρτα” << endl;
double play(int); return;
}; }
game::game(int n){ cards[j]--;

for (int i=1; i<=10; ++i) cards[i] = 4 * n; num--;
num = 40 * n; }
} 31 32
Παράδειγμα #3: Μέτρηση καρτών Παράδειγμα #3: Μέτρηση καρτών
(3/4) (4/4)
• Συνάρτηση για εκτίμηση πιθανότητας να τραβήξουμε • Το κυρίως πρόγραμμα
– στην είσοδο το j είναι το άθροισμα που έχουμε μέχρι τώρα
– αθροίζουμε τον αριθμό φύλλων που δεν το καίνε int main(){
• δηλαδή αυτά που έχουν μείνει από 1 μέχρι 21 - j int n, j;
– διαιρούμε με τον συνολικό αριθμό φύλλων που έχει μείνει cout << “πόσες τράπουλες; ”;
cin >> n;
double game::play( int j ){
game a(n);
if( num == 0 ){
do{
cout<< “τελείωσαν οι κάρτες” << endl ;
cout << “νέο φύλλο ”;
return 0;
cin >> j;
}
if (j <= 10) a.add(j);
else cout << “τράβα” << a.play(j) << “%\n”;
double s=0;
for(int i=1; i <= 21-j; ++i) s += cards[i];
}
while( j > 0 );
return s / num * 100; 33 34
}
}
Πρόσθεση διανυσμάτων 1: με
Υπερφόρτωση τελεστών
εξωτερική συνάρτηση
• Έστω η τάξη vector
– για απλότητα θεωρούμε όλα τα μέλη της τάξης δημόσια
• Είδαμε πως γράφουμε συναρτήσεις για την εκτέλεση
class vector{
συγκεκριμένων λειτουργιών-πράξεων
public:
• Είδαμε πως υπερφορτώνουμε συναρτήσεις double x, y, z;
};
• Εδώ τα συνδυάζουμε υπερφορτώνοντας τους τελεστές
– Για παράδειγμα, αντί να γράψουμε συνάρτηση sum για • Θα γράψουμε εξωτερική συνάρτηση για την πρόσθεση
πρόσθεση διανυσμάτων, θα επαναπρογραμματίσουμε το
“+” ώστε να κάνει την επιθυμητή λειτουργία vector sum(vector v, vector u){
vector w;
• Ως παράδειγμα, θα χρησιμοποιήσουμε την τάξη vector w.x = v.x + u.x;
w.y = v.y + u.y;
w.z = v.z + u.z;
return w;
35 } 36
Πρόσθεση διανυσμάτων 1: με Πρόσθεση διανυσμάτων 2: με
εξωτερική συνάρτηση συνάρτηση-μέλος
#include <iostream> • Έστω η τάξη vector
using namespace std; class vector{
public:
class vector{ double x, y, z;
public: double x, y, z; }; vector sum(vector);
};
vector sum(vector, vector);
• Η συνάρτηση-μέλος δέχεται και επιστρέφει τον ίδιο τύπο με την τάξη
int main(){ • καλείται από κάποια μεταβλητή τύπου vector με την τελεία
vector v1, v2, v3;
. vector vector::sum(vector u){
. vector w;
v3 = sum(v1, v2); w.x = x + u.x;
. w.y = y + u.y;
cout << “το άθροισμα v1+v2 είναι ” << endl; w.z = z + u.z;
cout << v3.x << v3.y << v3.z<<endl; return w;
} 37 } 38
Πρόσθεση διανυσμάτων 2: με Πρόσθεση διανυσμάτων 3: με

συνάρτηση-μέλος υπερφόρτωση τελεστή
#include <iostream> • Ορίζεται όπως και η εσωτερική συνάρτηση
• Για να δηλώσουμε ότι πρόκειται για τελεστή, το όνομά της αποτελείται
από τον κωδικό operator συνοδευόμενο από το επιθυμητό σύμβολο
class vector{
public: – π.χ. για πρόσθεση, χρησιμοποιούμε το operator+
double x, y, z; class vector{
vector sum(vector); public:
}; double x, y, z;
vector operator+(vector);
int main(){ };
vector v1, v2, v3;
. vector vector::operator+(vector u){
. vector w;
v3 = v1.sum(v2); w.x = x + u.x;
. w.y = y + u.y;
cout << “το άθροισμα v1+v2 είναι ” << endl; w.z = z + u.z;
cout << v3.x << v3.y << v3.z<<endl; return w;
39 40
} }
Πρόσθεση διανυσμάτων 3: με Σύγκριση συνάρτησης-μέλους και
υπερφόρτωση τελεστή τελεστή
#include <iostream>
using namespace std; Με συνάρτηση-μέλος Με τελεστή
• Η συνάρτηση sum καλείται από • Ο τελεστής + καλείται από το
class vector{ το διάνυσμα στα αριστερά διάνυσμα στα αριστερά
public: – Άρα έχει άμεση γνώση των – Άρα έχει άμεση γνώση των
double x, y, z; μελών x, y, z μελών x, y, z
vector operator+(vector); • Το διάνυσμα στα δεξιά εισέρχεται • Το διάνυσμα στα δεξιά εισέρχεται
}; – Άρα για τα x, y, z του – Άρα για τα x, y, z του
εισερχόμενου διανύσματος εισερχόμενου διανύσματος
int main(){ χρειαζόμαστε την τελεία χρειαζόμαστε την τελεία
vector v1, v2, v3;
. • H συνάρτηση καλείται ως • Ο τελεστής καλείται ως
. v3 = v1.sum(v2); v3 = v1 + v2;
v3 = v1 + v2;
.
cout << “το άθροισμα v1+v2 είναι ” << endl; Με τελεστή δεν χρειάζονται η τελεία και οι παρενθέσεις!
cout << v3.x << v3.y << v3.z<<endl; 41 42
}
Υπερφόρτωση αφαίρεσης Υπερφόρτωση γινομένου

διανυσμάτων διανυσμάτων και γινομένου με ρητό
• Εσωτερικό γινόμενο δύο διανυσμάτων
double vector::operator*(vector u){
return x*u.x + y*u.y + z*u.z;
}
vector vector::operator-(vector u){
vector w;
w.x = x - u.x; • Γινόμενο διανύσματος με ρητό
w.y = y - u.y;
w.z = z - u.z; vector vector::operator*(double m){
return w; vector w;
} w.x = x * m;
w.y = y * m;
w.z = z * m;
return w;
}
43 44
Δημιουργία τελεστή εξωτερικού
Λοιπές συναρτήσεις-μέλη
γινομένου διανυσμάτων
• Συνάρτηση δόμησης χωρίς είσοδο (για εξ ορισμού ανάθεση (0,0,0))
• Εξωτερικό γινόμενο (ορίζουμε τον νέο τελεστή ^)
vector::vector(){ x = y = z = 0; }
iˆ ˆj kˆ
r r
a × b = ax ay a z = iˆ(a y bz − a z b y ) − ˆj (a x bz − a z bx ) + kˆ(a x b y − a y bx ) • Συνάρτηση δόμησης με είσοδο (για ανάθεση κατά την δήλωση)
bx by bz vector::vector(double x1, double y1, double z1){
x = x1; y = y1; z = z1;
}
vector vector::operator^(vector u){
• Συνάρτηση set (για ανάθεση μετά την δήλωση)
vector w;
w.x = y * u.z – z * u.y; void vector::set(double x1, double y1, double z1){
w.y = z * u.x – x * u.z; x = x1; y = y1; z = z1;
w.z = x * u.y – y * u.x; }
return w; • Συνάρτηση magnitude
}
double vector::magnitude(){
45
return sqrt(x*x + y*y + z*z); 46
}
Παράδειγμα 1: Διανυσματικός Παράδειγμα 1: Διανυσματικός

λογισμός λογισμός (1/2)
#include <iostream>
#include <cmath>
• Πλήρες πρόγραμμα C++ με τους τελεστές και συναρτήσεις-μέλη using namespace std;
που δόθηκαν προηγουμένως, ώστε να υπολογίσει την έκφραση
class vector{
public:
(v1 × v 2 ) × (v1 × v3 )⋅ | (v1 + v 2 ) × (v1 − v3 ) | double x, y, z;
vector();
vector(double, double, double);
void set(double, double, double);
vector operator+(vector);
vector operator-(vector);
double operator*(vector);
vector operator*(double);
vector operator^(vector);
double magnitude();
47 }; 48
Παράδειγμα 1: Διανυσματικός
Παράδειγμα 2: μιγαδικοί αριθμοί
λογισμός (2/2)
int main(){
double x, y, z; vector r; #include <iostream>
cout << “εισάγετε τα τρία διανύσματα ” <<endl; #include <cmath>
cin >> x >> y >> z;
vector v1(x,y,z); class complex{
public:
cin >> x >> y >> z; double real, imag;
vector v2(x,y,z); complex();
complex(double, double);
cin >> x >> y >> z; void set(double, double);
vector v3(x,y,z); (v1 × v 2 ) × (v1 × v3 )⋅ | (v1 + v 2 ) × (v1 − v3 ) | complex operator+(complex);
complex operator-(complex);
r = ((v1^v2)^(v1^v3)) * ((v1+v2)^(v1-v3)).magn(); complex operator*(complex);
complex operator*(double);
cout << ”το ζητούμενο διάνυσμα είναι” <<endl; double magnitude();
cout << r.x <<” “<< r.y <<” “<< r.z <<endl; 49 }; 50
}
Παράδειγμα 2: μιγαδικοί αριθμοί Παράδειγμα 2: μιγαδικοί αριθμοί

complex::complex(){real = imag = 0; } complex complex::operator+(complex z){
complex w;
complex::complex(double r, double i){ w.real = real + z.real;
real = r; imag = i; w.imag = imag + z.imag;
} return w;
}
void complex::set(double r, double i){
real = r; imag = i; complex complex::operator-(complex z){
} complex w;
w.real = real - z.real;
double complex::magnitude(){ w.imag = imag - z.imag;
return sqrt(real*real + imag*imag); return w;
} }
51 52
Παράδειγμα 2: μιγαδικοί αριθμοί Παράδειγμα 2: μιγαδικοί αριθμοί
Χρησιμοποιώντας την τάξη complex, υπολογίστε τους 100 πρώτους
όρους της παρακάτω αναδρομικής ακολουθίας μιγαδικών αριθμών
complex complex::operator*(complex z){ z n = rz n −1 (1 − z n − 2 )
complex w; z 1 = 0.75 + i 0.25, z 2 = 0.25 + i 0.75, r = 2
w.real = real * z.real – imag * z.imag;
w.imag = real * z.imag + imag * z.real; int main(){
return w; double r = 2;
} complex za(0.75, 0.25);
complex zb(0.25, 0.75);
complex complex::operator*(double m){ complex z1(1.00, 0.00);
complex w;
w.real = real * m; for (int i=3; i<=100; ++i){
w.imag = imag * m; zc = ( zb * (z1 – za) ) * r;
return w; za = zb; zb = zc;
} cout << “ο όρος ” << i << “είναι ”
<< zc.real << “ “ << zc.imag << endl;
53 } 54
}

Υπολογιστεσ Ιi Προγραμματισμός Με Τη Γλώσσα 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

Υπολογιστεσ Ιi Προγραμματισμός Με Τη Γλώσσα c++ ε. Λοιδωρίκης, δ. Παπαγεωργίου Πανεπιστήμιο Ιωαννίνων

Uploaded by

Copyright:

Available Formats

ΥΠΟΛΟΓΙΣΤΕΣ ΙI

Προγραμματισμός με τη γλώσσα C++

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

Ένα πρώτο πρόγραμμα Πως γράφεται το πρόγραμμα

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

int main ( ) cout <<

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

• Στο τέλος κάθε εντολής βάζουμε ερωτηματικό (όχι Παράδειγμα:

Σχόλια Το κυρίως πρόγραμμα

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

Ξεκινάνε με τους χαρακτήρες // και εκτείνονται int main ( )

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

• Στην πραγματικότητα ένα πρόγραμμα C++ είναι ένα

Η εντολή cout Συγγραφή του προγράμματος

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

Αν γράψουμε: Αποθηκεύουμε το αρχείο δίνοντας ένα όνομα με

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

Πηγαίος κώδικας Εκτελέσιμος κώδικας

ΥΠΟΛΟΓΙΣΤΕΣ IΙ - ΔΟΜΗ ΤΟΥ ΠΡΟΓΡΑΜΜΑΤΟΣ

• Στη συνέχεια το προεπεξεργασμένο πρόγραμμα παραδίδεται

Η γλώσσα προγραμματισμού C++ υποστηρίζει

τους παρακάτω τύπους δεδομένων:

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Μεταξύ δύο ακεραίων αριθμών μπορούν να γίνουν

Το αποτέλεσμα μιας πράξης μεταξύ ακεραίων

Προσοχή: Δεν υπάρχει τελεστής για ύψωση σε δύναμη.

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Η λειτουργία αυτή ονομάζεται ακέραια διαίρεση.

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Για να υπολογιστούν πιο σύνθετες αριθμητικές Σε μια σύνθετη αριθμητική παράσταση:

Τελεστής Προτεραιότητα Προσεταιριστικότητα 3. Εάν υπάρχουν παρενθέσεις, τότε πρώτα γίνονται

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

• Λαμβάνουν τιμές στην περιοχή -10308…-10-308

• Στη C++ οποιαδήποτε αριθμητική σταθερά με

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

• Απαιτούνται 4 bytes για την αποθήκευσή τους.

• Για να ξεχωρίσουν από τους πραγματικούς

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

sin(1.0) Σωστό Για να υπολογίσουμε τον αριθμό e (βάση των

Οι τριγωνομετρικές συναρτήσεις δέχονται το όρισμα exp(1.0)

Οι αντίστροφες τριγωνομετρικές συναρτήσεις

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Η βάση (a) και ο εκθέτης (b) μπορεί να είναι: 4*acos(-1.0)*pow(r,3)/3

Τύπος βάσης Τύπος εκθέτη Τύπος αποτελέσματος

Προσοχή: Η βάση δεν μπορεί να είναι ακέραιος sqrt( pow(x1-x2,2)+pow(y1-y2,2) )

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Οι μεταβλητές είναι συμβολικά ονόματα που • Επιτρέπονται μόνο λατινικοί χαρακτήρες,

Οι ίδιοι κανόνες ισχύουν και για άλλα ονόματα, πχ.

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Μεταβλητή = Αριθμητική παράσταση

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

#include <iostream> k = k+1;

Στα δεξιά του = πρέπει να είναι μια σταθερή τιμή.

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

Στην επιθεματική μορφή: • Οι τελεστές ++ και -- χρησιμοποιούνται μόνο σε

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

ΥΠΟΛΟΓΙΣΤΕΣ ΙΙ - ΤΥΠΟΙ ΔΕΔΟΜΕΝΩΝ, ΠΡΑΞΕΙΣ, ΜΕΤΑΒΛΗΤΕΣ

cout << x ; cout << x << '\n';

Εάν θέλουμε να εμφανίσουμε δύο μεταβλητές στην ίδια

cout << x << " " << y << endl;

Η βάση (a) και ο εκθέτης (b) μπορεί να είναι: 4acos(-1.0)pow(r,3)/3