Αντικειμενοστραφής Προγραμματισμός ΣΗΜΕΙΩΣΕΙΣ ΘΕΩΡΙΑΣ

Transcript

1 ΣΗΜΕΙΩΣΕΙΣ ΘΕΩΡΙΑΣ ΜΑΡΙΟΣ ΤΣΟΥΚΑΛΑΣ 2017

2 Πίνακας περιεχομένων Εισαγωγή... 3 Συναρτήσεις Παραδείγματα συναρτήσεων Κλάσεις Αντικείμενα Παραδείγματα κλάσεων Κλάσεις και Πίνακες Παραδείγματα κλάσεων και πινάκων Κληρονομικότητα Παραδείγματα κληρονομικότητας Υπερφόρτωση Τελεστών Παραδείγματα υπερφόρτωσης τελεστών Δείκτες Παραδείγματα δεικτών Αρχεία Παραδείγματα αρχείων Βιβλιογραφία

3 ΕΙΣΑΓΩΓΗ Η Αρχή Ο αντικειμενοστραφής προγραμματισμός άρχισε να χρησιμοποιείται από τους προγραμματιστές, όταν ουσιαστικά ο διαδικαστικός (δομημένος) προγραμματισμός, δεν μπορούσε να ανταποκριθεί στις νέες απαιτήσεις των προγραμμάτων. Επίσης όσο τα προγράμματα μεγάλωναν και γίνονταν όλο και πιο πολύπλοκα, οι γλώσσες του διαδικαστικού προγραμματισμού εμφάνισαν αδυναμίες στην ανάπτυξή τους. Με τι ασχολείται ο αντικειμενοστραφής προγραμματισμός Ο αντικειμενοστραφής προγραμματισμός στρέφεται (όπως είναι και ο τίτλος του) στα αντικείμενα, τα οποία δημιουργούνται από κατάλληλη επεξεργασία των δεδομένων μελών από τις συναρτήσεις μέλη μιας κλάσης. Συνεπώς τα αντικείμενα είναι εν δυνάμει οντότητες, οι οποίες ανήκουν σε μία κλάση (τα περιέχει) ή αλλιώς, από μια κλάση μπορούν να δημιουργηθούν αντικείμενα. Με τον αντικειμενοστραφή προγραμματισμό τα προγράμματα που φτιάχνουμε είναι φιλικότερα, ευέλικτα, αποδοτικότερα και επαναχρησιμοποιήσιμα. Αντικείμενα Τα αντικείμενα είναι βασικά στοιχεία στον αντικειμενοστραφή προγραμματισμό τα οποία έχουν χαρακτηριστικά αλλά και συμπεριφορές. Με τον όρο χαρακτηριστικό εννοούμε οτιδήποτε καθορίζει την φυσική υπόσταση του αντικειμένου. Με τον όρο συμπεριφορά εννοούμε το πώς συμπεριφέρεται ένα αντικείμενο από μόνο του ή όταν μία ενέργεια επιδράσει επάνω του. 3

4 Αντικείμενα - δημιουργία και χειρισμός Με τις γλώσσες αντικειμενοστραφούς προγραμματισμού: κατασκευάζουμε (ορίζουμε) κλάσεις, οι οποίες με την σειρά τους δημιουργούν αντικείμενα. Τα προγράμματα που κατασκευάζονται δημιουργούν αντικείμενα αλλά και τα χειρίζονται, με κατάλληλα εργαλεία που ονομάζονται συναρτήσεις ή αλλιώς μέθοδοι. Δημιουργία αντικειμένου Αντικειμενοστραφής εφαρμογή Χειρισμός αντικειμένου Δεδομένα και συναρτήσεις Τα χαρακτηριστικά των αντικειμένων είναι τα δεδομένα-μέλη της κλάσης, τα οποία τα κρύβουμε με ειδικές τεχνικές, για να είναι ασφαλή από τυχόν αλλοίωσή τους. Οι συμπεριφορές είναι οι συναρτήσεις-μέλη της κλάσης, οι οποίες χειρίζονται με κατάλληλο τρόπο τα δεδομένα-μέλη της κλάσης. Οι συναρτήσεις-μέλη λέγονται αλλιώς και μέθοδοι μιας κλάσης. Παράδειγμα. Το αντικείμενο «Ήρα» της κλάσης «γάτα» έχει χαρακτηριστικά το όνομά της, την ηλικία της, το χρώμα της και συμπεριφορές ότι νιαουρίζει, κοιμάται, τρώει κλπ. Κλάσεις Η κλάση είναι ένα σύνολο από παρόμοια αντικείμενα. Είναι το πρότυπο, δηλαδή καθορίζει τα δεδομένα (χαρακτηριστικά) και τις συναρτήσεις (συμπεριφορές) που θα έχουν τα αντικείμενα της. 4

5 Άρα όλα τα αντικείμενα είναι πιστά αντίγραφα της κλάσης στην οποία ανήκουν. Το κάθε αντικείμενο έχει χαρακτηριστικά το σετ των χαρακτηριστικών της κλάσης και χειρίζεται τα χαρακτηριστικά του με τις συναρτήσεις της κλάσης. Η κλάση κατά τον ορισμό της δεν δημιουργεί αντικείμενα. Τα αντικείμενα δημιουργούνται από άλλους παράγοντες μέσα στο πρόγραμμα (άλλες συναρτήσεις, δομές κλπ). Εγκλεισμός Η διαδικασία της συμπερίληψης όλων των πληροφοριών (δεδομένων και συναρτήσεων) σε ένα συγκεκριμένο και εκ των προτέρων ορισμένο μέρος (κλάση), λέγεται εγκλεισμός (encapsulation). Ο εγκλεισμός επιτρέπει στους πελάτες της κλάσης (κλάσεις ή συναρτήσεις που βρίσκονται έξω από την κλάση), να χρησιμοποιούν την κλάση χωρίς να τους ενδιαφέρει πως λειτουργεί. Για παράδειγμα μπορούμε να οδηγούμε ένα αυτοκίνητο, χωρίς να μας ενδιαφέρει πως λειτουργεί η μηχανή του ή το σύστημα διεύθυνσης του. Παράδειγμα ορισμού κλάσης και αντικειμένου στην C++ Με την βοήθεια της αντικειμενοστραφούς γλώσσας προγραμματισμού C++,με την οποία και θα ασχοληθούμε στο μάθημα ορίζουμε μία κλάση, παράγουμε 2 αντικείμενα της κλάσης και καλούμε μια συνάρτηση της κλάσης από το ένα αντικείμενο. class student ; //δήλωση της κλάσης student student s1,s2; //δήλωση 2 αντικειμένων της κλάσης student s1.readdata(); //κλήση συνάρτησης από το αντικείμενο s1 5

6 Σχηματική παράσταση κλάσης αντικειμένου Κλάση Δεδομένο-μέλος Κλήση Συνάρτησης από αντικείμενο class student Name s1 Name Age readdata() printdata() Age readdata() s2 Name Αντικείμενο printdata() Age Συνάρτηση-μέλος Κληρονομικότητα Η έννοια της κλάσης στον αντικειμενοστραφή προγραμματισμό είναι άρρηκτα συνδεδεμένη με την έννοια της κληρονομικότητας. Κληρονομικότητα (inheritance) ονομάζεται η διαδικασία που επιτρέπει μία κλάση να κληρονομεί τις ιδιότητες και τις συμπεριφορές μιας άλλης κλάσης. Η κλάση που κληρονομείται λέγεται βασική κλάση (base class or superclass) ενώ, Η κλάση που κληρονομεί λέγεται παραγόμενη κλάση (derived class or subclass). Για παράδειγμα η κλάση οχήματα χωρίζεται σε επιβατικά, φορτηγά, λεωφορεία κλπ. 6

7 Παράδειγμα Η παραγόμενη κλάση κληρονομεί χαρακτηριστικά και συμπεριφορές από την βασική κλάση αλλά μπορεί να έχει και δικά της. Αν γυρίσουμε στο προηγούμενο παράδειγμα όλα τα οχήματα (βασική κλάση) έχουν κινητήρα και τροχούς (χαρακτηριστικά), ξεκινούν και σταματούν (συμπεριφορά), αλλά τα φορτηγά έχουν επί πλέον καρότσα (χαρακτηριστικό) η οποία ανατρέπεται (συμπεριφορά) και τα λεωφορεία έχουν επί πλέον μπαγκαζιέρα (χαρακτηριστικό). Οχήματα Επιβατικά Φορτηγά Λεωφορεία Σχηματική παράσταση κληρονομικότητας Στο διάγραμμα βλέπουμε ότι οι παραγόμενες κλάσεις χρησιμοποιούν τα δεδομένα της βασικής κλάσεις (Χαρακτηριστικό Α, Χαρακτηριστικό Β) αλλά και τα δικά τους. 7

8 Παράδειγμα κληρονομικότητας σε UML Στο παράδειγμα τα αντικείμενα της κλάσης «Επιβατικό», έχουν χαρακτηριστικά και μεθόδους μόνο αυτά της βασικής κλάσης, δηλαδή έχουν κινητήρα, τροχούς, πόρτες, καθίσματα και ξεκινούν, σταματούν, στρίβουν. Τα αντικείμενα της κλάσης «Φορτηγό», έχουν εκτός από αυτά της βασικής κλάσης επί προσθέτως, καρότσα η οποία ανατρέπεται και Τα αντικείμενα της κλάσης «Λεωφορείο» έχουν εκτός από αυτά της βασικής κλάσης επί προσθέτως, μπαγκαζιέρα. Σημ. τα αντικείμενα της κλάσης «Όχημα» έχουν τα δικά της χαρακτηριστικά και μεθόδους και δεν χρησιμοποιούν των παραγόμενων κλάσεων. Η κληρονομικότητα δεν λειτουργεί αντίστροφα. Επαναχρησιμοποίηση Ένα βασικό χαρακτηριστικό στον αντικειμενοστραφή προγραμματισμό είναι η επαναχρησιμοποίηση (reuse). Η επαναχρησιμοποίηση, είναι η δυνατότητα χρησιμοποίησης μιας κλάσης όταν οριστεί, από άλλα προγράμματα. 8

9 Είναι κάτι δηλαδή σαν τις βιβλιοθήκες συναρτήσεων της γλώσσας προγραμματισμού όπου μπορούμε να τις χρησιμοποιήσουμε σε πολλά προγράμματα. Ουσιαστικά χρησιμοποιούμε τον ήδη υπάρχοντα γραμμένο κώδικα χωρίς να χρειάζεται να τον ξαναγράψουμε. H κληρονομικότητα είναι μια μορφή επαναχρησιμοποίησης, αφού μπορούμε να πάρουμε μια υπάρχουσα κλάση (superclass) και χωρίς να την τροποποιήσουμε να παράξουμε μία άλλη κλάση (subclass), προσθέτοντας επιπλέον χαρακτηριστικά και μεθόδους στην νέα κλάση. Η νέα κλάση κληρονομεί τα χαρακτηριστικά και τις μεθόδους από την υπάρχουσα κλάση αλλά χρησιμοποιεί και τα δικά της (αν αυτά υπάρχουν στη νέα κλάση). Πολυμορφισμός Ο πολυμορφισμός (polymorphism), είναι η δυνατότητα που δίνεται: 1. Σε ένα αντικείμενο να αναφέρεται σε διαφορετικές κλάσεις (από αυτή από την οποία δημιουργήθηκε) και να επιδρά διαφορετικά σε άλλα αντικείμενα. 2. Σε μία συνάρτηση να υπάρχει πολλές φορές μέσα σε μία κλάση με το ίδιο όνομα και τον ίδιο σκοπό, αλλά με διαφορετικά αποτελέσματα. Για παράδειγμα η συνάρτηση πάτησε() λειτουργεί διαφορετικά στο φρένο, διαφορετικά στο γκάζι και διαφορετικά στον συμπλέκτη του αυτοκινήτου. 3. Αλλά και σε έναν τελεστή να λειτουργεί διαφορετικά μέσα σε ένα πρόγραμμα. Συμπέρασμα Τα δύο αυτά χαρακτηριστικά δηλαδή: η επαναχρησιμοποίηση και ο πολυμορφισμός, είναι πολύ σημαντικά γιατί ουσιαστικά μαζί με τις έννοιες: της κλάσης και του αντικειμένου, είναι οι πυλώνες στους οποίους στηρίζεται ο αντικειμενοστραφής προγραμματισμός. 9

10 ΣΥΝΑΡΤΗΣΕΙΣ Συνάρτηση ένα χρήσιμο εργαλείο Είναι απαραίτητο πριν ξεκινήσουμε την γνωριμία με τον αντικειμενοστραφή προγραμματισμό να εξετάσουμε ενδελεχώς ένα πολύ χρήσιμο εργαλείο το οποίο χρησιμοποιούμε κατά κόρο. Αυτό δεν είναι άλλο από τη συνάρτηση. Την συνάρτηση την χρησιμοποιούμε για να εκτελέσουμε έναν συγκεκριμένο αριθμό εντολών που λύνουν ένα μέρος του προβλήματος που καλούμαστε να αντιμετωπίσουμε. Την χρησιμοποιούμε μόνη της μέσα σε ένα πρόγραμμα ή και σαν μέρος μιας κλάσης. Σε αυτήν την περίπτωση η συνάρτηση είναι αυτή που καθορίζει ένα κομμάτι της συμπεριφοράς ενός αντικειμένου της κλάσης στην οποία ανήκει. Η συνάρτηση μέσα στην κλάση χειρίζεται τις μεταβλητές μέλη της κλάσης και ονομάζεται μέθοδος της κλάσης. Ουσιαστικά ένα αντικείμενο χειρίζεται τα δεδομένα του μέσω των συναρτήσεων της κλάσης. Τι είναι συνάρτηση Συνάρτηση είναι ένα κομμάτι του προγράμματος που εκτελεί μία συγκεκριμένη λειτουργία. Μέσα σε ένα πρόγραμμα της C++ μπορεί να υπάρχουν αυτόνομες συναρτήσεις ή να περιλαμβάνονται μέσα σε κλάσεις. Η συνάρτηση περιέχει εντολές μέσα στο σώμα της (μπλοκ εντολών). Η συνάρτηση: Καλείται μέσα στην βασική συνάρτηση της C++ (main) ή και από άλλες συναρτήσεις, αλλά και η ίδια καλεί άλλες συναρτήσεις. 10

11 Απεικόνιση συνάρτησης Πιο κάτω φαίνεται σχηματικά μια συνάρτηση. Όπως φαίνεται στο σχήμα η συνάρτηση έχει είσοδο που είναι οι παράμετροι (μεταβλητές εισόδου), έξοδο που είναι η τιμή που επιστρέφει η συνάρτηση στο σημείο που κλήθηκε και ένα σώμα που περιλαμβάνει τον κώδικα των εντολών που διατρέχει για να ολοκληρώσει την δουλειά της. Σχηματική παράσταση κλήσεων συναρτήσεων 11

12 Στη πιο πάνω εικόνα το πρόγραμμα καλεί την πρώτη συνάρτηση Συνάρτηση1(). Ο έλεγχος φεύγει από το πρόγραμμα και εκτελεί τις εντολές της συνάρτησης. Η Συνάρτηση1() επιστρέφει τιμή στο πρόγραμμα. Το πρόγραμμα εν συνεχεία καλεί την Συνάρτηση2(). Ο έλεγχος πηγαίνει στην συνάρτηση και εκτελεί τις εντολές της. Μια από τις εντολές της συνάρτησης είναι και η κλήση της Συνάρτηση3(), ο έλεγχος πηγαίνει σε αυτήν και εκτελεί το σώμα των εντολών της. Αφού ολοκληρωθεί η Συνάρτηση3() επιστρέφει τιμή στην Συνάρτηση2() η οποία αφού ολοκληρωθεί επιστρέφει με την σειρά της τιμή στο πρόγραμμα. Κατόπιν με τον ίδιο τρόπο καλείται από το πρόγραμμα η Συνάρτηση4(). Η συνάρτηση μέσα στο πρόγραμμα Οι συναρτήσεις μέσα σε ένα σημείο του προγράμματος καλούνται αφού πρώτα έχουν δηλωθεί στην αρχή του προγράμματος και έχουν οριστεί συνήθως μετά από την main(). Άρα για να χρησιμοποιήσουμε μια συνάρτηση πρέπει να κάνουμε τα ακόλουθα: Δήλωση: Επισημαίνουμε στον Compiler ότι θα χρησιμοποιήσουμε στο πρόγραμμα τη συνάρτηση. Η δήλωση λέγεται και Πρωτότυπο. Ορισμός: Περιγράφεται η λειτουργία της συνάρτησης με άλλα λόγια γράφουμε τον κώδικα της συνάρτησης. Κλήση: Καλούμε την συνάρτηση ή αλλιώς εκτελούμε τις εντολές της (τον κώδικα). Δήλωση συνάρτησης Η δήλωση μιας συνάρτησης στο πρόγραμμα συντάσσεται ως εξής: int function(int param1, int param2); όπου: int Τύπος επιστρεφόμενης τιμής function Όνομα συνάρτησης int param1 Τύπος και Όνομα παραμέτρου 1 12

13 int param2 Τύπος και Όνομα παραμέτρου 2 ; τερματικό εντολής Το Πρότυπο (ή αλλιώς επικεφαλίδα της συνάρτησης) έχει όνομα, εισόδους (παράμετροι με τύπο) αλλά και έξοδο (τύπος επιστρεφόμενης τιμής) Το Πρότυπο της συνάρτησης είναι μία εντολή άρα θα τελειώνει με τερματικό εντολής (;). Στη δήλωση (Πρότυπο) και τη κλήση μιας συνάρτησης χρησιμοποιούμε πάντα τερματικό εντολής. Στον ορισμό της ποτέ. Ορισμός συνάρτησης Πιο κάτω βλέπουμε τον ορισμό μιας συνάρτησης στην C++ Επικεφαλίδα συνάρτησης int function(int param1, int param2) εντολή1; εντολή2; return (value); Λέξη κλειδί Τιμή επιστροφής σώμα συνάρτησης Στον ορισμό της συνάρτησης (δηλαδή στην περιγραφή της λειτουργίας της συνάρτησης) χρησιμοποιούμε την επικεφαλίδα της συνάρτησης, δηλαδή: α) το όνομά της, β) τις παραμέτρους στο όρισμά της και 13

14 γ) μέσα σε ένα ζεύγος αγκίστρων, τις εντολές της συνάρτησης καθώς και τις τοπικές μεταβλητές που χρησιμοποιεί. Επίσης την λέξη return αν η συνάρτηση πρέπει να επιστρέφει μία τιμή. Στον ορισμό της συνάρτησης δεν χρησιμοποιούμε το ερωτηματικό. Σημ. Εάν δεν χρησιμοποιήσουμε πρωτότυπο τότε θα πρέπει να ορίζουμε την συνάρτηση πριν από την main() (πριν από την κλήση της). Κλήση συνάρτησης Κατά την κλήση μιας συνάρτησης μέσα σε ένα πρόγραμμα χρησιμοποιούνται: α) το όνομά της, β) οι πραγματικές παράμετροι εάν υπάρχουν και γ) το τερματικό εντολής. Δεν χρησιμοποιούμε τον τύπο επιστροφής. void main() Εντολή1; Εντολή2; function (param1, param2); // κλήση συνάρτησης Εντολή3; Συνάρτηση χωρίς επιστρεφόμενη τιμή Οι συναρτήσεις εάν δεν επιστρέφουν τιμή τότε ο τύπος επιστροφής τιμής δηλώνεται void και δεν υπάρχει μέσα στο σώμα της συνάρτησης η λέξη κλειδί return. 14

15 Στο παράδειγμα που ακολουθεί, βλέπουμε τον ορισμό της συνάρτησης tempmesure() που δεν επιστρέφει κάποια τιμή. void tempmesure() εντολή1; εντολή2; Συνάρτηση με επιστρεφόμενη τιμή Οι συναρτήσεις εάν επιστρέφουν τιμή, τότε ο τύπος επιστροφής τιμής δηλώνεται ως int ή float και μέσα στο σώμα της συνάρτησης υπάρχει η λέξη κλειδί return η οποία μας επιστρέφει μια τιμή. Στο παράδειγμα που ακολουθεί, βλέπουμε τον ορισμό της συνάρτησης tempmesure() που επιστρέφει την τιμή που προκύπτει, από το γινόμενο των παραμέτρων x και y που είναι και τα ορίσματα της συνάρτησης. int tempmesure(int x, int y) εντολή1; return x*y; Επιστρεφόμενες τιμές Μια συνάρτηση μπορεί να επιστρέφει: a) μία τιμή δηλαδή: return 10; 15

16 b) μία παράσταση δηλαδή: return (x>3); (Εδώ επιστρέφεται 0 εάν η παράσταση στην παρένθεση είναι αληθής ή 1 αν είναι ψευδής και όχι την τιμή του x). c) την τιμή επιστροφής μιας συνάρτησης δηλαδή: return (FunctionOne()); d) ή ακόμα μπορούμε να έχουμε μέσα σε μία συνάρτηση περισσότερες από μία επιστροφές τιμών δηλαδή: (return 5; else return -1;) Τοπικές μεταβλητές Τοπικές μεταβλητές είναι οι μεταβλητές που δηλώνονται και έχουν εμβέλεια μόνο μέσα στην ίδια τη συνάρτηση. Όταν η συνάρτηση επιστρέφει τότε οι μεταβλητές αυτές δεν είναι πλέον διαθέσιμες. Από αυτό συμπεραίνουμε ότι οι μεταβλητές αυτές δεσμεύουν μνήμη μόνο κατά την εκτέλεση της συνάρτησης. Άρα μετά το τέλος της συνάρτησης την αποδεσμεύουν. Οι μεταβλητές αυτές δηλώνονται όπως και κάθε άλλη μεταβλητή. Επίσης τοπικές μεταβλητές θεωρούμε και τις παραμέτρους (ή αλλιώς τα ορίσματα) της συνάρτησης. Τοπικές θεωρούνται και οι μεταβλητές που δηλώνονται μέσα στην main(). Καθολικές μεταβλητές Καθολικές μεταβλητές λέγονται αυτές οι μεταβλητές που δηλώνονται έξω από μία συνάρτηση (έξω και από την main) και έχουν καθολική εμβέλεια. 16

17 Οι μεταβλητές αυτές δεσμεύουν μνήμη καθ όλη την διάρκεια εκτέλεσης του προγράμματος. Είναι διαθέσιμες δηλαδή για οποιαδήποτε συνάρτηση μέσα στο πρόγραμμα αλλά και για την main(). Καλό είναι να αποφεύγονται γιατί μπερδεύουν τον κώδικα του προγράμματος και οδηγούν πολλές φορές σε σφάλματα. Συναρτήσεις με πίνακες ως παραμέτρους Μπορούμε να χρησιμοποιήσουμε στην κλήση μιας συνάρτησης σαν πραγματική παράμετρο το όνομα ενός πίνακα. Στην προκειμένη περίπτωση δεν στέλνουμε στην συνάρτηση όλο τον πίνακα αλλά την διεύθυνση του πρώτου του στοιχείου. Στην δήλωση της συνάρτησης ορίζουμε και τον τύπο του τοπικού πίνακα χωρίς το πλήθος των στοιχείων του. Άρα στον μεταγλωττιστή στέλνουμε ουσιαστικά το πρώτο byte και τον αριθμό bytes των στοιχείων του δηλαδή το μέγεθός του. Δήλωση κλήση ορισμός με όρισμα πίνακα Δήλωση συνάρτησης με πίνακα ως παράμετρο: float function_name (float Array_name[]); όπου: float function_name τύπος επιστροφής και όνομα συνάρτησης float Array_name[] τύπος και όνομα πίνακα χωρίς δήλωση στοιχείων 17

18 Κλήση συνάρτησης με πίνακα ως παράμετρο: void main() float Ar[N]; function_name (Ar); // κλήση με όρισμα πίνακα Ορισμός συνάρτησης με πίνακα ως παράμετρο: float function_name (float Array_name[]) Προταση_1; Συναρτήσεις με αναδρομή και επανάληψη Αναδρομικές λέγονται οι συναρτήσεις που καλούν τον εαυτό τους. Χρησιμοποιούνται σε επίλυση πολύπλοκων προβλημάτων. Λόγω του ότι το πρόγραμμα στο οποίο χρησιμοποιούμε αναδρομικές συναρτήσεις γίνεται αργό, καλό θα είναι είτε να χρησιμοποιούμε με μέτρο την αναδρομή ή να χρησιμοποιούμε συναρτήσεις με επανάληψη (loop). Οι συναρτήσεις με επανάληψη καλούνται να λύσουν το πρόβλημα με την χρήση δομών επανάληψης (π.χ. for). Υπερφόρτωση συναρτήσεων Πολλές φορές πρέπει να χρησιμοποιήσουμε πολλές διαφορετικές συναρτήσεις που κάνουν παρόμοιες (συναφείς) δουλειές, αλλά έχουν διαφορετικά ονόματα που πρέπει να θυμόμαστε για να τις χρησιμοποιούμε μέσα στο πρόγραμμα. Για να κάνουμε την ζωή μας πιο εύκολη, χρησιμοποιούμε το ίδιο όνομα για όλες τις όμοιες (συναφείς) συναρτήσεις, με τα ορίσματα τις κάθε μιας ξεχωριστά 18

19 και στην δήλωση και στην κλήση αλλά και στον ορισμό. Αυτή η διαδικασία στον αντικειμενοστραφή προγραμματισμό ονομάζεται υπερφόρτωση συναρτήσεων. Συναρτήσεις INLINE Όταν ορίσουμε μία συνάρτηση inline τότε ο compiler αντιγράφει τις εντολές της συνάρτησης στην καλούσα συνάρτηση. Με αυτό τον τρόπο το πρόγραμμα γίνεται πιο γρήγορο στις περιπτώσεις που πρέπει να κληθεί μία συνάρτηση πολλές φορές μέσα από μία άλλη. Είναι σαν να έχουμε γράψει τις εντολές της συνάρτησης μέσα στην καλούσα συνάρτηση. Αυτό το κάνουμε όταν η συνάρτηση που καλούμε έχει συνήθως μία εντολή. 19

20 ΠΑΡΑΔΕΙΓΜΑΤΑ ΧΡΗΣΗΣ ΣΥΝΑΡΤΗΣΕΩΝ Πολλές εντολές επιστροφής Το παρακάτω πρόγραμμα διπλασιάζει ένα ποσό που του δίνει ο χρήστης μεταξύ 0 και Εάν το ποσό που εισήχθη είναι μεγαλύτερο από 1000 το πρόγραμμα βγάζει μήνυμα λάθους. #include <iostream.h> int diplasio(int posogiadiplasiasmo); int main() int apotelesma=0; int posoeisagomeno; cout<<"dose poso metaxy 0 kai 1000 gia na to diplasiaso: "; cin>>posoeisagomeno; cout<< "\nprin kaleso thn diplasio... "; cout<< "\neisagomeno poso: "<<posoeisagomeno<<endl; cout<< "\ndiplasio: "<<apotelesma<< "\n\n"; apotelesma=diplasio(posoeisagomeno); if (apotelesma==-1) cout<<"\nepistrofh apo thn diplasio...\n"; cout<<"to poso pou edoses einai megalytero apo 1000\n\n"; else cout<< "\nepistrofh apo thn diplasio..."; cout<< "\neisagomeno poso: "<<posoeisagomeno<<endl; cout<< "\ndiplasio: "<<apotelesma<< "\n\n"; return 0; int diplasio(int pragmatiko) if (pragmatiko<=1000) return pragmatiko * 2; else return -1; 20

21 Πέρασμα ορισμάτων με τιμή (παράμετροι σαν τοπικές μεταβλητές) Το παρακάτω πρόγραμμα κάνει αλλαγή θέσης 2 τιμών τοπικών μεταβλητών χωρίς να επηρεάζονται οι αρχικές μεταβλητές. #include <iostream.h> void swap(int x, int y); int main() int a,b; cout<<"dose a: "<<endl; cin>>a; cout<<"dose b: "<<endl; cin>>b; cout<<"main. Prin to swap, a: "<<a<<" b: "<<b<<"\n"; swap(a,b); cout<<"main. Meta to swap, a: "<<a<<" b: "<<b<<"\n"; return 0; void swap(int x, int y) int temp; cout<<"swap. Prin to swap, x: "<<x<<" y: "<<y<<"\n"; temp=x; x=y; y=temp; cout<<"swap. Meta to swap, x: "<<x<<" y: "<<y<<"\n"; Σύντομη εξήγηση του προγράμματος. Σε αυτό το πρόγραμμα ένα αντίγραφο των τιμών των μεταβλητών a,b περνούν στις x,y. Στην έξοδο έχουμε την αντιστροφή των μεταβλητών x,y χωρίς να επηρεαστούν οι τιμές των μεταβλητών a,b 21

22 Υπερφόρτωση συναρτήσεων Θέλουμε να φτιάξουμε ένα πρόγραμμα που να κάνει τα εξής: 1. Να τυπώνει στην οθόνη 50 μηδενικά (0), 2. Να τυπώνει στην οθόνη 50 χαρακτήρες που θα καθορίζονται από την κλήση της συνάρτησης και 3. Να τυπώνει στην οθόνη χαρακτήρες που ο χαρακτήρας αλλά και ο αριθμός των χαρακτήρων να καθορίζονται στην κλήση της συνάρτησης. Για να το πετύχουμε θα χρησιμοποιήσουμε μία συνάρτηση με υπερφόρτωση. #include <iostream.h> void printfunc(); void printfunc(char ch); void printfunc(char ch, int n); void main() printfunc(); printfunc('/'); printfunc('%',40); void printfunc() int i; for (i=0; i<50; i++) cout << "0"; cout << endl; void printfunc(char ch) int i; for (i=0; i<50; i++) cout << ch; cout << endl; void printfunc(char ch, int n) int i; for (i=0; i<n; i++) cout << ch; cout << endl; 22

23 Υπερφόρτωση συναρτήσεων (με προεπιλεγμένα ορίσματα) Παρακάτω βλέπουμε το προηγούμενο πρόγραμμα που χρησιμοποιεί μία συνάρτηση με υπερφόρτωση και προεπιλεγμένα ορίσματα - και 50 #include <iostream.h> void printfunc(char ch='-', int n=50); void main() printfunc(); printfunc('/'); printfunc('%',40); void printfunc(char ch, int n) int i; for (i=0; i<n; i++) cout << ch; cout << endl; Σύντομη εξήγηση του προγράμματος. Εδώ το πρόγραμμα θα χρησιμοποιήσει (καλέσει) την συνάρτηση 3 φορές. Την πρώτη φορά το loop που βρίσκεται μέσα στον ορισμό της συνάρτησης θα χρησιμοποιήσει και τα δύο προεπιλεγμένα ορίσματα που βρίσκονται μέσα στο πρωτότυπο. Την δεύτερη φορά θα χρησιμοποιήσει το όρισμα της κλήσης συνάρτησης και το δεξί του πρωτοτύπου και την τρίτη φορά θα χρησιμοποιήσει τα ορίσματα που βρίσκονται στη κλήση της συνάρτησης. 23

24 Προκαθορισμένες τιμές παραμέτρων. Πιο κάτω βλέπουμε ένα πρόγραμμα που υπολογίζει τον όγκο ενός κύβου χρησιμοποιώντας προκαθορισμένες τιμές. #include <iostream.h> int ogkoskyvou(int mhkos, int platos = 30, int ypsos = 2); int main() int mhkos = 50; int platos = 20; int ypsos = 5; int ogkos; ogkos = ogkoskyvou(mhkos, platos, ypsos); cout << "1h Klhsh Synarthshs o ogkos einai: " << ogkos << "\n"; ogkos = ogkoskyvou(mhkos, platos); cout << "2h Klhsh Synarthshs o ogkos einai: " << ogkos << "\n"; ogkos = ogkoskyvou(mhkos); cout << "3h Klhsh Synarthshs o ogkos einai: " << ogkos << "\n"; return 0; ogkoskyvou(int mhkos, int platos, int ypsos) return (mhkos * platos * ypsos); Σύντομη εξήγηση του προγράμματος. Εδώ το πρόγραμμα θα χρησιμοποιήσει (καλέσει) την συνάρτηση 3 φορές με διαφορετικές κάθε φορά παραμέτρους κατά την κλήση. Την πρώτη φορά θα υπολογιστεί ο όγκος χρησιμοποιώντας τις τιμές των παραμέτρων που έχουν οριστεί μέσα στην main. Την δεύτερη φορά χρησιμοποιώντας τις τιμές δύο εκ των παραμέτρων που έχουν οριστεί μέσα στην main και την τελευταία στη σειρά στο πρωτότυπο και τη Τρίτη φορά χρησιμοποιώντας την τιμή της μιας παραμέτρου που έχει οριστεί μέσα στην main και την 2η και 3η κατά σειρά στο πρωτότυπο. 24

25 Κλήση συνάρτησης από συνάρτηση Το παρακάτω πρόγραμμα υπολογίζει εάν ο αριθμός που εισάγει ο χρήστης είναι άρτιος ή περιττός. Εάν δοθεί σαν επιλογή ο αριθμός 0 τότε το πρόγραμμα τερματίζεται. #include <iostream.h> void peritos(int a); void artios(int a); int main() int i; do cout<<"dose enan arithmo (0 gia EXODO): "; cin>>i; peritos(i); while (i!=0); return 0; void peritos(int a) if ((a%2)!=0) cout<<"o arithmos pou edoses einai PERITOS.\n"; else artios(a); void artios(int a) if ((a%2)==0) cout<<"o arithmos pou edoses einai ARTIOS.\n"; else peritos(a); Σύντομη εξήγηση του προγράμματος. Εδώ το πρόγραμμα θα βρει εάν ο αριθμός που εισήχθη είναι άρτιος ή περιττός με την χρήση κλήσης συνάρτησης από συνάρτηση. Η πρώτη συνάρτηση καλείται μέσα στην main. Εκεί ελέγχεται εάν ο αριθμός που εισήχθη είναι το 0 κάτι που προκαλεί το τερματισμό του προγράμματος. Στην πρώτη συνάρτηση (peritos) ελέγχεται εάν το υπόλοιπο της διαίρεσης του αριθμού δεν είναι 0 τότε ο αριθμός είναι περιττός αλλιώς καλείται η δεύτερη συνάρτηση (artios) που ελέγχει με την σειρά της εάν ο αριθμός είναι άρτιος. 25

26 INLINE συναρτήσεις Το παρακάτω πρόγραμμα διπλασιάζει 3 φορές διαδοχικά μια τιμή εισόδου με την χρήση INLINE συνάρτησης. #include <iostream.h> inline int Diplasio(int); int main() int timh; cout<<"dose MIA TIMH: "; cin>>timh; cout<<"\ndiadoxikos DIPLASIASMOS TIMHS\n"; cout<<"\narxikh TIMH: "<<timh<<endl; timh=diplasio(timh); cout<<"timh1 (ARXIKH TIMH x 2): "<<timh<<endl; timh=diplasio(timh); cout<<"timh2 (TIMH1 x 2): "<<timh<<endl; timh=diplasio(timh); cout<<"timh3 (TIMH2 x 2): "<<timh<<endl; cout<<endl; return 0; int Diplasio(int timh) return 2*timh; Σύντομη εξήγηση του προγράμματος. Εδώ έχουμε ορίσει μία inline συνάρτηση (Diplasio) που την καλούμε μέσα στην main τρεις φορές. Ουσιαστικά ο compiler αντιγράφει τον κώδικα της συνάρτησης σε κάθε σημείο της main που καλείται η συνάρτηση. Με αυτό τον τρόπο δεν έχουμε τρεις μεταπηδήσεις από την main στην συνάρτηση και έτσι κερδίζουμε χρόνο κατά την εκτέλεση του προγράμματος. Χρησιμοποιούμε inline συναρτήσεις όταν η συνάρτηση έχει μία έως δύο εντολές και χρειάζεται να την καλέσουμε μέσα στην main πολλές φορές. 26

27 ΚΛΑΣΕΙΣ - ΑΝΤΙΚΕΙΜΕΝΑ Τι είναι κλάση Κλάση είναι μια συλλογή από μεταβλητές. Αλλιώς είναι ένα σύνολο από: δεδομένα που δηλώνουν τα χαρακτηριστικά της κλάσης (τι είναι) και συναρτήσεις που προδιαγράφουν την συμπεριφορά της κλάσης (τι κάνει). Π.χ. μια κλάση μπορεί να είναι οι «εργαζόμενοι» με χαρακτηριστικά: Α.Μ, Όνομα, Επώνυμο, ΑΦΜ, Μισθός, Ή ακόμη η «εγγραφή» με χαρακτηριστικά: Κωδικός, Ημερομηνία, Φοιτητής, Μάθημα. Σχηματική παράσταση κλάσης Class Data 1 Data 2 Data 3 Όνομα κλάσης Χαρακτηριστικά κλάσης Data 4 Function 1 Function 2 Function3 Συμπεριφορές κλάσης 27

28 Από τι αποτελείται μία κλάση Η κλάση αποτελείται από δύο συστατικά: Τα δεδομένα (data or attributes) είναι μέλη της κλάσης, λέγονται αλλιώς και δεδομένα μέλη ή μεταβλητές μέλη και είναι αυτά που καθορίζουν την κλάση. Παράδειγμα: η κλάση αυτοκίνητο έχει τροχούς, μηχανή, πόρτες κλπ. Τις συναρτήσεις (functions or methods) ή αλλιώς συναρτήσεις μέλη είναι αυτές που καθορίζουν την συμπεριφορά της κλάσης. Χειρίζονται τις μεταβλητές μέλη και ονομάζονται αλλιώς και μέθοδοι. Παράδειγμα: οι μέθοδοι της κλάσης αυτοκίνητο είναι η Εκκίνηση(), το Φρενάρισμα(), το Σταμάτημα(). Εγκλεισμός Η διαδικασία της συμπερίληψης όλων των πληροφοριών (δεδομένων και συναρτήσεων) σε ένα μέρος (κλάση), λέγεται εγκλεισμός (encapsulation). Αυτό επιτρέπει τους πελάτες της κλάσης (άλλες κλάσεις ή συναρτήσεις) να χρησιμοποιούν την κλάση χωρίς να τους ενδιαφέρει πως δουλεύει. Για παράδειγμα μπορούμε να οδηγούμε ένα αυτοκίνητο χωρίς να μας ενδιαφέρει πως λειτουργεί η μηχανή. Δήλωση μιας κλάσης Η δήλωση μιας κλάσης γίνεται έξω από την main. Αρχίζει με τη δεσμευμένη λέξη class και το όνομα της κλάσης. Ακολουθεί αριστερό άγκιστρο. Κατόπιν ακολουθούν οι λέξεις public ή private (θα αναφερθούμε σε αυτές πιο κάτω) και το κυρίως σώμα της κλάσης που περιέχει τα δεδομένα μέλη και τις συναρτήσεις μέλη. 28

29 Στο τέλος η κλάση κλείνει με το δεξί άγκιστρο και το τερματικό εντολής (ελληνικό ερωτηματικό). Πιο κάτω βλέπουμε την δήλωση της κλάσης Car. class Car public int numofdoors; int numofwheels; Start(); Run(); Break(); ; Τέλος κλάσης Όνομα κλάσης Δεδομένα μέλη Συναρτήσεις μέλη Αντικείμενα μιας κλάσης Για να ορίσουμε ένα αντικείμενο μιας κλάσης στο πρόγραμμα κάνουμε την παρακάτω δήλωση: Όνομα_κλάσης όνομα_αντικειμένου Ορίζουμε ένα αντικείμενο της κλάσης Car που δηλώσαμε προηγουμένως όπως πιο κάτω: Car Van; Ο ορισμός αντικειμένου γίνεται έξω από την κλάση. Το Van είναι ένα αντικείμενο της κλάσης Car. 29

30 Για να δηλώσουμε ότι το αντικείμενο Van έχει 3 πόρτες (δεδομένο), ξεκινά (συνάρτηση) και στρίβει (συνάρτηση) δηλαδή για να έχουμε πρόσβαση στα δεδομένα μέλη και στις συναρτήσεις μέλη του αντικειμένου γράφουμε τις δηλώσεις: Van.numOfDoors=3; Van.Start(); Van.Turn(); Βλέπουμε ότι για να έχει πρόσβαση το αντικείμενο που φτιάξαμε στα δεδομένα και τις συναρτήσεις της κλάσης χρησιμοποιούμε τον τελεστή τελεία (.) που είναι ο τελεστής κλήσης. Το δεδομένο μέλος numofdoors της κλάσης παίρνει την τιμή 3. Οι συναρτήσεις Start() και Turn() είναι δηλωμένες μέσα στην κλάση και καλούνται από το αντικείμενο για να «ξεκινήσει» και στην συνέχεια να «στρίψει». Με αυτόν τον τρόπο το αντικείμενο αποκτά επαφή με τα χαρακτηριστικά του αλλά και με τις συναρτήσεις του. Πρόσβαση στα δεδομένα της κλάσης Στη δήλωση μιας κλάσης χρησιμοποιούμε τις δεσμευμένες λέξεις public (δημόσιο) ή private (ιδιωτικό) για να δηλώσουμε αν τα μέλη της κλάσης είναι δημόσια ή ιδιωτικά προσπελάσιμα. Ιδιωτικά προσπελάσιμα σημαίνει ότι δεν μπορεί να τα δει κανείς εκτός από τις συναρτήσεις της ίδιας της κλάσης στην οποία ανήκουν. Δημόσια προσπελάσιμα σημαίνει ότι μπορούν να τα δουν όλοι. Public ή private δηλώνονται και τα δεδομένα αλλά και οι συναρτήσεις μιας κλάσης. Για να προστατέψουμε τα δεδομένα των αντικειμένων από αλλοιώσεις τα αποκρύπτουμε από πελάτες της κλάσης δηλαδή τα δηλώνουμε private. Ενώ τις συναρτήσεις που πρέπει να έχουν πρόσβαση οι πελάτες της κλάσης τις δηλώνουμε public. Εξ ορισμού τα δεδομένα και οι μέθοδοι είναι ιδιωτικά προσπελάσιμα. Αν δεν χρησιμοποιήσουμε τις δηλώσεις public ή private, τότε 30

31 ούτε τα δεδομένα θα είναι προσπελάσιμα αλλά ούτε και οι μέθοδοι θα μπορούν να χρησιμοποιηθούν από τα αντικείμενα της κλάσης. Σχηματική παράσταση πρόσβασης στην κλάση Private Δεδομένα Public Συναρτήσεις Δήλωση της κλάσης με προσπελασιμότητα class Car pivate Char Model[50]; int numofdoors; int numofwheels; Δεδομένα μέλη ιδιωτικά ορατά public void Start(); void Break(); void Turn(); ; Συναρτήσεις μέλη δημόσια ορατές 31

32 Σχηματική παράσταση της κλάσης Car Ορισμός της μεθόδου Ο ορισμός μεθόδου (συνάρτησης μέλους) γίνεται έξω από την κλάση ως ακολούθως: τύπος Κλάση::συνάρτηση(παράμετροι) Εντολή; Για να δηλώσουμε στον compiler σε ποια κλάση ανήκει η συνάρτηση την οποία ορίζουμε χρησιμοποιούμε τον τελεστή διακρίβωσης εμβέλειας (: :). Σημ. Ο ορισμός μπορεί να γίνει και μέσα στην κλάση χωρίς τον τελεστή (: :). 32

33 Παράδειγμα. Ο ορισμός της υποθετικής μεθόδου start(): void Car::start() Model = Suzuki ; numofdoors = 4; numofwheels = 4; Constructor (συνάρτηση εγκατάστασης) Όπως αρχικοποιούμε τις μεταβλητές μας σε μία τιμή, έτσι αρχικοποιούμε και τα δεδομένα μέλη μιας κλάσης. Αυτό επιτυγχάνεται με την χρήση μιας συνάρτησης μέλος της κλάσης που ονομάζεται συνάρτηση εγκατάστασης ή αλλιώς constructor. Ο constructor: έχει το ίδιο όνομα με την κλάση, δηλώνεται μέσα ή και έξω από την κλάση, μπορεί να έχει παραμέτρους που μπορεί να είναι προκαθορισμένες τιμές, δεν επιστρέφει τιμή, ούτε void. Destructor (συνάρτηση καταστροφής) Κατά την κατασκευή του constructor δεσμεύεται χώρος στην μνήμη για να δεχθεί τον constructor. 33

34 Για να καθαρίσουμε την μνήμη από το αντικείμενο όταν αυτό τελειώσει την δουλειά του φτιάχνουμε μαζί του και μια συνάρτηση καταστροφής ή αλλιώς destructor. Ο destructor: ελευθερώνει την μνήμη που έχει δεσμευθεί για αντικείμενο. Δεν παίρνει ορίσματα δεν έχει εντολές και δεν επιστρέφει τιμή. Έχει και αυτός το ίδιο όνομα με την κλάση έχοντας μπροστά από το όνομά του μια περισπωμένη ( ~ ). Παράδειγμα δήλωσης και ορισμού Πιο κάτω ακολουθεί ένα παράδειγμα δήλωσης Constructor και Destructor και ορισμού τους έξω από την κλάση. class Dog //dhlosh klashs private int DogAge; //dedomeno melos public: Dog(); //dhlosh constructor ~Dog(); //dhlosh destructor ; //telos klashs Dog::Dog() DogAge=0; Dog::~Dog() // den exei entoles //orismos constructor //arxikopoihsh toy dedomenoy //orismos tou destructor 34

35 Πιο κάτω ακολουθεί ένα παράδειγμα δήλωσης Constructor και Destructor και ορισμού τους μέσα στην κλάση. class Dog //dhlosh klashs public: Dog() //orismos tou constructor DogAge =0; ~Dog() //orismos tou destructor ; //telos klashs Constructor με υπερφόρτωση Όπως είδαμε μπορούμε να φτιάξουμε μία συνάρτηση εγκατάστασης (constructor) και με αυτήν να δίνουμε αρχικές τιμές σε αντικείμενα την στιγμή που αυτά δημιουργούνται. Αυτό επιτυγχάνεται ορίζοντας παραμέτρους στις συναρτήσεις αυτές. Μπορούμε επίσης στην ίδια κλάση να χρησιμοποιούμε constructor με όρισμα και χωρίς. Αυτό ονομάζεται υπερφόρτωση του constructor. Το ποιος constructor εκτελείται κατά την δημιουργία του αντικειμένου εξαρτάται από τα ορίσματα του constructor. 35

36 Παράδειγμα υπερφόρτωσης constructors Dog() //constructor xoris orisma (1) DogAge=0; Dog(int initialage) //constructor me orisma (2) DogAge=initialAge; ~Dog() //destructor Εδώ χρησιμοποιούμε έναν constructor με προκαθορισμένη τιμή αρχικοποίησης (1) DogAge=0 και έναν με τιμή αρχικοποίησης από το αντικείμενο(2) DogAge=initialAge. Χρήση αντικειμένου μέσα σε συναρτήσεις Μπορούμε να χρησιμοποιήσουμε αντικείμενα μέσα σε συναρτήσεις: σαν παραμέτρους συνάρτησης (πρόσβαση των παραμέτρων της συνάρτησης που δέχεται τα αντικείμενα στα δεδομένα των αντικειμένων). αλλά και να φτιάξουμε συναρτήσεις που να επιστρέφουν αντικείμενα (ο τύπος επιστροφής της συνάρτησης είναι η ίδια η κλάση). Μπορούμε να δηλώσουμε αντικείμενα μιας κλάσης α μέσα σε μια άλλη κλάση β για να μπορεί η κλάση β να έχει πρόσβαση στα δεδομένα της κλάσης α. 36

37 Παράδειγμα χρήσης αντικειμένου σαν όρισμα συνάρτησης void athrypoloipo(logariasmos a, logariasmos b) ypoloipo=a.ypoloipo+b.ypoloipo; log3.athrypoloipo(log1,log2); Όνομα κλάσης σαν τύπος Κλήση της συνάρτησης από το log3 με ορίσματα το log1 και το log2 Στο παραπάνω παράδειγμα φτιάχνουμε μία συνάρτηση athrypoloipo() η οποία προσθέτει τα υπόλοιπα των δύο αντικειμένων log1 και log2. Το αντικείμενο log3 κάνει κλήση αυτής της συνάρτησης από όπου μεταβιβάζονται τα αντικείμενα log1 και log2 στις παραμέτρους της συνάρτησης a και b αντίστοιχα. Μέσα στο σώμα της συνάρτησης βλέπουμε την πρόσβαση αυτής στο δεδομένο του κάθε αντικειμένου (a.ypoloipo b.ypoloipo). Τα δεδομένα αυτά αν και είναι ιδιωτικά μπορούν να προσπελαστούν από την συνάρτηση, γιατί τα αντικείμενα α και β αλλά και η ίδια η συνάρτηση είναι μέλη της κλάσης. 37

38 Παράδειγμα επιστροφής αντικειμένου από συνάρτηση logariasmos athrypoloipo(logariasmos log) logariasmos apotelesma; apotelesma.ypoloipo=ypoloipo+log.ypoloipo; return apotelesma; log3=log1.athrypoloipo(log2); Κλήση της συνάρτησης από το log1 με όρισμα το log2 και εκχώρηση τιμής στο log3 Σε αυτό το παράδειγμα μεταβιβάζουμε στην συνάρτηση athrypoloipo μόνο το ένα αντικείμενο στην παράμετρο log (το log2). Η τιμή του δεδομένου ypoloipo προστίθεται στην τιμή του δεδομένου του αντικειμένου που καλεί την συνάρτηση δηλ του log1. Μέσα στην συνάρτηση ορίζουμε ένα αντικείμενο apotelesma στο οποίο θα εκχωρηθεί η τιμή της πρόσθεσης. Κατόπιν με την εντολή return το αντικείμενο apotelesma επιστρέφεται μέσα στην καλούσα συνάρτηση main() και αποδίδεται στο αντικείμενο log3. Δηλώσεις κλάσεων σε αρχεία επικεφαλίδας Τις κλάσεις έχουμε μάθει να τις δηλώνουμε μέσα στο κυρίως πρόγραμμα. Ένας άλλος τρόπος που υιοθετείται και είναι ο πιο σωστός είναι, τις δηλώσεις να τις κάνουμε σε ένα άλλο αρχείο το λεγόμενο αρχείο επικεφαλίδας και να το επισυνάπτουμε μέσα στο αρχείο του κυρίως προγράμματος μας. Τα αρχεία αυτά μπορεί να έχουν οποιοδήποτε όνομα αλλά επέκταση.hpp. (π.χ. το πρόγραμμα μας είναι το test.cpp το αρχείο κεφαλίδας είναι το car.hpp). 38

39 Η επόμενη δουλειά είναι να εισάγουμε το αρχείο κεφαλίδας car.hpp μέσα στο αρχείο κώδικα test.cpp. Με αυτόν τον τρόπο χρησιμοποιούμε την κλάση μας σε κάθε διαφορετικό πρόγραμμα που φτιάχνουμε. Έτσι οι πελάτες της κλάσης οι οποίοι δεν ενδιαφέρονται για τις λεπτομέρειες της κλάσης, μπορούν να την χρησιμοποιούν αφού όλες οι δηλώσεις υπάρχουν μέσα στο αρχείο επικεφαλίδας το οποίο διαβάζει ο compiler. Αυτό είναι το πλεονέκτημα της επαναχρησιμοποίησης κώδικα. Παράδειγμα: Το αρχείο που έχει την δήλωση της κλάσης dog είναι το dog.hpp. class dog Private: DogAge; Public: int GetAge() return itsage; ; 39

40 Το αρχείο του κυρίως προγράμματος είναι το dog.cpp το οποίο συμπεριλαμβάνει το αρχείο κεφαλίδας dog.hpp ως εξής: #include <iostream.h> #include dog.hpp void main() Σταθερές συναρτήσεις μέλη Μπορούμε να ορίσουμε μια συνάρτηση σαν σταθερή (const) όταν θέλουμε να διασφαλίσουμε ότι αυτή η συνάρτηση δεν θα αλλάξει την τιμή οποιουδήποτε δεδομένου μέλους της κλάσης μας. Ο ορισμός γίνεται ως εξής: void function() const; Αν δηλώσουμε ως σταθερά μία συνάρτηση που πρέπει να επιφέρει αλλαγές σε δεδομένα μέλη της κλάσης μας, τότε θα πάρουμε μήνυμα λάθους από τον compiler. Για παράδειγμα: Παράδειγμα: Μέσα στην κλάση Dog έχουμε την συνάρτηση setage() που αλλάζει το μέλος DogAge και την GetAge() η οποία απλώς μας επιστρέφει την τιμή του μέλους DogAge. Τη συνάρτηση GetAge() θα ορίσουμε ως σταθερά (const). 40

41 Δηλαδή ο ορισμός των συναρτήσεων θα είναι: void SetAge(int age); int GetAge() const; Μέθοδοι INLINE Όπως κάνουμε τις συναρτήσεις inline έτσι μπορούμε να κάνουμε και τις μεθόδους μιας κλάσης inline. Δηλαδή η μέθοδος GetAge() που ορίζεται έξω από την κλάση Dog: Inline int Dog::GetAge() return DogAge; Θα γίνει πιο σωστά μέσα στην κλάση Dog: Inline int GetAge()return DogAge; Στατικά δεδομένα μέλη Όταν τα δεδομένα μέλη ορίζονται ως ιδιωτικά, τότε το κάθε νέο αντικείμενο που δημιουργείται, παίρνει ένα ξεχωριστό δικό του αντίγραφο για τα δεδομένα αυτά. Εάν ορίσουμε κάποιο δεδομένο σαν στατικό (static), τότε όλη η κλάση έχει μόνο ένα αντίγραφο του δεδομένου, όσα αντικείμενα και αν δημιουργηθούν. Ένα στατικό δεδομένο αρχικοποιείται στην κλάση και αλλάζει τιμή με κάθε αντικείμενο.τα στατικά δεδομένα είναι χρήσιμα, όταν πρέπει όλα τα αντικείμενα μιας κλάσης, να μοιραστούν μια πληροφορία. private: static count; 41

42 ΠΑΡΑΔΕΙΓΜΑΤΑ ΚΛΑΣΕΩΝ Δήλωση μιας απλής κλάσης Ορισμός μεθόδων μέσα στην κλάση #include <iostream.h> class foithths //dhlosh klashs private: char onoma[30]; float vathmos; public: void readdata() //orismos ths readdata cout << "Dwse onoma:"; cin >> onoma; cout << "Dwse vathmo:"; cin >> vathmos; void printdata() //orismos ths printdata cout<<"to onoma toy foithth einai: "<<onoma<<endl; cout<<"o vathmos toy foithth einai: "<<vathmos<<endl; ; // telos klashs void main() foithths f1, f2; // dhlosh antikeimenwn f1.readdata(); //klhsh synarthshs gia orismo dedomenwn f1.printdata(); //klhsh synarthshs gia emfanish dedomenwn f2.readdata(); f2.printdata(); Σύντομη εξήγηση του προγράμματος. Σε αυτό το παράδειγμα ο ορισμός των μεθόδων (Συναρτήσεων Μελών) γίνεται μέσα στην δήλωση της κλάσης. Τα δεδομένα μέλη είναι ιδιωτικά ορατά δηλ μπορούν να έχουν πρόσβαση σε αυτά οι μέθοδοι της ίδιας της κλάσης και οι μέθοδοι είναι δημόσια ορατές. Κατόπιν δημιουργούμε δύο αντικείμενα της κλάσης φοιτητής και καλούμε για το κάθε αντικείμενο τις συναρτήσεις για την εισαγωγή δεδομένων και την εκτύπωση δεδομένων. 42

43 Ορισμός μεθόδων έξω από την κλάση #include <iostream.h> class foithths //dhlosh klashs private: char onoma[30]; float vathmos; public: void readdata(); void printdata(); ; // telos klashs //orismos ths readdata void foithths::readdata() cout << "Dwse onoma:"; cin >> onoma; cout << "Dwse vathmo:"; cin >> vathmos; //orismos ths printdata void foithths::printdata() cout << "To onoma toy foithth einai: " << onoma << endl; cout << "O vathmos toy foithth einai: " << vathmos << endl; void main() foithths f1, f2; // dhlosh antikeimenwn f1.readdata(); //klhsh synarthshs gia orismo dedomenwn f1.printdata(); //klhsh synarthshs gia emfanish dedomenwn f2.readdata(); f2.printdata(); Σύντομη εξήγηση του προγράμματος. Σε αυτό το παράδειγμα ο ορισμός των μεθόδων (Συναρτήσεων Μελών) γίνεται έξω από την κλάση. Για να έχουν πρόσβαση τα αντικείμενα στις μεθόδους, ο ορισμός των μεθόδων γίνεται με τον εξής τρόπο: τύποςσυνάρτησης όνομακλάσης::όνομασυνάρτησης(παράμετροι) Π.χ. void foithths::printdata() 43

44 Απόδοση τιμών μέσα από τις παραμέτρους. #include <iostream.h> # include <string.h> class foithths //dhlosh klashs private: char onoma[30]; float vathmos; public: //orismos ths setdata void setdata(char onoma_new[], int vathmos_new) strcpy(onoma, onoma_new); vathmos=vathmos_new; //orismos ths printdata void printdata() cout<<"to onoma toy foithth einai: "<<onoma<<endl; cout<<"o vathmos toy foithth einai: "<<vathmos<<endl; ; // telos klashs void main() foithths f1; f1.setdata("marios TSOUKALAS", 6.5); f1.printdata(); Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα ορίζουμε μία μέθοδο setdata, ο οποία όταν κληθεί στην main, μεταβιβάζονται οι τιμές MARIOS TSOUKALAS και 6.5 στις αντίστοιχες onoma_new και vathmos_new. Έτσι όταν τρέξει το πρόγραμμα το αντικείμενο θα έχει ήδη τιμές. Χρησιμοποιούμε το αρχείο κεφαλίδας string.h το οποίο περιλαμβάνει την συνάρτηση strcpy για να μεταφέρουμε τις τιμές του πίνακα onoma_new στον πίνακα onoma. χαρακτήρων 44

45 Χειρισμός κλάσης Το παρακάτω πρόγραμμα δημιουργεί (μία κλάση) έναν σκύλο, που ορίζεται η ηλικία του. Κατόπιν ο σκύλος μάς γαυγίζει και μάς λέει την ηλικία του. #include <iostream.h> class Dog // dhlosh ths klashs public: // dhmosia enothta int GetDogAge(); // voithitikh synarthsh void SetDogAge (int age); // voithitikh synarthsh void Bark(); // genikh synarthsh private: // idiotikh enothta int itsage; // metavlhth melous ; //telos klashs /* orismos dhmosias vohthitikhs synarthshs GetAge epistrefei thn timh toy meloys itsage */ int Dog::GetDogAge() return itsage; /* orismos dhmosias vohthitikhs synarthshs SetAge epistrefei thn timh toy meloys itsage */ void Dog::SetDogAge(int age) /* pernaei thn timh ths parametroy age sthn metavlhth itsage */ itsage = age; /* orismos thw methodoy Bark epistrefei void, den exei parametrous typonei Bark sthn othonh */ void Dog::Bark() cout << "Bark!!!\n"; /* dhmiourgia enos skyloy, orismos ths hlikias toy ton kanei na gaygizei kai na leei thn hlikia toy*/ int main() Dog Max; //orismos antikeimenoy Max.SetDogAge(2); //dhlosh timhs sto itsage Max.Bark(); cout << "o Max o skylos moy einai " ; cout << Max.GetDogAge() << " xronwn \n"; //anagnosh timhs Max.Bark(); return 0; //telos ths main 45

46 Σύντομη εξήγηση του προγράμματος. Στην αρχή του προγράμματος δηλώνουμε την κλάση Dog η οποία περιέχει τις δύο δημόσιες βοηθητικές μεθόδους (συναρτήσεις) GetDogAge(), SetDogAge(int age) και την μία δημόσια γενική Bark() καθώς και την ιδιωτική μεταβλητή μέλους itsage. Αμέσως μετά ορίζεται η συνάρτηση μέλος GetDogAge() η οποία επιστρέφει την τιμή της itsage. Εδώ βλέπουμε ότι η main() έχει πρόσβαση μόνο στην GetDogAge() που είναι δημόσια και όχι στην itsage που είναι ιδιωτική. Η GetDogAge() που είναι συνάρτηση μέλος της κλάσης Dog έχει πρόσβαση στην itsage και έτσι μπορεί να επιστρέψει την τιμή της στην main(). Στην συνέχεια ορίζεται η συνάρτηση μέλος SetDogAge() που έχει μία ακέραια παράμετρο και δίνει στο itsage την τιμή αυτής της παραμέτρου. Η συνάρτηση αυτή έχει πρόσβαση στην μεταβλητή μέλος ItsAge λόγω του ότι είναι μέλος της κλάσης Dog. Στο επόμενο βήμα ορίζουμε την γενική δημόσια συνάρτηση Bark() η οποία τυπώνει στην οθόνη την λέξη Bark (Γαβ). Αμέσως μετά αρχίζει η main() η οποία ορίζει ένα αντικείμενο Max της κλάσης Dog, δίνει την τιμή 2 στην μεταβλητή μέλος itsage μέσω της μεθόδου SetDogAge() η οποία ξεκινά με το όνομα του αντικειμένου, τον τελεστή μέλους (.) και το όνομα της μεθόδου. Ύστερα καλείται η συνάρτηση μέλος Bark() δύο φορές και ενδιαμέσως τυπώνεται ένα μήνυμα που χρησιμοποιεί την συνάρτηση μέλος GetDogAge() του αντικειμένου Max για να εμφανίσει στην οθόνη την τιμή της itsage που εισήχθη πριν. 46

47 Το πιο πάνω πρόγραμμα με την χρήση constructor με όρισμα και destructor. #include <iostream.h> class Dog public: Dog(int initialage); ~Dog(); int GetDogAge(); void SetDogAge(int age); void Bark(); private: int itsage; ; //telos ths klashs //dhlosh constructor me orisma //dhlosh destructor Dog::Dog(int initialage) //orismos constructor toy Dog itsage=initialage; Dog::~Dog() //orismos tou destructor int main() /* kathorismos ths hlikias xoris na klhthei h SetDogAge Orismos antikeimenoy me perasma timhs ston constructor tou Max */ Dog Max(2); Max.Bark(); cout << "o Max o skylos moy einai " ; cout << Max.GetDogAge() << " xronwn \n"; Max.Bark(); Max.SetDogAge(9); //klhsh ths SetDogAge gia allagh hlikias cout << "twra o Max o skylos moy egine " ; cout << Max.GetDogAge() << " xronwn \n"; Max.Bark(); Max.Bark(); return 0; //telos ths main Σύντομη εξήγηση του προγράμματος. Εδώ βλέπουμε την χρήση των constructor με όρισμα και destructor. Στην main(), η ηλικία καθορίστηκε από την αρχή (τιμή 2 στην μεταβλητή μέλος 47

48 itsage) και δεν χρειάστηκε να κληθεί η SetDogAge(). Η SetDogAge() καλείται μετέπειτα για να αλλάξουμε την ηλικία σε 9. Επισημαίνουμε ότι όταν ορίζουμε constructor πρέπει υποχρεωτικά να ορίσουμε και destructor. Μεταφορά δεδομένων κλάσης σε συνάρτηση #include <iostream.h> #include <process.h> #include <math.h> class paradeigma private: int a,b,s,c; public: void getdata(int k, int l) //metafora timon sthn klash a=k; b=l; int calcdatasqr() //athroisma ton tetragwnwn s=pow(a,2)+pow(b,2); return s; int calcdatacube() //athroisma ton kyvwn c=pow(a,3)+pow(b,3); return c; void printsqrtdata() //ektyposh athroismatos twn tetragwnwn cout<<" 1os arithmos: "<<a<<endl; cout<<" 2os arithmos: "<<b<<endl; cout<<"athroisma Tetragonon: "<<s<<endl; void printcubedata() //ektyposh athroismatos twn kyvwn cout<<" 1os arithmos: "<<a<<endl; cout<<" 2os arithmos: "<<b<<endl; cout<<"athroisma Kyvon: "<<c<<endl; ; //telos klashs void main() paradeigma par1,par2; //antikeimena ths klashs 48

49 int za,zb,apotsqrt,apotcube; //topikes metavlhtes int float rizasqrt, rizacbrt; //topikes metavlhtes float while(1) //synexomenh epanalhpsi (1>0) cout<<"dose 2 arithmous"<<endl; cout<<"h dose 0 0 gia exodo"<<endl; cin>>za; cin>>zb; if((za==0)&&(zb==0)) //exodus an kai oi 2 arithmoi einai 0 cout<<"exodos apo to programma"<<endl; exit(0); cout<<"**************************************"<<endl; par1.getdata(za,zb); //apostolh timon sthn klash apotsqrt=par1.calcdatasqr(); par1.printsqrtdata(); //ektyposh dedomenon cout<<"to athroisma ton tetragonon einai: "<<apotsqrt<<endl; rizasqrt=sqrt(apotsqrt); //ypologismos tetragonikhs rizas cout<<"h tetragonikh riza toy athroismatos einai: "<<endl; cout<<rizasqrt<<endl; cout<<"**************************************"<<endl; par2.getdata(za,zb); apotcube=par2.calcdatacube(); par2.printcubedata(); cout<<"to athroisma ton kyvon einai: "<<apotcube<<endl; rizacbrt=pow(apotcube, (float)1/3); cout<<"h kyvikh riza toy athroismatos einai: "<<rizacbrt<<endl; //telos main Σύντομη εξήγηση του προγράμματος. Σε αυτό το πρόγραμμα βάζουμε 2 αριθμούς και υπολογίζουμε το άθροισμα των τετραγώνων τους και την τετραγωνική ρίζα του αθροίσματος, καθώς και το άθροισμα των κύβων τους και την κυβική ρίζα του αθροίσματος. Καλούμε τις συναρτήσεις της κλάσης paradeigma στέλνοντας τις τιμές των μεταβλητών που βρίσκονται μέσα στην main(). Μέσα στην main() έχουμε ένα βρόχο while με συνθήκη (1) ή αλλιώς (1>0) που ισοδυναμεί με διαρκή επανάληψη των εντολών του βρόχου. Ο βρόχος τερματίζεται όταν και οι δύο αριθμοί που θα εισαχθούν θα είναι ίσοι με 0 (μέσα σε μία δομή επιλογής if). Για τον υπολογισμό της δύναμης χρησιμοποιούμε την συνάρτηση pow() της βιβλιοθήκης math.h. 49

50 Για τον υπολογισμό της τετραγωνικής ρίζας χρησιμοποιούμε την συνάρτηση sqrt(). Για τον υπολογισμό της κυβικής ρίζας χρησιμοποιούμε την συνάρτηση pow() με ορίσματα τον αριθμό και το 1/3 γιατί από τα μαθηματικά γνωρίζουμε ότι όταν θέλουμε να βρούμε την ρίζα ενός αριθμού αρκεί να τον υψώσουμε σε 1/δύναμη. Επίσης επειδή το 1/3 θεωρείται από την γλώσσα πηλίκο ακεραίων και όταν εφαρμοστεί στην pow() θα δίνει αποτέλεσμα πάντα 1 (γιατί 1/3=0 και αριθμός^0=1) κάνουμε casting σε τύπο float στο πηλίκο. Κλάση με υπερφόρτωση constructor Στο παρακάτω πρόγραμμα δηλώνουμε μία κλάση για τον υπολογισμό του εμβαδού ενός τριγώνου. Κάνουμε χρήση συνάρτησης εγκατάστασης (constructor- destructor) με υπερφόρτωση. #include <iostream.h> class Trigono //dhlodh klashs private: int vash; int ypsos; public: Trigono() //constructor xoris orisma vash = 5; ypsos = 3; Trigono(int v,int y) //constructor me orisma vash = v; ypsos = y; ~Trigono() //destructor int emvado() //synarthsh ypologismoy toy emvadou return (vash*ypsos)/2; ; //telos klashs int main () Trigono TrigA (8,3); //antikeimen ths klashs me times 50

51 Trigono TrigB; //antikeimen ths klashs xoris times /* klhsh synarthshs ypologismoy toy embadoy me taytoxronh ektyposh sthn othonh toy apotelesmatos */ cout << "Emvado Trigonou A: " << TrigA.emvado() << endl; cout << "Emvado Trigonou B: " << TrigB.emvado() << endl; return 0; //telos main Σύντομη εξήγηση του προγράμματος. Σε αυτό το πρόγραμμα φτιάχνουμε μια κλάση Trigono, την οποία θα χρησιμοποιούμε για τον υπολογισμό του εμβαδού ενός τριγώνου. Τα αντικείμενα της κλάσης μπορούν να έχουν δικές τους τιμές (βάση, ύψος) ή να χρησιμοποιούν προεπιλεγμένες. Αυτό γίνεται με την χρήση συναρτήσεων εγκατάστασης (constructor-destructor) με υπερφόρτωση δηλαδή constructor με όρισμα και χωρίς όρισμα. Δήλωση κλάσης χειρισμού προϊόντος #include <iostream.h> class proion //dhlosh klashs private: int code; char name[20]; float init_price; float sales_price; float rate; public: proion() //constructor xwris orisma init_price=0; sales_price=0; ~proion() //synarthsh eisagoghs stoixeiwn void pr_set_data() cout<<"dose KWDIKO: "<<; cin>>code; 51

52 cout<<"dose ONOMA EIDOUS: "<<; cin>>name; cout<<"dose TIMH AGORAS: "<<; cin>>init_price; cout<<"dose POSOSTO KERDOUS (%): "<<; cin>>rate; cout<<" "<<endl; // ektyposh stoixeion me klhsh synarthsewn ypologismwn void pr_print_data() float a; cout<<"kvdikos EIDOUS: "<<code<<endl; cout<<"onoma EIDOUS: "<<name<<endl; cout<<"timh AGORAS: "<<init_price<<" EURO"<<endl; //ypologismos kerdoys a=calc_profit_price(init_price, rate); sales_price=calc_final_price(a); //ypologismos FPA cout<<"timh PWLHSHS XORIS FPA: "<<a<<" EURO"<<endl; cout<<"timh PWLHSHS ME FPA: "<<sales_price<<" EURO"<<endl; cout<<" "<<endl; //synarthsh ypologismou ths timhs polhshs float calc_profit_price(float x, float y) return x+=x*y/100; //synarthsh ypologismoy toy FPA 23% float calc_final_price(float z) return z+=z*24/100; // epistrofh timhs agoras float get_init_price() return init_price; // epistrofh telikhs timhs float get_sales_price() return sales_price; ; //telos klashs void main() 52

53 proion pr1,pr2; pr1.pr_set_data(); pr2.pr_set_data(); pr1.pr_print_data(); pr2.pr_print_data(); // telos main Σύντομη εξήγηση του προγράμματος. Στο παραπάνω πρόγραμμα δηλώνουμε μια κλάση proion η οποία έχει ως δεδομένα μέλη τα εξής: κωδικός, όνομα, τιμή αγοράς, τιμή πώλησης με ΦΠΑ (23%), ποσοστό κέρδους. Έχει επίσης και τις μεθόδους: α) εισαγωγή στοιχείων στα αντικείμενα, β) εκτύπωση των στοιχείων των αντικειμένων, γ) υπολογισμός του κέρδους πάνω στην τιμή αγοράς, δ) υπολογισμός τελικής τιμής με ΦΠΑ, ε) επιστροφή της αρχικής τιμής (τιμή αγοράς) και ζ) επιστροφή της τελικής τιμής (με ΦΠΑ). Μέσα στην μέθοδο pr_print_data καλούμε την μέθοδο calc_profit_price που υπολογίζει την τελική τιμή του είδους (με ορίσματα την τιμή αγοράς του αντικειμένου και το ποσό του κέρδους) και την calc_final_price με την οποία υπολογίζουμε την τελική τιμή του είδους με ΦΠΑ 24% με όρισμα την τιμή επιστροφής της calc_profit_price Έχουμε δηλώσει constructor που αρχικοποιεί τα δεδομένα: τιμή αγοράς και τελική τιμή στην τιμή 0. Τα αντικείμενα που κατασκευάζουμε στην main() καλούν τις μεθόδους της κλάσης για εισαγωγή και εκτύπωση των δεδομένων. 53

54 Constructor με υπερφόρτωση #include <iostream.h> class logariasmos private: float ypoloipo; public: logariasmos() // constructor xoris orisma ypoloipo=0; logariasmos(float arxiko_ypoloipo) // constructor me orisma ypoloipo=arxiko_ypoloipo; ~logariasmos() //dhlosh destructor void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!!! To poso ths analhpsis "<<endl; cout<<" Einai megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; ; void main() logariasmos log1,log2(20),log3(200); cout <<"To ypoloipo toy log1:"<<log1.pareypoloipo()<<endl; cout <<"To ypoloipo toy log2:"<<log2.pareypoloipo()<<endl; cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; cout<<"log1 katathesi 100E"<<endl; log1.katathesi(100); cout <<"To ypoloipo toy log1:"<<log1.pareypoloipo()<<endl; cout <<"To ypoloipo toy log2:"<<log2.pareypoloipo()<<endl; cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; 54

55 Σύντομη εξήγηση του προγράμματος. Σε αυτό το παράδειγμα δηλώνουμε 2 constructors. Ο ένας με όρισμα και ο άλλος χωρίς. Κατόπιν δημιουργούμε τρία αντικείμενα της κλάσης με αρχικοποίηση του υπολοίπου στο πρώτο από τον constructor δίχως όρισμα (δηλ στην τιμή 0) και στα άλλα δύο με τιμή αρχικοποίησης κατά την δημιουργία. Μετά κάνουμε κατάθεση στο ένα αντικείμενο και βλέπουμε ότι το υπόλοιπο άλλαξε μόνο για το αντικείμενο το οποίο έκανε την κατάθεση. Χρήση αντικείμενου σαν όρισμα συνάρτησης #include <iostream.h> class logariasmos private: float ypoloipo; public: logariasmos() ypoloipo=0; logariasmos(float arxiko_ypoloipo) ypoloipo=arxiko_ypoloipo; ~logariasmos() void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!!! To poso ths analhpsis "<<endl; cout<<" Einai megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; 55

56 // orismos synarthshs prostheshs ypoloipon. void athrypoloipo(logariasmos a, logariasmos b) ypoloipo=a.ypoloipo+b.ypoloipo; ; void main() logariasmos log1(200),log2(500),log3; cout <<"To ypoloipo toy log1:"<<log1.pareypoloipo()<<endl; cout <<"To ypoloipo toy log2:"<<log2.pareypoloipo()<<endl; cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; // klhsh synarthshs me orismata ta dyo antikeimena // H synarthsh xrhsimopoiei san orismata ta dyo antikeimena log3.athrypoloipo(log1,log2); cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; Σύντομη εξήγηση του προγράμματος. Σε αυτό το παράδειγμα δημιουργούμε τρία αντικείμενα της κλάσης με αρχικοποίηση του υπολοίπου στο τελευταίο από τον constructor δίχως όρισμα (δηλ στην τιμή 0) και στα άλλα δύο με τιμή αρχικοποίησης κατά την δημιουργία. Φτιάχνουμε μία συνάρτηση η οποία προσθέτει τα υπόλοιπα των δύο πρώτων αντικειμένων. Κάνουμε κλήση αυτής της συνάρτησης όπου μεταβιβάζονται τα αντικείμενα log1 και log2 στις παραμέτρους της συνάρτησης a και b αντίστοιχα. Μέσα στο σώμα της συνάρτησης βλέπουμε την πρόσβαση αυτής στο δεδομένο του κάθε αντικειμένου (a.ypoloipo b.ypoloipo). Τα δεδομένα αυτά αν και είναι ιδιωτικά μπορούν να προσπελαστούν από την συνάρτηση γιατί αυτή είναι μέλος της κλάσης. Βλέπουμε επίσης ότι πριν την κλήση της συνάρτησης αυτής το υπόλοιπο του log3 ήταν 0 και μετά την κλήση της συνάρτησης έγινε 700. Επιστροφή αντικειμένων από συναρτήσεις #include <iostream.h> class logariasmos private: float ypoloipo; public: logariasmos() 56

57 ypoloipo=0; logariasmos(float arxiko_ypoloipo) ypoloipo=arxiko_ypoloipo; ~logariasmos() void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!! To poso ths analhpsis "<<endl; cout<<" Einai megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; /* dhlosh antikeimenoy apotelesma kai Epistrofh toy apo thn synarthsh */ logariasmos athrypoloipo(logariasmos log) logariasmos apotelesma; /* prosthesi toy ypoloipo toy log1 me toy log2 kai ekxwrhsh sto ypoloipo toy apotelesma */ apotelesma.ypoloipo=ypoloipo+log.ypoloipo; return apotelesma; ; void main() logariasmos log1(1200),log2(10500),log3; cout <<"To ypoloipo toy log1:"<<log1.pareypoloipo()<<endl; cout <<"To ypoloipo toy log2:"<<log2.pareypoloipo()<<endl; cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; log3=log1.athrypoloipo(log2); //klhsh synarthshs cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; 57

58 Σύντομη εξήγηση του προγράμματος. Αυτό το πρόγραμμα κάνει ότι ακριβώς και το προηγούμενο με διαφορετικό τρόπο. Εδώ στην συνάρτηση athrypoloipo μεταβιβάζουμε μόνο το ένα αντικείμενο στην παράμετρο log (το log2 στο log). Η τιμή του δεδομένου ypoloipo της παραμέτρου log προστίθεται στην τιμή του δεδομένου του αντικειμένου που καλεί την συνάρτηση δηλ του log1. Μέσα στην συνάρτηση ορίζουμε ένα αντικείμενο apotelesma στο οποίο θα εκχωρηθεί το αποτέλεσμα της πρόσθεσης των δύο υπολοίπων. Κατόπιν με την εντολή return το αντικείμενο apotelesma επιστρέφεται μέσα στην καλούσα συνάρτηση main() και αποδίδεται στο αντικείμενο log3. Για να μπορέσει να επιστρέψει το αντικείμενο η συνάρτηση θα πρέπει να έχει τύπο επιστροφής την ίδια την κλάση. Στατικά δεδομένα κλάσης #include <iostream.h> class logariasmos private: static count=0; //dhlosh statikoy dedomenoy metrhrth float ypoloipo; public: logariasmos() count++; //xrhsh toy metrhrh ypoloipo=0; logariasmos(float arxiko_ypoloipo) count++; // xrhsh toy metrhrh ypoloipo=arxiko_ypoloipo; ~logariasmos() int getcount() //epistrefei thn timh toy metrhth return count; void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; 58

59 else cout<<"prosoxh!!!!! To poso ths analhpsis "<<endl; cout<<" Einai megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; logariasmos athrypoloipo(logariasmos log) logariasmos apotelesma; apotelesma.ypoloipo=ypoloipo+log.ypoloipo; return apotelesma; ; void main() logariasmos log1(200),log2(500),log3; cout <<"To ypoloipo toy log1:"<<log1.pareypoloipo()<<endl; cout <<"To ypoloipo toy log2:"<<log2.pareypoloipo()<<endl; cout <<"To ypoloipo toy log3:"<<log3.pareypoloipo()<<endl; log3=log1.athrypoloipo(log2); cout <<"synolo logariasmon:"<<log3.pareypoloipo()<<endl; cout<<"arithmos Pelaton"<<log1.getCount()<<endl; //count=3 cout<<"arithmos Pelaton"<<log2.getCount()<<endl; //count=3 cout<<"arithmos Pelaton"<<log3.getCount()<<endl; //count=3 Σύντομη εξήγηση του προγράμματος. Εδώ ορίζουμε ένα στατικό δεδομένο count στην κλάση logariasmos το οποίο δίνει την δυνατότητα σε κάθε αντικείμενο της κλάσης να γνωρίζει πόσα αντικείμενα υπάρχουν (ή αλλιώς τα αντικείμενα μοιράζονται την ίδια πληροφορία). Οι συναρτήσεις εγκατάστασης constructors, αυξάνουν κατά ένα κάθε φορά που δημιουργείται ένα αντικείμενο το στατικό δεδομένο μέλος count. Η συνάρτηση getcount που προσθέσαμε μέσα στην κλάση επιστέφει την τιμή που έχει το count την δεδομένη χρονική στιγμή. Έτσι και οι τρεις κλήσης της συνάρτησης που γίνονται μέσα στην main() επιστρέφουν την τιμή 3, δηλ ουσιαστικά μας δείχνει τον αριθμό των αντικειμένων. Εάν δηλώναμε σαν 59

60 κανονική μεταβλητή το count τότε κάθε constructor θα αύξανε κατά 1 το δικό του αντίγραφο και θα παίρναμε αυτή την τιμή για κάθε ξεχωριστό αντικείμενο. Δηλώσεις κλάσεων σε αρχεία επικεφαλίδας - inline & const μέθοδοι Παράδειγμα 1 Dog.hpp //Dog.hpp class Dog public: Dog(int initialage) itsage=initialage; ~Dog() inline int GetDogAge() const return itsage; //const inline inline void SetDogAge(int age) itsage=age; //inline inline void Bark() const cout<< Bark!!!\n ; //const inline private: int itsage; ; Σύντομη εξήγηση του προγράμματος. Το πρόγραμμα δήλωσης της κλάσης Dog είναι χωρισμένο σε αρχείο κεφαλίδας Dog.hpp και αρχείο κυρίως κώδικα Dog.cpp. Δηλώνουμε τρεις μεθόδους inline εκ των οποίων οι δύο είναι const δηλαδή δεν θα αλλάξουν την τιμή του δεδομένου-μέλους itsage. Dog.cpp //Dog.cpp #include <iostream.h> #include Dog.hpp //συμπερίληψη του αρχείου κεφαλίδας int main() Dog Max(2); Max.Bark(); cout << "o Max o skylos moy einai " ; cout << Max.GetDogAge() << " xronwn \n"; Max.Bark(); Max.SetDogAge(9); cout << "twra o Max o skylos moy egine " ; cout << Max.GetDogAge() << " xronwn \n"; Max.Bark(); 60

61 Max.Bark(); return 0; Παράδειγμα 2 Parallhlogramo.hpp //Parallhlogramo.hpp class Parallhlogramo private: float platos, ypsos; public: Parallhlogramo (float x, float y) platos = x; ypsos = y; ~Parallhlogramo () float emvado() return (platos*ypsos); ; //telos klashs Trigono.hpp //Trigono.hpp class Trigono private: float vash; float ypsos; public: Trigono(float v, float y) vash = v; ypsos = y; ~Trigono() float emvado() return (vash*ypsos)/2; ; //telos klashs 61

62 Kyklos.hpp //Kyklos.hpp class Kyklos private: float aktina; public: Kyklos float a) aktina = a; ~ Kyklos() float emvado() return (aktina*aktina*3.14); ; //telos klashs Kylindros.hpp //Kylindros.hpp class kylindros private: float aktina,ypsos; public: kylindros(float a, float h) aktina=a; ypsos=h; float ogkos() return (aktina*aktina*ypsos*3.14); ; //telos klashs 62

63 ypologismoi.cpp //ypologismoi.cpp #include <iostream.h> #include Parallhlogramo.hpp #include Trigono.hpp #include Kyklos.hpp #include Kylindros.hpp void main() Parallhlogramo P_a(12,30); Trigono T_a(3.4,5.0); Kyklos K_a(5); Kylindros Kyl_a(2.3,8.0); Cout<< Emvado Parallhlogramoy <<P_a.emvado()<<endl; Cout<< Emvado Trigwnou <<T_a.emvado()<<endl; Cout<< Epifaneia Kykloy <<K_a.emvado()<<endl; Cout<< Ogkos Kylindroy <<Kyl_a.ogkos()<<endl; ; //telos main Σύντομη εξήγηση του προγράμματος. Εδώ έχουμε δηλώσει 4 κλάσεις σε αντίστοιχα αρχεία επικεφαλίδας. Τις κλάσεις τις χρησιμοποιούμε μέσα στο κυρίως πρόγραμμα ypologismoi.cpp συμπεριλαμβάνοντας τες με διαδοχικά includes. Δημιουργία και χρήση αντικειμένου μιας κλάσης σε μια άλλη #include <iostream.h> class kyklos private: float aktina; public: kyklos(float r) : aktina(r) float emvado() return aktina*aktina*3.14; ; class kylindros kyklos vash; private: float ypsos; public: kylindros(float v, float h) : vash (v), ypsos(h) 63

64 float ogkos() return vash.emvado() * ypsos; ; int main () kylindros kyl1 (10,20); cout << "ogkos kyl1 : " << kyl1.ogkos() << '\n'; return 0; Σύντομη εξήγηση του προγράμματος. Αυτό το πρόγραμμα έχει 2 κλάσεις, μία για τον υπολογισμό της επιφάνειας του κύκλου με την βοήθεια του τύπου Ε κ =π*r 2 και μία του για τον υπολογισμό του όγκου του κυλίνδρου με την βοήθεια του τύπου V κυλ =Εκ*h. όπου π=3.14, r=ακτίνα κύκλου, h=ύψος κυλίνδρου. Στο πρόγραμμα αυτό μπορούμε ανεξάρτητα να υπολογίζουμε την επιφάνεια κύκλου φτιάχνοντας ένα αντικείμενο της κλάσης kyklos το οποίο καλεί την συνάρτηση emvado() της κλάσης kyklos, αλλά και τον όγκο κυλίνδρου φτιάχνοντας αντίστοιχα ένα αντικείμενο της κλάσης kylindros, με την μόνη διαφορά ότι μέσα στην κλάση κύλινδρος φτιάχνουμε ένα αντικείμενο της κλάσης κύκλος το οποίο χρησιμοποιείται από την συνάρτηση ogkos() της κλάσης kylindros για να καλέσει την συνάρτηση emvado() της κλάσης kyklos η οποία επιστρέφει την επιφάνεια του κύκλου που με την σειρά της θα πολλαπλασιαστεί με το ύψος του κυλίνδρου για να επιστρέψει τον όγκο στην main(). Επίσης βλέπουμε την διαφορετική λειτουργία των constructors με αντιστοίχιση ορισμάτων με δεδομένα, όπου στην κλάση kyklos ο constructor kyklos αρχικοποιεί την ακτίνα aktina(r), ενώ στην κλάση kylindros το αντικείμενο στέλνει δύο τιμές (10,20) από τις οποίες η πρώτη είναι η ακτίνα που αποδίδεται από τον constructor kylindros ως τιμή στο αντικείμενο vash(v) άρα και κατ επέκταση στο δεδομένο-μέλος aktina της κλάσης kyklos και η δεύτερη είναι το ύψος η οποία αποδίδεται κανονικά στο δεδομένο-μέλος ypsos(h) της κλάσης kylindros. 64

65 Παράδειγμα χρήσης κλάσης #include <iostream.h> class iatroi private: int am; char name[10]; char surname[20]; char speciality[20]; int hours; float payrate; float salary; public: iatroi(); iatroi(float p):payrate(p); ~iatroi(); void readdata(); float salcalc(int hrs, float prt); float salarybonus(float a); float salarybonusper(float a); float returnsalary(); float returnpayrate(); float returnhours(); int returnam(); void showspeciality(); void showdata(); ; iatroi::iatroi() payrate=25; iatroi::iatroi(float p):payrate(p) iatroi::~ iatroi() void iatroi::readdata() cout<<"a.m.:"; cin>>am; cout<<"name:"; cin>>name; cout<<"surname:"; cin>>surname; cout<<"eidikothta: "; cin>>speciality; cout<<"ores:"; cin>>hours; salary=salcalc(hours, payrate); float iatroi::salcalc(int hrs, float prt) 65

66 float sal; sal=hrs*prt; return sal; float iatroi::salarybonus(float a) return salary+=a; float iatroi::salarybonusper(float a) return salary+=salary*a/100; float iatroi::returnsalary() return salary; float iatroi::returnpayrate() return payrate; float iatroi::returnhours() return hours; int iatroi::returnam() return am; void iatroi::showspeciality() cout<<speciality<<endl; void iatroi::showdata() cout<<"a.m.: "<<am<<endl; cout<<"name: "<<name<<endl; cout<<"surname: "<<surname<<endl; cout<<"eidikothta: "<<speciality<<endl; cout<<"ores Ergasias: "<<hours<<endl; cout<<"oromisthio: "<<payrate<<endl; cout<<"misthos: "<<salary<<" Euro"<<endl; void main() iatroi i1(20), i2, i3(110); i1.readdata (); i2.readdata (); i3.readdata (); cout<<endl; i1.showdata (); cout<<endl; i2.showdata (); cout<<endl; 66

67 i3.showdata (); cout<<endl; Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα ορίζεται μια κλάση iatroi. Τα δεδομένα μέλη είναι: ο αριθμός μητρώου, το όνομα, το επώνυμο, η ειδικότητα, οι ώρες εργασίας, το ωρομίσθιο και το ημερομίσθιο. Χρησιμοποιείται constructor με υπερφόρτωση. Δηλαδή το ωρομίσθιο χρησιμοποιείται σαν δεδομένο αρχικοποίησης στον constructor χωρίς όρισμα με τιμή 25. Επίσης χρησιμοποιείται και constructor με αντιστοίχιση ορισμάτων με τα δεδομένα. Η κλάση περιέχει εκτός από τους constructors τις εξής συναρτήσεις: 1. Συνάρτηση για την εισαγωγή των δεδομένων των ιατρών readdata() (με κλήση της συνάρτησης υπολογισμού του ημερομισθίου), 2. Συνάρτηση για τον υπολογισμό του ημερομισθίου salcalc(), 3. Συνάρτηση για τον υπολογισμό χρηματικής αύξησης μισθού salarybonus (), 4. Συνάρτηση για τον υπολογισμό ποσοστιαίας αύξησης μισθού salarybonusper (), 5. Συνάρτηση για την εμφάνιση των δεδομένων showdata(), 6. Συνάρτηση για την επιστροφή των ωρών εργασίας returnhours(), 7. Συνάρτηση για την επιστροφή του ημερομισθίου returnpayrate(), 8. Συνάρτηση για την επιστροφή του μισθού returnsalary(), 9. Συνάρτηση για την επιστροφή του αριθμού μητρώου returnam() και 10. Συνάρτηση για την εμφάνιση της ειδικότητας του γιατρού showspeciality(). Για καλύτερο έλεγχο της κλάσης οι δηλώσεις των συναρτήσεων περιέχονται στην κλάση ενώ οι ορισμοί τους βρίσκονται έξω από αυτήν. 67

68 ΚΛΑΣΕΙΣ & ΠΙΝΑΚΕΣ Τι είναι πίνακας Πίνακας (array) είναι ένα σύνολο από θέσεις μνήμης (μεταβλητές), όπου η κάθε μία περιέχει τον ίδιο τύπο δεδομένων (π.χ int, float κλπ). Κάθε θέση ονομάζεται στοιχείο του πίνακα. Δηλώνουμε έναν πίνακα στο πρόγραμμα γράφοντας τον τύπο, το όνομα του πίνακα και τέλος έναν δείκτη (subscript) μέσα σε τετράγωνες αγκύλες που είναι ο αριθμός των στοιχείων του πίνακα. Δηλαδή: double MyArray[10]; όπου: double τύπος MyArray όνομα πίνακα [10] δείκτης πλήθους στοιχείων πίνακα Μέγεθος στη μνήμη Ο μεταγλωττιστής για αυτόν τον πίνακα δεσμεύει: 80 bytes (δηλ. double 8 bytes x 10 στοιχεία). Τα στοιχεία του πίνακα μετριούνται από το 0, δηλαδή το πρώτο στοιχείο του πίνακα είναι MyArray[0], το δεύτερο MyArray[1], το τρίτο MyArray[2] κλπ. Αρα εάν έχουμε έναν πίνακα με n στοιχεία, η αρίθμηση τους είναι: MyArray[0], MyArray[1], MyArray[n-1] Άρα ο πίνακας του παραδείγματος έχει στοιχεία που μετριούνται από το MyArray[0] έως το MyArray[9]. 68

69 Εγγραφή σε συγκεκριμένη θέση μνήμης Ο μεταγλωττιστής υπολογίζει που θα αποθηκεύσει την τιμή σε ένα στοιχείο του πίνακα ανάλογα με το μέγεθος του (τύπος) και τον δείκτη. Π.χ θέλουμε να γράψει μία τιμή στο στοιχείο MyArray[5] (έκτο στοιχείο), ο μεταγλωττιστής πολλαπλασιάζει την μετατόπιση επί το μέγεθος του κάθε στοιχείου 5Χ8 bytes=40 bytes. Μετακινείται από την αρχή 40 bytes και γράφει την τιμή του στοιχείου. Προσοχή!! εάν του δώσουμε να γράψει στο MyArray[50], αγνοεί ότι δεν υπάρχει αυτό το στοιχείο στον πίνακα, υπολογίζει την απόσταση (400 bytes) και πάει και γράφει εκεί που μπορεί να υπάρχουν άλλα δεδομένα. Αρχικοποίηση μονοδιάστατου πίνακα Αρχικοποιούμε έναν μονοδιάστατο πίνακα γράφοντας: float MyArray[5]=1.2, 11.5, 21.0, 31.9, 41.12; Αυτό σημαίνει ότι το στοιχείο: MyArray[0] θα πάρει την τιμη 1.2, το MyArray[1] την τιμή 11.5, το MyArray[2] την τιμή 21.0, το MyArray[3] την τιμή 31.9, και το MyArray[4] την τιμή

70 Παρατηρήσεις Εάν στη δήλωση παραλείψουμε τον δείκτη του πίνακα αλλά βάλουμε τις τιμές, τότε ο compiler θα φτιάξει έναν πίνακα που να χωρέσει τις τιμές αυτές. Δεν πρέπει να αρχικοποιούμε έναν πίνακα με τιμές περισσότερες από το μέγεθός του. Εάν αρχικοποιήσουμε έναν πίνακα με λιγότερες τιμές τότε θα αρχικοποιηθούν τα πρώτα στοιχεία με τις δοθείσες τιμές και τα υπόλοιπα με τιμές 0. Προσοχή στον δείκτη μέσα στις αγκύλες. Στη δήλωση float MyArray[5]; ο δείκτης 5 καθορίζει το μέγεθος του πίνακα, ενώ στην πρόταση MyArray[4]=41.12; ο δείκτης 4 δηλώνει ότι το 5ο στοιχείο του πίνακα που αναφερόμαστε, θα πάρει την τιμή Υπολογισμός μεγέθους πίνακα Μπορούμε να βρούμε το μέγεθος σε bytes ενός πίνακα χρησιμοποιώντας τον τελεστή sizeof(). Η δήλωση: sizeof(ονομα_πίνακα) μας δείχνει το μέγεθος (σε bytes) του πίνακα. Η δήλωση: sizeof(ονομα_πίνακα[δείκτης]) μας δείχνει το μέγεθος του συγκεκριμένου στοιχείου του πίνακα. Και η διαίρεση: sizeof(ονομα_πίνακα) / sizeof(ονομα_πίνακα[δείκτης]) μας δείχνει το αριθμό των στοιχείων του πίνακα. 70

71 Δισδιάστατοι πίνακες Δισδιάστατοι είναι οι πίνακες των οποίων τα στοιχεία είναι επίσης πίνακες. Η πρόταση : int Myarray[2][4]; δηλώνει το Myarray σαν πίνακα ακεραίων 2 στοιχείων, που κάθε στοιχείο του είναι ένας πίνακας ακεραίων 4 στοιχείων. Στην C και την C++ δεν υπάρχει περιορισμός στον αριθμό διαστάσεων ενός πίνακα. Για να αναφερθούμε σε ένα στοιχείο ενός δισδιάστατου πίνακα θα πρέπει να καθοριστούν σωστά οι δείκτες. Δηλ. η έκφραση: Myarray[1] αναφέρεται στην δεύτερη γραμμή του πίνακα Myarray. Ενώ η έκφραση: Myarray[0][3] αναφέρεται στο τέταρτο στοιχείο της πρώτης γραμμής του πίνακα Myarray. Άρα οι δείκτες χρησιμοποιούνται για να δείξουν: Myarray[γραμμή][στοιχείο] Αρχικοποίηση δισδιάστατου πίνακα Για να αρχικοποιηθεί ένας δισδιάστατος πίνακας, θα πρέπει κάθε γραμμή με τιμές, να περικλείεται από άγκιστρα. Αν δεν υπάρχουν σε κάποια στοιχεία τιμές τότε τα στοιχεία αυτά παίρνουν την τιμή 0. Όταν εκτελεστεί η πρόταση: int array[3][3]= 1,2,3,4,5,6,7,8,9 ; 71

72 ο πίνακας που δημιουργείται είναι ο: Εδώ ο compiler βρήκε τρεις τριάδες τιμών μέσα στα άγκιστρά και τις τοποθέτησε στον πίνακα με την σειρά ξεκινώντας από το πρώτο μπλοκ τιμών. Σημ. Προσέχουμε πάντα που βάζουμε τα άγκιστρα. Η δήλωση: 1 η γραμμή 2 η γραμμή 3 η γραμμή int Arr[4][3]= 3, 2, 1, 6, 4, 7, 8, 9 ; θα δημιουργήσει τον πίνακα: Εδώ ο compiler βρήκε τρία μπλοκ τιμών μέσα στα άγκιστρά τα οποία δεν είχαν τον ίδιο αριθμό τιμών. Έτσι τοποθέτησε τις τιμές του πρώτου μπλοκ, κατόπιν τοποθέτησε τις δύο τιμές του δεύτερου μπλοκ τιμών συμπληρώνοντας με 0 την τιμή που λείπει και τέλος τοποθέτησε και το τρίτο μπλοκ τιμών. Επειδή όμως στη δήλωσή του πίνακα υπάρχει και τέταρτη γραμμή αλλά στην αρχικοποίηση δεν δόθηκε τέταρτο μπλοκ τιμών ο compiler συμπλήρωσε την γραμμή αυτή με 0. 72

73 ` ` Αντικειμενοστραφής Προγραμματισμός Στον ίδιο πίνακα η δήλωση χωρίς τα εσωτερικά άγκιστρα: 1 η γραμμή 2 η γραμμή 3 η γραμμή int Arr[4][3]= 3, 2, 1, 6, 4, 7, 8, 9 ; θα δημιουργήσει τον πίνακα: Στην προκειμένη περίπτωση και λογω έλειψης εσωτερικών αγκίστρων ο compiler τοποθετεί με την σειρά τις δοθείσες όσες και να είναι αυτές και συμπληρών ει με 0 τα στοιχεία για ταοποία δεν υπάρχουν τιμές. Πολυδιάστατοι πίνακες Ένας πολυδιάστατος πίνακας δηλώνεται όπως παρακάτω: Τύπος όνομα_πίνακα [διάσταση 1][διάσταση 2] [διάσταση n] Δήλωση και αρχικοποίηση ενός ακέραιου πίνακα 2Χ2Χ2 γίνεται: int Array[2][2][2]= 1,2,3,4,5,6,7,8,9,10,11,12; 73

74 j k i Η προσπέλαση του πίνακα γίνεται με 3 βρόχους for και τρεις δείκτες δηλ. Array[i][j][k]. Αναγνωριστικό define Στην C++ χρησιμοποιούμε το αναγνωριστικό define για να αντικαταστήσουμε μία έκφραση, μία δήλωση, ή έναν αριθμό που δηλώνει στοιχεία ενός πίνακα με ένα γράμμα ή μία λέξη, έτσι ώστε να μην χρειάζεται να θυμόμαστε τον αριθμό των στοιχείων. Η σύνταξη είναι η εξής: # define <αναγνωριστικό> <αντικατατάτης> Π.χ τον αριθμό των στοιχείων ενός μονοδιάστατου πίνακα μπορούμε σε όλο το πρόγραμμα να τον αντικαταστήσουμε με ένα γράμμα (π.χ Ν) ή μια λέξη (π.χ. CITY). # define N 10 ή # define CITY 10 Αντικαθιστούμε τον αριθμό 10 με το γράμμα Ν ή την λέξη CITY. Δηλ. για να διαβάσουμε αυτόν τον πίνακα θα γράψουμε τις προτάσεις: for (i=0;i<n;i++) cin>>arr[i]; ή for (i=0;i<city;i++) cin>>arr[i]; 74

75 Αυτός ο βρόχος θα εισάγει τιμές και στα 10 (Ν ή CITY) στοιχεία του πίνακα μετά από (Ν ή CITY) επαναλήψεις. Σε δισδιάστατο πίνακα χρησιμοποιούμε δύο αναγνωριστικά. Π.χ Ν,Μ και διπλό (εμφωλευμένο) βρόχο for. Πίνακες μέσα σε κλάσεις Οι πίνακες μπορούν να δηλωθούν σαν δεδομένα-μέλη μιας κλάσης και να χρησιμοποιηθούν μέσα στις μεθόδους της κλάσης. Π.χ δήλωση πίνακα ως δεδομένο μιας κλάσης: private: int temp; Μεταβλητή ως δεδομένο μέλος float temparr[n]; Πίνακας ως δεδομένο μέλος Χρήση πίνακα μέσα σε μέθοδο με επανάληψη: public: //δημόσια ορατό μέρος κλάσης tempmesure() // constructor χωρίς όρισμα int i; //τοπική μεταβλητή for(i=0; i<n; i++) //βρόχος Ν επαναλήψεων temparr[i]=0; //μηδενισμός στοιχείων πίνακα 75

76 Πίνακες με αντικείμενα Μπορούμε να έχουμε σε ένα πρόγραμμα και πίνακες που να περιέχουν αντικείμενα. Εδώ έχουμε έναν πίνακα αντικειμένων tem της κλάσης Temperature. Σε κάποιο σημείο του προγράμματος κάποιο αντικείμενο του πίνακα (ή όλα τα αντικείμενα μέσα σε βρόχο for) καλεί την μέθοδο readtemp(). main() Temperature tem[n]; tem[i].readtemp(); 76

77 ΠΑΡΑΔΕΙΓΜΑΤΑ ΚΛΑΣΕΩΝ ΚΑΙ ΠΙΝΑΚΩΝ Μονοδιάστατοι πίνακες Διάβασμα μονοδιάστατου πίνακα. for (int i=0; i<n; i++) cin>>arr[i]; Εμφάνιση μονοδιάστατου πίνακα. for (int i=0; i<n; i++) cout<<arr[i]; Άθροισμα στοιχείων μονοδιάστατου πίνακα. int sum=0; for (int i=0; i<n; i++) sum=sum+arr[i]); Δισδιάστατοι πίνακες Διάβασμα δισδιάστατου πίνακα. for (int i=0; i<m; i++) for (int j=0; j<n; j++) cin>>arr[i][j]; Εμφάνιση δισδιάστατου πίνακα. for (int i=0; i<m; i++) for (int j=0; j<n; j++) cout<<arr[i][j]; Άθροισμα στοιχείων δισδιάστατου πίνακα. int sum=0; for (int i=0; i<μ; i++) for (int j=0; j<n; j++) sum=sum+arr[i][j]; Άθροισμα στοιχείων δισδιάστατου πίνακα ανά γραμμή. for (int i=0; i<μ; i++) row[i]=0; for (int j=0; j<n; j++) row[i]=row[i]+arr[i][j]; Άθροισμα στοιχείων δισδιάστατου πίνακα ανά στήλη. for (int j=0; j<n; j++) col[j]=0; for (int i=0; i<μ; i++) col[j]=col[j]+arr[i][j]; 77

78 Μονοδιάστατοι πίνακες Ακολουθεί ένα πρόγραμμα που διαβάζει είκοσι ακέραιους από το πληκτρολόγιο και εμφανίζει το πλήθος των άρτιων και το πλήθος των περιττών. #include <iostream.h> #define N 20 void main() int arr[n]; int i, artios=0, perittos=0 ; for (i=0; i<n; i++) cout<<"dose "<<i+1<<"o arithmo:"; cin>>arr[i]; for (i=0; i<n; i++) if (arr[i]%2==0) artios++; else perittos++; cout<<"oi Artioi einai: "<<artios<<endl; cout<<"oi Perittoi einai: "<< perittos << endl; Δισδιάστατοι πίνακες 1. Το πιο κάτω πρόγραμμα υπολογίζει το άθροισμα των στοιχείων ενός δισδιάστατου πίνακα ανά γραμμή. #include <iostream.h> #define M 3 #define N 3 void main() int i,j; int myarray[m][n]; //vasikos pinakas int row[m]; //vohthitikos pinakas /* vroxos gia thn eisafvgh twn timwn tou pinaka apo ton xrhsth */ for(i=0;i<m;i++) for(j=0;j<n;j++) cout<<"timh gia to myarray["<<i<<"]["<<j<<"]: "; cin>>myarray[i][j]; for(i=0;i<m;i++) // vroxos gia ton ypologismo toy athroismatos row[i]=0; 78

79 for(j=0;j<n;j++) row[i]=row[i]+myarray[i][j]; cout<<"to athroisma ths grammhs "<<i<<" einai: "<<row[i]<<endl; 2. Το πιο κάτω πρόγραμμα υπολογίζει το άθροισμα των στοιχείων ενός δισδιάστατου πίνακα ανά στήλη. #include <iostream.h> #define M 3 #define N 3 void main() int i,j; int myarray[m][n]; //vasikos pinakas int col[n]; //vohthitikos pinakas /* vroxos gia thn eisafvgh twn timwn tou pinaka apo ton xrhsth */ for(i=0;i<m;i++) for(j=0;j<n;j++) cout<<"timh gia to myarray["<<i<<"]["<<j<<"]: "; cin>>myarray[i][j]; for(j=0;j<n;j++) // vroxos gia ton ypologismo toy athroismatos col[j]=0; for(i=0;i<m;i++) col[j]=col[j]+myarray[i][j]; cout<<"to athroisma ths sthlhs "<<j<<" einai: "<<col[j]<<endl; 3. Το πρόγραμμα που ακολουθεί χρησιμοποιεί τρεις πίνακες ως εξής: Ένα μονοδιάστατο πίνακα 5 θέσεων όπου βρίσκονται καταχωρημένα τα ονόματα 5 πόλεων, Ένα μονοδιάστατο πίνακα 12 θέσεων όπου βρίσκονται καταχωρημένα τα ονόματα των 12 μηνών, 79

80 Ένα δισδιάστατο πίνακα 5x12 όπου βρίσκονται καταχωρημένοι οι μέσοι όροι θερμοκρασίας που καταγράφηκαν σε κάθε πόλη για κάθε μήνα. Το πρόγραμμα θα εμφανίζει τις θερμοκρασίες όλων των πόλεων για κάθε μήνα, και θα βρίσκει και θα εμφανίζει την ελάχιστη και τη μέγιστη θερμοκρασία ανά πόλη και μήνα. #include <iostream.h> #define M 5 #define N 12 void main() char cities[m][80]="kavala", "DRAMA", "THESSALONIKI", "SERRES", "LARISSA"; char months[n][80] = "IANOYARIO","FEBROUARIO","MARTIO","APRILIO", "MAIO","IOYNIO","IOYLIO","AVGOUSTO","SEPTEMBRIO", "OKTOBRIO", "MOEMBRIO","DEKEMBRIO"; float temp[m][n] = 15.6,13.8,16.9,18.2,19.3,26.7,29.5,33.4,22.5,18.4,17.5,14.2, 13.5,12.9,15.8,17.3,18.2,24.9,28.9,30.1,21.7,17.1,15.8,13.8, 15.9,14.2,17.3,19.4,21.5,17.9,30.6,34.2,24.1,19.6,18.2,14.7, 16.3,15.9,17.8,19.8,22.2,18.3,30.8,35.1,25.5,20.5,18.8,15.3, 18.3,17.1,19.6,22.4,25.3,30.2,32.4,36.3,31.5,22.7,21.5,19.4 ; float mintemp, maxtemp; int i,j, row, col; for (i=0; i<m; i++) //emfanish twn 8ermokrasiwn ana polh cout<<cities[i]; for (j=0; j<n; j++) cout<<temp[i][j]; cout<<endl; mintemp=temp[0][0]; //evresh ths mikroterhs 8ermokrasias row=0; col=0; for (i=0; i<m; i++) for (j=0; j<n; j++) if (temp[i][j]<mintemp) mintemp=temp[i][j]; row=i; //h polh me thn mikroterh 8ermokrasia. col=j; //o mhnas me thn mikroterh 8ermokrasia. cout<<endl<<"mikroterh Thermokrasia: "<<mintemp<<endl; cout<<"stin: "<<cities[row]<<endl; cout<<"to Mhna: "<<months[col]<<endl; maxtemp=temp[0][0]; 80

81 row = 0; col = 0; for (i=0; i<m; i++) //evresh ths megalyterhs 8ermokrasias for (j=0; j<n; j++) if (temp[i][j]>maxtemp) maxtemp=temp[i][j]; row=i; //h polh me thn megalyterh 8ermokrasia. col=j; //o mhnas me thn megalyterh 8ermokrasia. cout<<endl<<"megalyterh Thermokrasia: "<<maxtemp<<endl; cout<<"stin: "<<cities[row]<<endl; cout<<"to Mhna: "<<months[col]<<endl; return 0; ΠΙΝΑΚΕΣ ΜΕΣΑ ΣΕ ΚΛΑΣΕΙΣ Οι πίνακες μπορούν να χρησιμοποιηθούν ως δεδομένα κλάσεων αλλά και ως μέρη των μεθόδων κλάσεων. Μπορούν να είναι πίνακες απλοί ή ακόμα και πίνακες αντικειμένων. Πίνακας ως δεδομένο μιας κλάσης. Πίνακας ως μέλος μεθόδου. private: char Polh[30]; float Temp[N]; void readdata() cout<<"dose A.M.:"; cin >> armht; cout <<"Dose Vathmous: "; for (int i=0; i<n; i++) cin>>vathmos[i]; Πίνακας αντικειμένων μιας κλάσης. void main() Temperature Tem[N]; for (i=0; i<n; i++) Tem[i].setTemp(); 81

82 Αρχικοποίηση στοιχείων πίνακα με constructor. class City private: char Polh[30]; float Temp[N]; public: City() for (int i=0;i<n;i++) Temp[i]=0.0; ~City() Εύρεση Μ.Ο μισθών Ν υπαλλήλων. for (i=0; i<n; i++) sum=sum+erg[i].retmisthos(); avg=sum/n; cout<<"\no M.O. einai: "<<avg<<endl; Χρήση των πινάκων μέσα σε κλάσεις Παράδειγμα 1. Το πρόγραμμα που ακολουθεί ορίζει μία κλάση με το όνομα Student και δεδομένα τον αριθμό μητρώου ενός σπουδαστή και έναν πίνακα όπου αποθηκεύονται βαθμολογίες του. Το πρόγραμμα εμφανίζει τον Μ.Ο. των βαθμολογιών και την μικρότερή αλλά κα την μεγαλύτερη βαθμολογία. #include <iostream.h> const int N=10; class Student private: int armht; float vathmos[n]; //pinakas san dedomeno public: Student() //constructor gia arxikopoihsh data sto 0 armht=0; for (int i=0; i<n; i++) vathmos[i]=0; void readdata() //methodos eisagoshs A.M. kai vathmwn 82

83 cout<<"dose A.M.:"; cin >> armht; cout <<"Dose Vathmous: "; for (int i=0; i<n; i++) cin>>vathmos[i]; float getavg() //methodos gia ton M.O. float sum=0, avg; for (int i=0; i<n; i++) sum+=vathmos[i]; avg=sum/n; return avg; float getmin() //methodos gia mikrotero vathmo float min; min=vathmos[0]; for (int i=0; i<n; i++) if (vathmos[i]<min) min=vathmos[i]; return min; float getmax() //methodos gia megalytero vathmo float max; max=vathmos[0]; for (int i=0; i<n; i++) if (vathmos[i]>max) max=vathmos[i]; return max; ; void main() Student Stud1; //orismos antikeimenoy Stud1.readData(); cout<<"m.o.: "<<Stud1.getAvg()<<endl; cout<<"megalyteros Vathmos: "<<Stud1.getMax()<<endl; cout<<"mikroteros Vathmos: "<<Stud1.getMin()<<endl; 83

84 Παράδειγμα 2. Στο πρόγραμμα που ακολουθεί δηλώνεται ένας πινάκας σαν δεδομένο μιας κλάσης. Κατασκευάζεται ένα αντικείμενο το οποίο κάνει εισαγωγή δεδομένων μέσω της κλάσης. Κατόπιν τα δεδομένα μεταφέρονται σε έναν δεύτερο πίνακα έξω από την κλάση όπου και τυπώνονται με στηλοθεσία. Στο τέλος τυπώνεται το άθροισμα των τιμών που δόθηκαν. #include <iostream.h> #include <iomanip.h> const int MAX=5; //dhlwsh sta8eras class pinakas //dhlwsh klashs private: int Arr[MAX],i ; //dhlwsh pinaka san dedomeno public: void getdata() for(i=0; i<max; i++) cout<<"\ndose "<<i+1<<"o Ari8mo:"; cin>>arr[i]; cout<<"to Arr["<<i<<"]= "<<Arr[i]; Arr[i]+=MAX; //pros8esh stis times ths timhs MAX void printdata() for(i=0; i<max; i++) cout<<i+1<<"h timh: "<<Arr[i]<<endl; int retdata(int k) //epistrofh timhs stoixeiou pinaka return Arr[k]; ; //telos klashs void main() pinakas pin1; //dhlwsh antikeimenou pin1 int Arr2[MAX]; //dhlosh 2ou pinaka int i, sum=0; pin1.getdata(); //eisagwgh timwn // metafora timwn apo pinaka se pinaka for(i=0; i<max; i++) Arr2[i]=pin1.retData(i); //ektypwsh me sthlo8esia cout<<"\n\nse ka8e timh proste8hke to MAX"<<endl; 84

85 cout<<"\n\noi times toy pinaka einai"<<endl; pin1.printdata(); cout<<"\noi times metafer8hkan ston Arr2[]"<<endl; cout<<"\noi times tou Arr2[] einai"<<endl; for(i=0; i<max; i++) sum+=arr2[i]; //ypologismos a8roismatos cout<<endl; cout<<setw(5)<<"to Arr2["<<i<<"]="<<Arr2[i]<<endl; //ektupwsh toy a8roismatos twn timwn cout<<"\n\nto A8roisma twn stoixeiwn toy pinaka Arr2[] einai: "; cout<<sum<<endl<<endl; //telos main Πίνακες με αντικείμενα Στο παρακάτω πρόγραμμα καταγράφονται τα στοιχεία 5 εργαζομένων. Με την πληκτρολόγηση του Α.Μ εμφανίζονται τα στοιχεία του συγκεκριμένου εργαζόμενου. Εάν το Α.Μ. δεν υπάρχει τότε το πρόγραμμα θα εμφανίζει μήνυμα λάθους. #include <iostream.h> #define N 3 class Ergazomenoi private: int armht; char onoma[20]; float misthos; public: void readdata() //eisagogh stoixeiwn cout<<"dose A.M.: "; cin>>armht; cout<<"dose Onoma: "; cin>>onoma; cout<<"dose Mistho: "; cin>>misthos; void printdata() //ektypwsh stoixeiwn cout<<"a.m.: "<<armht<<endl; cout<<"onoma: "<<onoma<<endl; cout<<"misthos: "<<misthos<<endl; int retam() //epistrofh A.M. return armht; ; 85

86 void main() Ergazomenoi erg[n]; //pinakas antikeimenwn int i,j,armht; bool found; char choice; cout <<"Dose stoixeia "<<N<<" Ergazomenwn: "<<endl; cout<<"\n====================================="<<endl; for (i=0; i<n; i++) cout<<endl<<"ergazomenos "<<i+1<<endl; erg[i].readdata(); //klhsh synarthshs apo ola ta antik cout<<"\n====================================="<<endl; cout<<"\ndiadikasia anazhthshs mesw ari8mou mhtrwou"<<endl; do cout<<"\ndose A.M. gia Anazhthsh: "; cin>>armht; j=0; found=false; while (j<n && found==false) if (erg[j].retam()==armht) //eyresh A.M ergazomenwn found=true; //ergazomenos vre8hke else j++; //metrhths mexri to N if (found==true) //typwse ta stoixeia toy ergazomenou cout<<"\n>>>o ergazomenos bre8hke<<< "<<endl; cout<<"ta stoixeia tou einai:"<<endl; erg[j].printdata(); else //o A.M. den vre8hke cout<<">>>o Ergazomenos den yparxei<<<"<<endl; cout<<"\n8a synexiseis thn anazhthsh?"<<endl; cout<<"pata Y (NAI) h N (OXI)"<<endl; cin>>choice; while(choice=='y'); cout<<"\ntelos ANAZHTHSHS"<<endl; Σύντομη εξήγηση του προγράμματος. Στο προηγούμενο πρόγραμμα ορίζεται ένας πίνακας αντικειμένων erg τύπου Ergazomenoi. Κατόπιν με ένα βρόχο for, εισάγονται πληροφορίες για κάθε ένα από τα 5 αντικείμενα του πίνακα, με την κλήση της συνάρτησης readdata(). Τέλος, πληκτρολογείται ένας τυχαίος αριθμός μητρώου και αναζητείται στον πίνακα αντικειμένων. Αν υπάρχει, εμφανίζονται οι πληροφορίες για το συγκεκριμένο εργαζόμενο. Αν όχι εμφανίζεται αντίστοιχο μήνυμα. 86

87 ΚΛΗΡΟΝΟΜΙΚΟΤΗΤΑ Τι είναι κληρονομικότητα Κληρονομικότητα ονομάζεται η διαδικασία που επιτρέπει μία κλάση να κληρονομεί τις ιδιότητες (δεδομένα) και τις συμπεριφορές (συναρτήσεις) μιας άλλης κλάσης. Η κλάση που κληρονομείται λέγεται βασική κλάση (basic class) ή υπερκλάση (superclass) ενώ, Η κλάση που κληρονομεί λέγεται παραγόμενη κλάση (derived class) υποκλάση (subclass). Πλεονέκτημα της κληρονομικότητας Βασικό πλεονέκτημα της κληρονομικότητας είναι ότι χρησιμοποιείται ο ήδη γραμμένος κώδικάς μιας κλάσης, που με κάποιες προσθήκες προσαρμόζεται σε μία κλάση που κληρονομεί χαρακτηριστικά και μεθόδους (παραγόμενη κλάση), αυτό λέγεται επαναχρησιμοποίηση κώδικα. Έτσι δεν χρειάζεται να ξαναγράψουμε τον κώδικα από την αρχή για μια νέα κλάση. Αυτό έχει σαν αποτέλεσμα να εξοικονομούμε χρόνο και χρήμα αλλά και να καθιστούμε το πρόγραμμα πιο αξιόπιστο και εύκολα αναγνώσιμο. 87

88 Σύνταξη βασικής και παραγόμενης κλάσης Ο ορισμός της βασικής αλλά και της παραγόμενης κλάσης μέσα στον κώδικα της C++ γίνεται ως εξής: class παράγωγη_κλάση : public βασική_κλάση Η παράγωγη κλάση κληρονομεί και τα χαρακτηριστικά αλλά και τις μεθόδους της βασικής κλάσης. Προστατευόμενα δεδομένα Ο τρόπος πρόσβασης στα δεδομένα μέλη από τις μεθόδους της κλάσης στην κληρονομικότητα αλλάζει λίγο. Τα δεδομένα στην βασική κλάση πρέπει να δηλωθούν ως προστατευμένα δεδομένα μέλη με την χρήση της δεσμευμένης από τη γλώσσα λέξη protected. Αυτό γίνεται για να μπορούν να έχουν πρόσβαση σε αυτά (ή αλλιώς να τα προσπελάσουν), οι συναρτήσεις-μέλη της ίδιας της κλάσης αλλά και οι συναρτήσεις-μέλη παραγόμενων κλάσεων. Σε αντίθεση με την δήλωση private όπου μπορεί να έχει πρόσβαση στα δεδομένα, μόνο η κλάση στην οποία ανήκουν. Σημ. Δεν μπορούν να έχουν πρόσβαση στα δεδομένα συναρτήσεις που βρίσκονται έξω από αυτές τις κλάσεις δηλ. στην main(). 88

89 Παράδειγμα κληρονομικότητας σε UML Εδώ φαίνονται οι παράγωγες κλάσεις class B, class C, class D οι οποίες κληρονομούν από την βασική κλάση class A τα δεδομένα μέλη data 1, data 2, data 3 καθώς και τις μεθόδους της βασικής κλάσης method 1(),method 2(),method 3(). Τα δεδομένα της βασικής δηλώνονται protected (#) δηλαδή προστατευμένα ενώ οι μέθοδοι public (+) δηλαδή δημόσια ορατές. Οι παραγόμενες κλάσεις διαθέτουν και δικά τους δεδομένα που δηλώνονται private (-) δηλαδή ιδιωτικά ορατά και μεθόδους. Τα αντικείμενα που θα προκύψουν από τις παραγόμενες κλάσεις θα έχουν πρόσβαση και στα δεδομένα αλλά και στις μεθόδους της βασικής κλάσης. Ένα αντικείμενο της κλάσης class D έχει τέσσερα δεδομένα (data1, data2, data3, data4) στα οποία μπορούν να έχουν πρόσβαση τέσσερεις μέθοδοι (method1, method2,method3, method4). 89

90 Παράδειγμα κληρονομικότητας της κλάσης όχημα σε UML Στο πιο πάνω παράδειγμα τα αντικείμενα της κλάσης «Επιβατικό», έχουν χαρακτηριστικά και μεθόδους μόνο αυτά της βασικής κλάσης, δηλαδή έχουν κινητήρα, τροχούς, πόρτες, καθίσματα και ξεκινούν, σταματούν, στρίβουν. Αυτό συμβαίνει διοτι η κλάση «Επιβατικό» δεν διαθέτει δικά της δεδομένα και μεθόδους. Τα αντικείμενα της κλάσης «Φορτηγό», έχουν εκτός από αυτά της βασικής κλάσης επί προσθέτως, καρότσα η οποία ανατρέπεται. Τα αντικείμενα της κλάσης «Λεωφορείο» έχουν εκτός από αυτά της βασικής κλάσης επί προσθέτως, μπαγκαζιέρα. Σημ. τα αντικείμενα της κλάσης «Όχημα» έχουν τα δικά της χαρακτηριστικά και μεθόδους και δεν χρησιμοποιούν των παραγόμενων κλάσεων. Η κληρονομικότητα δεν λειτουργεί αντίστροφα. Αυτό σημαίνει ότι τα αντικείμενα της κλάσης όχημα δεν έχουν πρόσβαση σε κλάσεις χαμηλότερου επιπέδου (Επιβατικό, Φορτηγό, Λεωφορείο). 90

91 Δήλωση προσβασιμότητας σε κλάση class basic ; protected: public: int mesure; Basic() mesure=0; Βασική κλάση Προστατευμένο δεδομένο - μέλος Προσβασιμότητα δεδομένων στην κληρονομικότητα Όταν τα δεδομένα δηλωθούν Έχει πρόσβαση σε αυτά η κλάση στην οποία ανήκουν Έχει πρόσβαση σε αυτά η παραγόμενη κλάση Έχουν πρόσβαση συναρτήσεις έξω από την κλάση στην οποία ανήκουν private protected public Στον παραπάνω πίνακα φαίνεται με ποιόν τρόπο αποκτούν πρόσβαση στα δεδομένα. οι πελάτες μιας κλάσης Όταν δηλώνονται private έχει πρόσβαση σε αυτά μόνο η κλάση στην οποία ανήκουν, όταν δηλωθούν protected έχουν πρόσβαση σε αυτά και οι παραγόμενες κλάσης, ενώ όταν δηλωθούν public έχουν πρόσβαση όλοι. 91

92 Συνδυασμοί παραγωγής μιας κλάσης Πρέπει να αναφέρουμε ότι οι κλάσεις μπορούν να παραχθούν είτε δημόσια δηλ: class ProdA : public Basic ή ιδιωτικά δηλ: class ProdΒ : private Basic Εδώ η κλάση ProdA παράγεται δημόσια από την Basic, ενώ η ProdB παράγεται ιδιωτικά από την Basic. Τι σημαίνει αυτή η διάκριση? Πρακτικά οι παράγωγες κλάσεις είτε ιδιωτικά είτε δημόσια παραγόμενες μπορούν να προσπελάσουν δεδομένα της βασικής κλάσης που είναι προστατευμένα (protected) ή δημόσια (public) και ποτέ τα ιδιωτικά (private). : public Private data Protected data Public data : private 92

93 Επίσης αντικείμενα της παράγωγης κλάσης μπορούν να προσπελάσουν δημόσια δεδομένα της βασικής κλάσης μόνο εάν η κλάση παράγεται δημόσια (δηλ η κλάση ProdA). Εάν η παράγωγη κλάση παράγεται ιδιωτικά (ProdΒ) δεν μπορούν να προσπελάσουν ούτε τα δημόσια δεδομένα. : public basic Private data1 Protected data2 Public data3 objecta objectb objecta.data3; : private basic Όταν δεν δηλώνουμε κατά την παραγωγή μιας κλάσης την λέξη κλειδί της προσπέλασης (public ή private), τότε θεωρείται από το πρόγραμμα ότι αυτή η κλάση παράγεται ιδιωτικά (private). Δηλαδή η παρακάτω δήλωση: class ProdA : Basic Ισοδυναμεί με τη δήλωση: class ProdA : Private Basic 93

94 Αντίστροφα δουλεύει; ΠΡΟΣΟΧΗ!!! Η κληρονομικότητα δεν λειτουργεί αντίστροφα. Δηλαδή εάν φτιάχναμε στην main() ένα αντικείμενο της βασικής κλάσης, αυτό θα είχε πρόσβαση μόνο!! στις μεθόδους της βασικής κλάσης και όχι στις μεθόδους που ανήκουν στην παραγόμενη κλάση. Basic Class ProdA Class Basic Class ProdA Class Object Constructor στην παραγομένη κλάση Αν και μπορούμε να χρησιμοποιήσουμε τον constructor δίχως όρισμα της βασικής κλάσης για να αρχικοποιήσουμε ένα αντικείμενο της παραγόμενης κλάσης, το ίδιο δεν μπορεί να συμβεί σε constructor με όρισμα της βασικής κλάσης. Σε αυτή την περίπτωση φτιάχνουμε constructors με όρισμα και χωρίς όρισμα και στην παραγόμενη κλάση. Έτσι για αρχικοποίηση από την παραγόμενη κλάση καλούμε τον constructor της βασικής. 94

95 Παράδειγμα constructor βασικής και παραγόμενης κλάσης class Produced:public Basic public: Produced():Basic() Produced(float temp):basic(temp) ΠΑΡΑΓΟΜΕΝΗ Constructor ΜΕ ΟΡΙΣΜΑ ΤΗΣ ΠΑΡΑΓΟΜΕΝΗΣ Constructor ΧΩΡΙΣ ΟΡΙΣΜΑ ΤΗΣ ΠΑΡΑΓΟΜΕΝΗΣ ΒΑΣΙΚΗ Constructor ΧΩΡΙΣ ΟΡΙΣΜΑ ΤΗΣ ΒΑΣΙΚΗΣ Constructor ΜΕ ΟΡΙΣΜΑ ΤΗΣ ΒΑΣΙΚΗΣ Όταν στην main() φτιάξουμε ένα αντικείμενο της παραγόμενης χωρίς όρισμα δηλ. το Produced Pr1 τότε εκτελείται η εντολή: Produced():Basic() Ο constructor Produced() καλεί τον constructor Basic() για την αρχικοποίηση του Pr1. Αντίστοιχα εάν φτιάξουμε ένα αντικείμενο με όρισμα δηλ. το Produced Pr2(20,5). Τότε εκτελείται η εντολή: Produced(float temp):basic(temp) όπου καλείται ο constructor Produced(float temp) με όρισμα και αυτός καλεί τον constructor Basic(temp) με όρισμα και του μεταβιβάζει την παράμετρο temp για να αρχικοποιηθεί το αντικείμενο Pr2. 95

96 Υπερφόρτωση συναρτήσεων μελών Μπορούμε μέσα σε μία παραγόμενη κλάση να φτιάξουμε συναρτήσεις μέλη που έχουν το ίδιο όνομα με κάποιες στην βασική κλάση. Με αυτόν τον τρόπο μπορούμε να χρησιμοποιούμε για έλεγχο τις συναρτήσεις των παραγομένων κλάσεων χωρίς να πειράζουμε τον κώδικα των συναρτήσεων της βασικής κλάσης. Αυτή η διαδικασία ονομάζεται υπερφόρτωση συναρτήσεων. Είναι πολύ σημαντικό να γνωρίζουμε ότι μέσα στην μέθοδο της παραγόμενης κλάσης για να καλέσουμε την αντίστοιχη με το ίδιο όνομα της βασικής κλάσης, θα πρέπει να χρησιμοποιούμε τον τελεστή διάκρισης εμβέλειας ( :: ), γιατί αλλιώς η μέθοδος καλεί τον εαυτό της με όχι και τόσο επιθυμητά αποτελέσματα για το πρόγραμμα. Σύνταξη υπερφόρτωσης class Prod:public Basic Public: void funca(orisma) if (orisma!=0) Basic::funcA(orisma); else Δημιουργία συνάρτησης στην παραγόμενη κλάση με το ίδιο όνομα με την συνάρτηση της βασικής Έλεγχος Χρήση της συνάρτησης της βασικής κλάσης (υπερφόρτωση) Στο παραπάνω παράδειγμα φτιάχνουμε μια συνάρτηση: funca(orisma) 96

97 που υπάρχει και στην βασική με το ίδιο όνομα και καλούμε μέσα σε αυτήν την συνάρτηση της βασικής, για να της περάσουμε την τιμή του ορίσματος μετά από κάποιον έλεγχο. Η συνάρτηση funca() της βασικής μπορεί να κάνει κάτι παρόμοιο με την αντίστοιχη της παραγόμενης ή κάτι διαφορετικό. Επίπεδα κλάσεων Μια κλάση μπορεί να παραχθεί από μια άλλη παραγόμενη κλάση. Δηλ. class Basic ; class ProdA:public Basic ; class ProdB:public ProdA ; Η κλάση ProdB είναι δημόσια παραγόμενη από την κλάση ProdA, που με την σειρά της είναι δημόσια παραγόμενη από την βασική κλάση Basic. Basic ProdA ProdC ProdB 97

98 Πολλαπλή κληρονομικότητα Μια κλάση μπορεί να παραχθεί από περισσότερες από μια βασικές κλάσεις. class FrstClass ; class ScndClass ; class PrdClass:public FrstClass, public ScndClass ; Η κλάση PrdClass παράγεται δημόσια από τις κλάσεις FrstClass και ScndClass, οι οποίες έχουν πρωτίστως οριστεί. FrstClass ScndClass PrdClass Περιεκτικότητα Μια άλλη σχέση που μπορεί να υπάρξει μεταξύ δύο κλάσεων εκτός από την κληρονομικότητα είναι η περιεκτικότητα όπου ένα αντικείμενο μιας κλάσης περιέχεται σε μια άλλη κλάση. Π.χ: class Basic_Class ; class Other_Class Basic_Class Bas1; Private: ; ΑΝΤΙΚΕΙΜΕΝΟ Bas1 ΤΗΣ ΚΛΑΣΗΣ Basic_Class ΜΕΣΑ ΣΤΗΝ ΚΛΑΣΗ Other_Class 98

99 ΠΑΡΑΔΕΙΓΜΑΤΑ ΚΛΗΡΟΝΟΜΙΚΟΤΗΤΑΣ Βασική και παράγωγες κλάσεις #include <iostream.h> class logariasmos //basikh klash protected: //prostateymeno dedomeno-melos float ypoloipo; public: logariasmos() //dhlosh constructor ypoloipo=0; float pareypoloipo() return ypoloipo; ; //telos basikhs klashs class tokoslogar:public logariasmos //paragomenh klash public: void tokos() //methodos paragomenhs klashs ypoloipo+=ypoloipo*0.1; ; //telos paragomenhs klashs void main() tokoslogar loga; //antikeimeno ths paragomenhs klashs cout <<"Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; loga.katathesi(120.0); cout <<"Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; loga.tokos(); cout <<"Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; //telos ths main Σχηματική παράσταση του προγράμματος. logariasmos tokoslogar 99

100 Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω παράδειγμα δημιουργήσαμε μια βασική κλάση logariasmos και μία δημόσια παραγόμενη κλάση tokoslogar. Στην main() δημιουργούμε ένα αντικείμενο loga της παράγωγης κλάσης tokoslogar. Το αντικείμενο από την στιγμή που δεν υπάρχει constructor στην κλάση tokoslogar αρχικοποιείται στην τιμή 0 χρησιμοποιώντας τον constructor της βασικής κλάσης logariasmos. Επίσης το αντικείμενο χρησιμοποιεί τις μεθόδους katathesi() και pareypoloipo() της κλάσης logariasmos. To δεδομένο-μέλος έχει δηλωθεί ως protected έτσι ώστε να είναι προσπελάσιμο και από την βασική κλάση στην οποία και ανήκει αλλά και στην παράγωγη (εάν ήταν private θα είχε πρόσβαση σε αυτό μόνο η κλάση στην οποία ανήκει δηλαδή η logariasmos. Η κληρονομικότητα δεν λειτουργεί αντίστροφα, δηλαδή εάν φτιάχναμε στην main() ένα αντικείμενο της βασικής κλάσης π.χ. logariasmos log1 αυτό θα είχε πρόσβαση μόνο στις μεθόδους της κλάσης στην οποία ανήκει και είναι η βασική αλλά όχι και στην μέθοδο tokos() που ανήκει στην παραγόμενη κλάση. Συνδυασμοί πρόσβασης #include <iostream.h> class Basic //basikh klash private: int privmember; //idiotiko dedomeno-melos protected: int protmember; //prostateymeno dedomeno-melos public: int publmember; //dhmosio dedomeno-melos ; //telos basikhs klashs class ProdA:public Basic //dhmosia paragomenh klash public: void method() int x; x=privmember; //mh prospelasimo x=protmember; //prospelasimo x=publmember; //prospelasimo ; //telos klashs ProdA 100

101 class ProdB:private Basic //idiotika paragomenh klash public: void method() int x; x=privmember; //mh prospelasimo x=protmember; //prospelasimo x=publmember; //prospelasimo ; //telos klashs ProdB void main() int y,z; ProdA anta; //antikeimeno ths paragomenhs ProdA y=anta.privmember; //mh prospelasimo y=anta.protmember; //mh prospelasimo y=anta.publmember; //prospelasimo ProdB antb; //antikeimeno ths paragomenhs ProdB z=antb.privmember; //mh prospelasimo z=antb.protmember; //mh prospelasimo z=antb.publmember; //mh prospelasimo //telos ths main Σχηματική παράσταση του προγράμματος. Basic ProdA ProdB Σύντομη εξήγηση του προγράμματος. Στο παραπάνω πρόγραμμα ορίζεται μία βασική κλάση Basic και δύο παραγόμενες κλάσεις, η μία δημόσια παραγόμενη ProdA και η άλλη ιδιωτικά ProdB. Στην βασική κλάση δηλώνονται τρία δεδομένα-μέλη, το πρώτο σαν ιδιωτικό, το δεύτερο σαν προστατευμένο και το τρίτο σαν δημόσιο. Μέθοδοι των παράγωγων κλάσεων μπορούν να έχουν πρόσβαση σε προστατευμένα και δημόσια δεδομένα-μέλη της βασικής κλάσης, όχι όμως σε ιδιωτικά. 101

102 Αντικείμενα παράγωγων κλάσεων δεν μπορούν να έχουν πρόσβαση σε προστατευμένα και ιδιωτικά δεδομένα-μέλη της βασικής κλάσης. Αντικείμενα της παράγωγης κλάσης που παράγεται δημόσια (ProdA) μπορούν να έχουν πρόσβαση σε δημόσια δεδομένα-μέλη της βασικής κλάσης. Αντικείμενα παράγωγης κλάσης που παράγεται ιδιωτικά (ProdB) δεν μπορούν να έχουν πρόσβαση ούτε στα δημόσια δεδομένα-μέλη της βασικής κλάσης. Εάν δεν δηλώσουμε τον τρόπο προσπέλασης κατά την δήλωση παραγωγής μιας κλάσης τότε θεωρείται ότι η κλάση αυτή παράγεται ιδιωτικά (private). Kληρονομικότητα και αρχεία επικεφαλίδας Μπορούμε βεβαίως να φτιάξουμε τις κλάσεις μας και να τις σώσουμε ως αρχεία κεφαλίδας έτσι ώστε να τιε ενσωματώνουμε (συμπεριλαμβάνουμε) σε όποιο πρόγραμμα εμείς επιθυμούμε. Πιο κάτω βλέπουμε το πρώτο παράδειγμα κληρονομικότητας που ενσωματώνει τις κλάσεις logariasmos και tokoslogar μέσα στην main ως αρχεία επικεφαλίδας πλέον. logariasmos.hpp class logariasmos protected: float ypoloipo; public: logariasmos() ypoloipo=0; ~logariasmos() void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!!!!"<<endl; cout<<"to poso ths analhpsis einai "<<endl; cout<<"megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() 102

103 ; return ypoloipo; tokoslogar.hpp #include "logariasmos.hpp" // enswmatwsh ths klashs logariasmos class tokoslogar:public logariasmos public: void tokos() ypoloipo+=ypoloipo*0.1; ; main.cpp #include <iostream.h> #include "tokoslogar.hpp" //enswmatwsh ths klashs tokoslogar void main() tokoslogar loga; cout <<"\nloga Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; logariasmos Log1; cout <<"\nlog1 Trexon ypoloipo:"<<log1.pareypoloipo()<<endl; //Log1.tokos(); loga.katathesi(120.0); cout <<"\nloga Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; loga.tokos(); cout <<"\nloga Trexon ypoloipo:"<<loga.pareypoloipo()<<endl; cout<<endl; Υπερφόρτωση συναρτήσεων #include <iostream.h> class logariasmos //basikh klash protected: //prostateymeno dedomeno-melos float ypoloipo; public: logariasmos() //constructor x.o. ypoloipo=0; 103

104 float pareypoloipo() return ypoloipo; ; //telos basikhs klashs class tokoslogar:public logariasmos //paragomenh klash public: tokoslogar():logariasmos() tokoslogar(float ypoloipo):logariasmos(ypoloipo) void tokos() //methodos paragomenhs klashs ypoloipo+=ypoloipo*0.1; void katathesi(float poso) if(poso>0) //elegxos arnhtikoy posou logariasmos::katathesi(poso); //yperfortosh else cout<<"mh egkyro poso"<<endl; void analhpsh(float poso) if(poso>0) //elegxos arnhtikoy posou logariasmos::analhpsh(poso); //yperfortosh else cout<<"mh egkyro poso"<<endl; ; //telos paragomenhs klashs void main() tokoslogar t1; //antikeimeno ths paragoghs klashs t1.katathesi(100); cout<<"neo ypoloipo toy t1= "<<t1.pareypoloipo()<<endl; t1.katathesi(-30); cout<<"neo ypoloipo toy t1= "<<t1.pareypoloipo()<<endl; t1.analhpsh(50); cout<<"neo ypoloipo toy t1= "<<t1.pareypoloipo()<<endl; t1.analhpsh(-45); cout<<"neo ypoloipo toy t1= "<<t1.pareypoloipo()<<endl; //telos ths main Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα έχουμε φτιάξει μεθόδους με το ίδιο όνομα και στην βασική logariasmos και στην παραγόμενη κλάση tokoslogar. Αυτό το κάνουμε 104

105 για να προσθέσουμε ένα τμήμα ελέγχου μέσα στις μεθόδους analhpsh() και katathesi() χωρίς να επηρεαστούν οι αντίστοιχες μέθοδοι της βασικής κλάσης. Στην main() φτιάχνουμε ένα αντικείμενο t1 της παράγωγης κλάσης tokoslogar όπου κάνει ανάληψη αλλά και κατάθεση με θετικό και αρνητικό ποσό. Στην εντολή t1.katathesi(100); καλείται η μέθοδος katathesi() της παραγόμενης κλάσης όπου και γίνεται ο έλεγχος για το αν το ορισμα είναι θετικό. Εάν το ποσό είναι θετικό τότε καλείται η μέθοδος katathesi() της βασικής κλάσης με την εντολή logariasmos::katathesi(poso); Το ίδιο ισχύει και για την μέθοδο analhpsh(). Είναι πολύ σημαντικό να γνωρίζουμε ότι μέσα στην μέθοδο της παραγόμενης κλάσης για να καλέσουμε την αντίστοιχη με το ίδιο όνομα της βασικής κλάσης θα πρέπει να χρησιμοποιούμε τον τελεστή διάκρισης εμβέλειας :: γιατί αλλιώς η μέθοδος καλεί τον εαυτό της με όχι και τόσο επιθυμητά αποτελέσματα για το πρόγραμμα. Επίσης βλέπουμε και την δήλωση και χρήση των συναρτήσεων εγκατάστασης (constructor) και στην παράγωγη κλάση tokoslogar όπου για να αρχικοποιήσουμε το δεδομένο-μέλος ypoloipo της βασικής συνάρτησης logariasmos, ο constructor της παράγωγης κλάσης (με όρισμα ή χωρίς όρισμα ) καλεί τον αντίστοιχο της βασικής. Constructors σε βασική και παραγόμενη κλάση class animal //vasikh klash protected: float age; bool male; int weight; public: animal () animal (float i, bool j, int k) //constructor me 3 orismata age = i; male = j; weight = k; 105

106 class cat:public animal //paragomenh klash private: char name[10]; public: cat () // constructor me 4 orismata cat (float a, bool b, int c, char d[]):animal (a, b, c) strcpy(onoma, d); Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω τμήμα ενός προγράμματος φαίνονται δύο κλάσεις. Η βασική που είναι η animal και η παραγόμενη που είναι η cat. Στην βασική κλάση έχουμε δημιουργήσει έναν constructor με 3 ορίσματα animal(float i,bool j,int k). Τα ορίσματα αφορούν στην ηλικία, το φύλλο και το βάρος του ζώου. Στην παραγόμενη κλάση ορίζουμε έναν constructor με 4 ορίσματα cat(float a, bool b,int c, char d[]) που αφορούν σε όλα της βασικής και σε ένα που ορίζουμε στην παραγόμενη κλάση και αφορά το όνομα του ζώου. Έτσι ώστε αν δημιουργήσουμε ένα αντικείμενο cata της κλάσης cat και δώσουμε 4 ορίσματα, τα τρία θα τα αρχικοποιεί ο constructor της βασικής και το ένα αυτός της παραγόμενης. Επίπεδα κληρονομικότητας class vehicle //vasikh klash protected: int rodes; char timoni[10]; public: void start() void stop() void turn() ; //telos vasikhs 106

107 class auto:public vehicle //paragomenh apo thn vasikh protected: int portes; char motor[20]; ; //telos paragomenhs class truck:public auto //paragomenh apo thn paragomenh private: char flatbed[10]; public: void liftflatbed() ; //telos paragomenhs Σχηματική παράσταση του προγράμματος. vehicle auto truck Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω τμήμα ενός προγράμματος φαίνονται τρεις κλάσεις. Η βασική είναι η vehicle από την οποία παράγεται η auto, η οποία κληρονομεί χαρακτηριστικά και μεθόδους από την vehicle. Κατόπιν φαίνεται η truck η οποία κληρονομεί χαρακτηριστικά και μεθόδους από την auto αλλά και από την vehicle. Ένα αντικείμενο της κλάσης truck έχει πρόσβαση στις μεθόδους και της auto και της vehicle. Ένα αντικείμενο της κλάσης auto έχει πρόσβαση στις μεθόδους της vehicle, αλλά όχι σε αυτές της truck. Ένα αντικείμενο της κλάσης vehicle έχει πρόσβαση μόνο στις μεθόδους της κλάσης του. 107

108 Αυτό συμβαίνει γιατί όπως έχουμε πει η έννοια της κληρονομικότητας δεν λειτουργεί αντίστροφα. Πολλαπλή κληρονομικότητα class screen //proth vasikh klash public: void showscreen(void); protected: char type[32]; long colors; int x_resol; int y_resol; ; class motherboard //deyterh vasikh klash public: void showmotherboard(void); protected: char processor[15]; int speed; int RAM; ; //pollaplh klhronomikothta class computer:public screen, public motherboard public: void showcomputer(void); private: char name[64]; int hdd; float floppy; ; Σχηματική παράσταση του προγράμματος. screen motherboard computer 108

109 Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα δηλώνονται δύο κλάσεις screen και motherboard από τις οποίες παράγεται μία κλάση computer η οποία κληρονομεί χαρακτηριστικά και μεθόδους και των δύο κλάσεων. Περιεκτικότητα #include <iostream.h> #include <string.h> class logariasmos //klash logariasmos protected: float ypoloipo; public: logariasmos() ypoloipo=0; float pareypoloipo() return ypoloipo; ; //telos klashs class Pelaths //klash pelaths private: int armht; char onoma[20]; //antikeimeno ths klashs logariasmos logariasmos log1; public: Pelaths() Pelaths(int armht1,char onoma1[]) armht=armht1; strcpy(onoma,onoma1); void parexrhma() float poso; cout<<"dose POSO ANALHPSIS:"; cin>>poso; //klhsh synarthshs apo klash logariasmos log1.analhpsh(poso); 109

110 void valexrhma() float poso; cout<<"dose POSO KATATHESIS:"; cin>>poso; //klhsh synarthshs apo klash logariasmos log1.katathesh(poso); void anaforaypoloipou() cout<<"to TREXON YPOLOIPO EINAI: " <<log1.pareypoloipo()<<endl; ; //telos klashs void main() Pelaths P1; P1.anaforaYpoloipou(); P1.valeXrhma(); P1.anaforaYpoloipou(); P1.pareXrhma(); P1.anaforaYpoloipou(); //telos main Σχηματική παράσταση του προγράμματος Class logariasmos Class Pelaths Log1 Αντικείμενο της κλάσης logariasmos μέσα στην κλάση Pelaths Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα βλέπουμε την σχέση της περιεκτικότητας ανάμεσα σε δύο ανεξάρτητες κλάσεις logariasmos και Pelaths. Κατασκευάζουμε ένα αντικείμενο log1 της κλάσης logariasmos μέσα στην κλάση Pelaths. Με αυτόν τον τρόπο το αντικείμενο log1 μπορεί να εκτελεί μεθόδους της κλάσης logariasmos μέσα από τη κλάση Pelaths. 110

111 ΠΕΡΙΕΚΤΙΚΟΤΗΤΑ ΜΕ ΥΠΕΡΦΟΡΤΩΣΗ ΜΕΘΟΔΩΝ #include <iostream.h> #include <string.h> class logariasmos //klash logariasmos protected: float ypoloipo; public: logariasmos() ypoloipo=0; logariasmos(float arxiko_ypoloipo) ypoloipo=arxiko_ypoloipo; void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"poso ANALHPSIS MEGALYTERO APO TO YPOLOIPO"<<endl; void katathesh(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; ; //telos klashs class tokoslogar:public logariasmos //paragomenh klash tokoslogar public: tokoslogar():logariasmos() //constructor xoris orisma tokoslogar(float ypoloipo):logariasmos(ypoloipo) //constructor me orisma void tokosstd() //methodos apodoshs sygkekrimenoy epitokioy ypoloipo+=ypoloipo*0.1; void tokosobject(float a) //methodos apodoshs epitokioy apo antikeimeno ypoloipo+=ypoloipo*(a/100); void tokospelaths()//methodos apodoshs epitokioy apo ton xrhshth float a; cout<<"dvse to epitokio: "; cin>>a; 111

112 ypoloipo+=ypoloipo*(a/100); cout<<"me epitokio: "<<a<<"%"<<endl; cout<<"to ypoloipo soy einai:"<<ypoloipo<<endl; void katathesh(float poso) if(poso>0) //elegxos arnhtikoy posou logariasmos::katathesh(poso); //oveloading katathesi() else cout<<"mh egkyro poso"<<endl; void analhpsh(float poso) if(poso>0) //elegxos arnhtikoy posou logariasmos::analhpsh(poso); //oveloading analhpsh() else cout<<"mh egkyro poso"<<endl; ; //telos paragomenhs klashs class Pelaths //anexarthth klash pelaths private: int armht; char onoma[20]; tokoslogar log1; //antikeimeno ths klashs tokoslogar public: Pelaths() Pelaths(int armht1,char onoma1[]) //eisagwgh stoixeiwn apo antikeimeno armht=armht1; strcpy(onoma,onoma1); void givestoixeia() //eisagwgh stoixeiwn apo xrhsth cout<<"dwse Ari8mo Mhtrwou: "; cin>>armht; cout<<"dwse Onoma: "; cin>>onoma; void showstoixeia() //emfanish stoixeiwn cout<<armht<<" "; cout<<onoma<<endl; void parexrhma() //analhpsh apo klash Pelaths float poso; char choice; do cout<<"dose POSO ANALHPSIS:"; cin>>poso; if(poso>0) 112

113 else cin>>choice; while(choice=='y'); //klhsh analhpshs apo klash logariasmos log1.analhpsh(poso); break; cout<<"mh Egkyro poso"<<endl; cout<<"xanaprospathise Y(Nai) or N(Oxi):"; void valexrhma() // katathesh apo klash Pelaths float poso; char choice; do cout<<"dose POSO KATATHESIS:"; cin>>poso; if(poso>0) //klhsh katatheshs apo klash logariasmos log1.katathesh(poso); break; else cout<<"mh Egkyro poso"<<endl; cout<<"xanaprospathise Y(Nai) or N(Oxi):"; cin>>choice; while(choice=='y'); void PareToko() //apodosh tokou log1.tokospelaths(); //klhsh tokospelaths apo klash tokoslogar void anaforaypoloipou() //klhsh pareypoloipo apo klash logariasmos cout<<"to TREXON YPOLOIPO EINAI: "<<log1.pareypoloipo()<<endl; ; //telos klashs void main() //synarthsh main Pelaths P1(1001, "Marios"); cout<<"\nprwtos PELATHS"<<endl; cout<<"kalwsorises "<<endl; P1.showStoixeia(); P1.anaforaYpoloipou(); P1.valeXrhma(); P1.anaforaYpoloipou(); P1.pareXrhma(); P1.anaforaYpoloipou(); 113

114 cout<<"\ndeyteros PELATHS"<<endl; Pelaths P2; P2.giveStoixeia(); cout<<"kalwsorises "<<endl; P2.showStoixeia(); P2.anaforaYpoloipou(); P2.valeXrhma(); P2.anaforaYpoloipou(); P2.pareXrhma(); P2.anaforaYpoloipou(); cout<<"====twra 8A PAREIS TOKO===="<<endl; P2.PareToko(); cout<<"exei YPOLOIPO LOGARIASMOU"<<endl; P2.anaforaYpoloipou(); cout<<endl<<endl; cout<<"====anafora YPOLOIPWN===="<<endl; cout<<"\n O PELATHS "; P1.showStoixeia(); cout<<"exei YPOLOIPO LOGARIASMOU"<<endl; P1.anaforaYpoloipou(); cout<<endl; cout<<"\n O PELATHS "; P2.showStoixeia(); cout<<"exei YPOLOIPO LOGARIASMOU"<<endl; P2.anaforaYpoloipou(); //telos main Σύντομη εξήγηση του προγράμματος. Στο παραπάνω πρόγραμμα έχουμε ενσωματώσει και την υπερφόρτωση συναρτήσεων στο παράδειγμα περιεκτικότητας. Υπάρχουν οι κλάσεις logariasmos (βασική κλάση), tokoslogar (παράγωγη της logariasmos) και Pelaths (ανεξάρτητη κλάση που χρησιμοποιεί συναρτήσεις από τις δύο άλλες κλάσεις μέσω της περιεκτικότητας). Στην κλάση tokoslogar έχουμε ενσωματώσει άλλες δύο μεθόδους απόδοσης τόκου στο υπόλοιπο την tokosobject(float a) η οποία ενημερώνει το υπόλοιπο με επιτόκιο που δίνει το αντικείμενο και την tokospelaths() η οποία ενημερώνει το υπόλοιπο με επιτόκιο που δίνει ο χρήστης από το πληκτρολόγιο. Συνεχίζει να υφίσταται η μέθοδος tokosstd() η οποία ενημερώνει το υπόλοιπο με επιτόκιο 10%. Στην ανεξάρτητη κλάση Pelaths γίνεται υπερφόρτωση των μεθόδων analhpsh() και katathesh() της κλάσης logariasmos, μέσα πλέον στις μεθόδους valexrhma() και parexrhma() οι οποίες χρησιμοποιούνται από τα αντικείμενα της κλάσης Pelaths. Μέσα στις τελευταίες μεθόδους γίνεται και ο έλεγχος απόδοσης μη αρνητικού ποσού με την προτροπή αν γίνει αυτό και ξαναδοθεί νέο ποσό από τον χρήστη. 114

115 Σχηματική παράσταση κληρονομικότητας ΟΧΗΜΑ Ρόδες Τιμόνι Ξεκινά() Σταματά() Στρίβει() Βασική κλάση όχημα παράγωγες κλάσεις από όχημα ΑΥΤΟΚΙΝΗΤΟ ΠΟΔΗΛΑΤΟ ΜΗΧΑΝΗ Μηχανή Πόρτες Συμπλέκτης Σταντ Μηχανή Σταντ Συμπλέκτης ΦΟΡΤΗΓΟ Καρότσα Ανατροπή() ΕΠΙΒΑΤΙΚΟ Πίσω πόρτα ΛΕΩΦΟΡΕΙΟ Πολλά καθίσματα παράγωγες κλάσεις από αυτοκίνητο 115

116 ΥΠΕΡΦΟΡΤΩΣΗ ΤΕΛΕΣΤΩΝ Τι είναι υπερφόρτωση τελεστών Η ιδιότητα με την οποία στην C++ μπορούμε να έχουμε τελεστές που να ενεργούν διαφορετικά μέσα στο ίδιο πρόγραμμα την ονομάζουμε υπερφόρτωση. Το χαρακτηριστικό αυτό της C++ δηλαδή την διαφορετική χρησιμοποίηση των τελεστών μέσα στο ίδιο πρόγραμμα το λέμε πολυμορφισμό. Άρα Μία γλώσσα προγραμματισμού είναι αντικειμενοστραφής όταν συνδυάζει τα χαρακτηριστικά των κλάσεων-αντικειμένων, της κληρονομικότητας και του πολυμορφισμού. Γιατί χρειαζόμαστε την υπερφόρτωση τελεστών Οι τελεστές π.χ. +, -, *, /, <<, ==, <, >,!= κ.τ.λ. όπως τους ξέρουμε ενεργούν μόνο επάνω σε μεταβλητές. Π.χ: z=x+y ή a+=b*c ή i<j Τι γίνεται όμως όταν έχουμε αντικείμενα; Δηλ: log3 = log1 + log2 εδώ ο compiler θα εντοπίσει λάθος. Εδώ θα χρειαστούμε την ιδιότητα της υπερφόρτωσης τελεστών. 116

117 Υπερφόρτωση του τελεστή << Ο τελεστής << ξέρουμε ότι είναι αυτός που μαζί με τα αντικείμενα cin και cout καθορίζει την ροή εισόδου ή εξόδου των δεδομένων στην C++. Μπορεί επίσης με υπερφόρτωση να ενεργήσει σε δύο ακέραιους και να μετακινήσει τα δυαδικά τους ψηφία προς τα αριστερά. Δηλαδή στην έκφραση: 3 << 2 Μετακινεί προς τα αριστερά τα δυαδικά ψηφία του ακέραιου που βρίσκεται στα αριστερά του (δηλαδή του ακέραιου 3), τόσες θέσεις όσες ορίζει ο ακέραιος που βρίσκεται στα δεξιά του (δηλαδή 2 θέσεις). Εξετάζοντας το προηγούμενο παράδειγμα βλέπουμε ότι στο δυαδικό σύστημα ο δεκαδικός αριθμός 3 γράφεται 11. Εάν ο 11 μετακινηθεί κατά δύο θέσεις στα αριστερά όπως του ορίζει ο αριθμός 2, τα κενά που θα προκύψουν δεξιά του αριθμού συμπληρώνονται από δύο μηδενικά, άρα ο αριθμός γίνεται Ο δυαδικός αριθμός 1100 που προέκυψε τώρα είναι ο δεκαδικός αριθμός 12. Ο δυαδικός αριθμός 12 προκύπτει από την παράσταση: 1* * * *2 0 = = 12 Άλλο ένα παράδειγμα υπερφόρτωσης του << Έστω η έκφραση: -2<<4 Εξετάζοντας αυτό το παράδειγμα βλέπουμε ότι στο δυαδικό σύστημα ο δεκαδικός αριθμός -2 γράφεται όπου το πρώτο 1 ορίζει ότι ο αριθμός είναι αρνητικός. Εάν μετακινηθεί κατά τέσσερις θέσεις στα αριστερά όπως του ορίζει ο δεξιός τελεστέος, τα κενά που θα προκύψουν δεξιά του αριθμού συμπληρώνονται από τέσσερα μηδενικά, άρα ο αριθμός γίνεται Ο δυαδικός αριθμός που προέκυψε τώρα είναι ο δεκαδικός αριθμός

118 Τελεστές αύξησης (++) και μείωσης (--) ως μετρητές Πιο κάτω εξηγείται η λειτουργία μεταβλητών ως τελεστές αύξησης και μείωσης κατά 1: ++i Η τιμή της μεταβλητής i αυξάνει κατά 1 και μετά χρησιμοποιείται. i++ Πρώτα χρησιμοποιείται η τιμή της μεταβλητής i και μετά αυξάνεται κατά 1. --i Η τιμή της μεταβλητής i μειώνεται κατά 1 και μετά χρησιμοποιείται. i-- Πρώτα χρησιμοποιείται η τιμή της μεταβλητής i και μετά μειώνεται κατά 1. Οι τελεστές ανάθεσης τιμής (+=) και (-=) Οι τελεστές + και - χρησιμοποιούνται επίσης για αύξηση και μείωση τιμών των μεταβλητών ως ακολούθως: x+=y η τιμή της μεταβλητής x αυξάνεται κατά y ή αλλιώς x=x+y x-=y η τιμή της μεταβλητής x μειώνεται κατά y ή αλλιώς x=x-y; x+=y*z; η τιμή της μεταβλητής x αυξάνεται κατά y*z ή αλλιώς x=x+(y*z) και όχι x=(x+y)*z; Τελεστές με αντικείμενα Τι γίνεται όμως όταν έχουμε αντικείμενα; Μπορούμε δηλαδή: Να αυξήσουμε την τιμή ενός αντικειμένου; (++log1) 118

119 ή Να κάνουμε πράξεις με τις τιμές αντικειμένων; (log3=log1+log2) για να το κάνουμε αυτό πρέπει να χρησιμοποιήσουμε στην συνάρτηση που θα χρειαστεί να αυξήσει τιμή στο αντικείμενο, την λέξη κλειδί operator. Η λέξη αυτή επεκτείνει την χρήση του εκάστοτε τελεστή (++, --, +, - κλπ) από τις μεταβλητές και στα αντικείμενα. Με την λέξη operator φτιάχνουμε συνάρτηση αύξησης ή μείωσης της τιμής. Υπάρχουν δύο μορφές χρήσης του operator, η προθεματική όπου ο τελεστής βρίσκεται αριστερά από το δεδομένομέλος και η επιθεματική όπου ο τελεστής βρίσκεται δεξιά από το δεδομένομέλος. Τις δύο μορφές τις αναλύουμε παρακάτω. Προθεματική χρήση του operator Εάν έχουμε προθεματική μορφή τελεστή (++i) τότε ο operator γίνεται: void operator ++() ++i; Τώρα στο αντικείμενο που θα φτιάξουμε θα εφαρμόσουμε κατευθείαν επάνω του τον τελεστή ++ χωρίς να υπάρξει λάθος του compiler δηλ. ++log1 119

120 Επιθεματική χρήση του operator Εάν έχουμε επιθεματική μορφή τελεστή (i++) τότε ο operator γίνεται: void operator ++(int) i++; Το int μέσα στην παρένθεση δεν σημαίνει ότι υπάρχει ακέραιος αριθμός, αλλά κάνει τον compiler να ξεχωρίσει πως θα χρησιμοποιήσει τον operator. Μπορούμε τώρα να εφαρμόσουμε τον τελεστή ++ πάνω στο αντικείμενο δηλ log1++ Υπερφόρτωση του τύπου x+=y Κάπως έτσι μπορούμε να χρησιμοποιήσουμε υπερφόρτωση του τελεστή ανάθεσης τιμής με την χρήση του operator ως εξής: void operator ++() i+=2; Υπερφόρτωση του τελεστή άθροισης (+) Για να μπορέσουμε να προσθέσουμε αντικείμενα δηλ. log3=log1+log2; 120

121 θα πρέπει να χρησιμοποιήσουμε τον πιο κάτω κώδικα: logariasmos operator+ (logariasmos log) logariasmos temp; temp.ypoloipo=ypoloipo+log.ypoloipo; return temp; Τώρα μπορούμε να προχωρήσουμε στην αρχική έκφραση και να προσθέσουμε τις τιμές των αντικειμένων σαν να προσθέτουμε απλές μεταβλητές. Η συνάρτηση έχει την τιμή του log1 και το όρισμα μέσα στην παρένθεση είναι το log2. Υπερφόρτωση συγκριτικού τελεστή > Μπορούμε με το ίδιο σκεπτικό να υπερφορτώσουμε και συγκριτικούς τελεστές. H πρακτική αυτή μας βοηθά να συγκρίνουμε απευθείας τιμές αντικειμένων μέσα στην main() δηλ. log1>log2 bool operator > (logariasmos log) if(ypoloipo>log.ypoloipo) return true; else return false; 121

122 Υπόλοιποι τελεστές Κατά αντιστοιχία γίνεται υπερφόρτωση και των υπολοίπων τελεστών. Δηλαδή για τους δυαδικούς: Ο τελεστής >> όπως ο τελεστής << για τους αριθμητικούς: Ο τελεστής -- όπως ο τελεστής ++ Ο τελεστής - όπως ο τελεστής + για τους συγκριτικούς: Ο τελεστής < όπως ο τελεστής > Ο τελεστής =! όπως ο τελεστής == Επίσης υπερφορτώνεται και ο τελεστής κλήσης συνάρτησης (). Ποιοι τελεστές δεν υπερφορτώνονται Όλοι οι τελεστές μπορούν να υπερφορτωθούν εκτός από τους παρακάτω: Τελεστής Περιγραφή. Τελεστής κλήσης.* Τελεστής δείκτη σε μέλος : : Τελεστής διακρίβωσης εμβέλειας? : Τελεστής υπό όρους. Περιορισμοί της υπερφόρτωσης τελεστών Με την υπερφόρτωση δεν αλλάζει: η προτεραιότητα του τελεστή, η προσεταιριστικότητα του τελεστή, 122

123 το πλήθος των τελεστέων που δέχεται ο τελεστής (π.χ. ο δυαδικός δέχεται πάντα δύο τελεστέους), η σημασία του τρόπου λειτουργίας του τελεστή (π.χ ο τελεστής * πολλαπλασιάζει δύο τελεστέους και αυτό δεν αλλάζει). Δεν μπορούμε να δημιουργήσουμε καινούριους τελεστές για να τους υπερφορτώσουμε (χρησιμοποιούμε μόνο τους ήδη υπάρχοντες). Τους συναφείς τελεστές π.χ + και += τους υπερφορτώνουμε ξεχωριστά (δηλ. σε διαφορετικές συναρτήσεις υπερφόρτωσης). Οι συναρτήσεις υπερφόρτωσης μπορεί και να μην είναι μέλη κλάσεων (δηλ. μπορούν να δηλώνονται αυτόνομες μέσα στο πρόγραμμα). Οι συναρτήσεις υπερφόρτωσης των τελεστών (), [], -> πρέπει οπωσδήποτε να είναι μέλη κλάσεων. 123

124 ΠΑΡΑΔΕΙΓΜΑΤΑ ΥΠΕΡΦΟΡΤΩΣΗΣ ΤΕΛΕΣΤΩΝ Υπερφόρτωση του τελεστή ροής << #include <iostream.h> #include <process.h> void main () int a,b,x; while(1) cout<<"\n=================================" ; cout<<"\ndose arithmo H 0 gia exodo:"; cin>>a; if(a==0) cout<<"\n -telos programmatos-\n"; exit(0); cout<<"\nose plithos theseon gia metakinhsh :"; cin>>b; x=a<<b; // metakinhsh toy arithmou cout<<"\no arithmos poy edoses einai : " ; cout<<a; cout<<"\nplithos bits poy metakinhthikan :"; cout<<b; cout<<"\no neos arithmos einai :"; // edo kai se oles tis cout typonei times cout<<x<<endl; Σύντομη εξήγηση του προγράμματος. Στο παραπάνω πρόγραμμα χρησιμοποιούμε τον τελεστή ροής << στην έκφραση a<<b για να μετακινήσουμε τα δυαδικά ψηφία προς τα αριστερά ενός δεκαδικού αριθμού a, τόσες θέσεις όσες δηλώνει ο αριθμός που βρίσκεται δεξιά του τελεστή δηλαδή ο αριθμός b. O τελεστής θα λειτουργήσει με υπερφόρτωση μόνο στην παράσταση x=a<<b; Σε όλες τις άλλες γραμμές του κώδικα θα λειτουργεί σαν τελεστής ροής εισόδου εξόδου μαζί με τα αντικείμενα cin και cout. Στην επανάληψη while(1) το 1 μέσα στην παρένθεση είναι μία σταθερά μεγαλύτερη του 0 και αντικαθιστά την συνθήκη (1>0), δηλαδή επαληθεύεται 124

125 διαρκώς. Άρα οι εντολές της while εκτελούνται ασταμάτητα, εωσότου εισάγουμε τον αριθμό 0 όπου εκεί ενεργεί η συνάρτηση exit(0) η οποία προκαλεί άμεση διακοπή του προγράμματος. Η exit() βρίσκεται μέσα στο αρχείο κεφαλίδας process.h το οποίο και συμπεριλαμβάνουμε στην αρχή του προγράμματος. Έξοδος του προγράμματος: αν a=3 (11) 2 και b=2 τότε το x γίνεται (1100) 2 12 αν a=12 (1100) 2 και b=3 τότε το x γίνεται ( ) 96 αν a=-2 ( ) 2 και b=4 τότε το x γίνεται ( ) -32 Υπερφόρτωση του τελεστή αύξησης κατά # include <iostream.h> class metritis private: int met; public: metritis() //constructor met=0; void calc_met() //func gia afkshsh met ++met; int get_met() //func gia lhpsh timhs met return met; ; void main() metritis met1,met2; //2 antikeimena me timh 0 int m,k,i; //topikes metavlhtes i=0; ++i; //afkshsh kata 1 ++i; //afkshsh kata 1 cout<<"\nmetriths i="<<i; cout<<"\n\n"; m=met1.get_met(); //apodosh ths timhs met (0) sto m k=met2.get_met(); //apodosh ths timhs met (0) sto k cout<<"\nmetriths met1= "<<m; cout<<"\nmetriths met2= "<<k; cout<<endl; 125

126 met1.calc_met(); //afkshsh kata 1 toy met1 (1) met2.calc_met() ; //afkshsh kata 1 toy met2 (1) met1.calc_met(); //afkshsh kata 1 toy met1 (2) met1.calc_met() ; //afkshsh kata 1 toy met1 (3) //ektyposh ths timhs tou met1 cout<<"\netriths met1="<<met1.get_met(); //ektyposh ths timhs tou met2 cout<<"\netriths met2="<<met2.get_met(); //prosthesi kai apodosh timhs sto k k=met1.get_met()+met2.get_met(); cout<<"\nto athroisma einai :"<<k<<endl; //ektyposh toy k Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα βλέπουμε ότι χρησιμοποιούμε τον τελεστή ++ και στην τοπική μεταβλητή i της main αλλά και στο δεδομένο μέλος met της κλάσης metritis ο οποίος λειτουργεί όπως πρέπει σε αυτές. Αυξάνει δηλαδή κατά ένα δύο φορές την i μέσα στην main αλλά και με την κλήση της calc_met() από τα αντικείμενα met1 και met2 αυξάνει την τιμή του δεδομένου μέλους met για κάθε αντικείμενο. Στο τέλος προσθέτει τις δύο τιμές και τις εκχωρεί εκ νέου στην μεταβλητή k. Εάν γράψουμε ++met1 προσπαθώντας να αυξήσουμε την τιμή του αντικειμένου ο compiler θα μας δώσει λάθος. Γι αυτόν τον λόγο χρησιμοποιούμε την λέξη κλειδί operator με τον τελεστή ++ αντί της συνάρτησης calc_met(). Τώρα εάν χρησιμοποιήσουμε την έκφραση ++met1; ο compiler θα αυξήσει την τιμή του αντικειμένου χωρίς λάθος. Αυτό φαίνεται στο πιο κάτω πρόγραμμα. # include <iostream.h> ///////////////////////////////////////////////////////// void operator ++() //yperfortosh telesth ++ ++met; int get_met() //func gia lhpsh timhs met return met; ; void main() 126

127 /////////////////////////////////////////////////////////// cout<<"\nmetriths met2= "<<k; cout<<endl; ++met1; //afkshsh me yperfortosh ++met2; //afkshsh me yperfortosh ++met1; //afkshsh me yperfortosh ++met1; //afkshsh me yperfortosh ////////////////////////////////////////////////////////////// cout<<"\nto athroisma einai :"<<k<<endl; //ektyposh toy k Στο πιο πάνω παράδειγμα έχουμε προθεματική χρήση του operator. Για επιθεματική χρήση του operator η αλλαγή είναι πιο κάτω. # include <iostream.h> ///////////////////////////////////////////////////////// //epithematikh yperfortosh telesth ++ void operator ++(int) met++; int get_met() //func gia lhpsh timhs met return met; ; void main() /////////////////////////////////////////////////////////// cout<<"\nmetriths met2= "<<k; cout<<endl; met1++; //afkshsh me epithematikh yperfortosh met2++; //afkshsh me epithematikh yperfortosh met1++; //afkshsh me epithematikh yperfortosh met1++; //afkshsh me epithematikh yperfortosh ////////////////////////////////////////////////////////////// cout<<"\nto athroisma einai :"<<k<<endl; //ektyposh toy k 127

128 Προθεματική και επιθεματική υπερφόρτωση #include <iostream.h> class test private: unsigned int met; public: test() //constructor xoris orisma met = 0; test(int x) //constructor me orisma met=x ; test operator ++() //prothematikh morfh return test(++met); test operator ++(int) //epithematikh morfh return test(met++); int get_met() return met; ; void main() test t1,t2 ; cout<<"\nt1 = "<<t1.get_met(); //(t1=0) cout<<"\nt2 = "<<t2.get_met(); //(t2=0) ++t1; //prothamatikh yperfortosh (t1=1) ++t1; //prothamatikh yperfortosh (t1=2) t2=++t1; // (t1=3, t2=3) cout<<"\nt1 = "<<t1.get_met(); cout<<"\nt2 = "<<t2.get_met(); t2=t1++; //epithamatikh yperfortosh (t2=3,t1=4) t2=t1++; //epithamatikh yperfortosh (t2=4,t1=5) cout<<"\nt1 = "<<t1.get_met(); cout<<"\nt2 = "<<t2.get_met(); cout<<"\n\n"; Εξοδος: 1 Ο cout t1=0, t2=0 2 Ο cout t1=3, t2=3 3 Ο cout t1=5, t2=4 128

129 Υπερφόρτωση αριθμητικού τελεστή + #include <iostream.h> class logariasmos private: float ypoloipo; public: logariasmos() //dhlosh constructor ypoloipo=0; ~logariasmos() //dhlosh destructor //orismos synarthshs gia yperfortwsh //telesth prostheshs logariasmos operator+ (logariasmos a) logariasmos sum; sum.ypoloipo=ypoloipo+a.ypoloipo; return sum; void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!!!!"<<endl; cout<<"to poso ths analhpsis einai megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; ; void main() logariasmos log1,log2,log3; cout<<endl; cout<<"dhmiourgia 3 antikeimenwn"<<endl; cout<<"enarxh synallagwn"<<endl; cout<<"=========================================="<<endl; cout<<"arxika ypoloipa"<<endl; cout<<"log1: "<<log1.pareypoloipo()<<" Euro"<<endl; 129

130 cout<<"log2: "<<log2.pareypoloipo()<<" Euro"<<endl; cout<<"log3: "<<log3.pareypoloipo()<<" Euro"<<endl; cout<<"=========================================="<<endl; cout<<"=========================================="<<endl; cout <<"Katathesi 100 Euro apo to log1"<<endl; log1.katathesi(100.0); cout <<"Katathesi 200 Euro apo to log2"<<endl; log2.katathesi(200.0); cout<<"=========================================="<<endl; cout<<"ta ypoloipa eginan"<<endl; cout<<"log1: "<<log1.pareypoloipo()<<" Euro"<<endl; cout<<"log2: "<<log2.pareypoloipo()<<" Euro"<<endl; cout<<"log3: "<<log3.pareypoloipo()<<" Euro"<<endl; cout<<"=========================================="<<endl; cout<<"=========================================="<<endl; cout <<"Analhpsh 70 Euro apo to log1"<<endl; log1.analhpsh(70.0) ; cout<<"=========================================="<<endl; cout <<"Ta ypoloipa twra einai:"<<endl; cout<<"log1: "<<log1.pareypoloipo()<<" Euro"<<endl; cout<<"log2: "<<log2.pareypoloipo()<<" Euro"<<endl; cout<<"log3: "<<log3.pareypoloipo()<<" Euro"<<endl; cout<<"=========================================="<<endl; cout<<"prosthesi twn ypoloipwn log1 me to log2"<<endl; cout<<"=========================================="<<endl; log3=log1+log2; cout <<"Ta ypoloipa twra einai:"<<endl; cout<<"log1: "<<log1.pareypoloipo()<<" Euro"<<endl; cout<<"log2: "<<log2.pareypoloipo()<<" Euro"<<endl; cout<<"log3: "<<log3.pareypoloipo()<<" Euro"<<endl; cout<<"=========================================="<<endl; cout<<"=========================================="<<endl; cout<<"telos synallagwn"<<endl; cout<<"=========================================="<<endl; cout<<endl; Σύντομη εξήγηση του προγράμματος. Εδώ έχουμε την χρήση του operator για υπερφόρτωση του τελεστή πρόσθεσης +. Στη συνάρτηση υπερφόρτωσης δηλώνουμε ένα αντικείμενο sum που θα δεχθεί το αποτέλεσμα της άθροισης, θα επιστραφεί στο πρόγραμμα και θα αποδοθεί στο αντικείμενο στο οποίο εκχωρείται η τιμή της άθροισης και είναι το log3. Επίσης στην συνάρτηση υπερφόρτωσης χρησιμοποιούμε ως όρισμα το αντικείμενο που βρίσκεται δεξιά του τελεστή + στην προταση που βρίσκεται μέσα στη main() (log3=log1+log2), δηλαδή το αντικείμενο log2. Επειδή η συνάρτηση υπερφόρτωσης ανήκει και στο αντικείμενο που βρίσκεται αριστερά 130

131 από τον τελεστή, δηλαδή στο log1 η αναφορά στο δεδομένο-μέλος της κλάσης logariasmos γίνεται άμεσα. Το αποτέλεσμα είναι να προσθέτουμε τα αντικείμενα σαν να ήταν μεταβλητές και να έχουμε αποτέλεσμα το άθροισμα των δεδομένων-μελών ypoloipo. Υπερφόρτωση συγκριτικού τελεστή > #include <iostream.h> class logariasmos private: float ypoloipo; public: logariasmos() ypoloipo=0; logariasmos(float arxiko_ypoloipo) ypoloipo=arxiko_ypoloipo; ~logariasmos() void analhpsh(float poso) if (poso<=ypoloipo) ypoloipo=ypoloipo-poso; else cout<<"prosoxh!!!!!!"<<endl; cout<<"poso megalytero apo to ypoloipo"<<endl; void katathesi(float poso) ypoloipo+=poso; float pareypoloipo() return ypoloipo; //operator me sygritiko telesth 131

132 bool operator >( logariasmos log) if (ypoloipo>log.ypoloipo) return true; else return false; ; //telos klashs void main() logariasmos log1(200.0), log2(120.0), log3(50.0), log4(110.0); //yperfortvsh gia thn sygkrish logariasmon if (log1>log2) cout<< log1 > log2 <<endl; else cout<< log2 >= log1 <<endl; if (log3>log4) cout<< log3 > log4 <<endl; else cout<< log4 >= log3 <<endl; Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα χρησιμοποιούμε υπερφόρτωση του συγκριτικού τελεστή > για να μπορούμε να συγκρίνουμε δύο λογαριασμούς. Υπερφόρτωση του τελεστή κλήσης συνάρτησης () // doublestatementclass.h class doublestatement //dhlwsh klashs public: doublestatement(); int operator() (int,int); //yperfortwsh ths parentheshs private: int ArrayA[10][10]; //pinakas ws dedomeno-melos ; // overl_parentesis.cpp #include <iostream.h> #include "doublestatementclass.h" //symperilhpsi toy arxeiou ths klashs doublestatement::doublestatement() //constructor xwris orisma 132

133 for(int loopa=0; loopa<10; ++loopa) for(int loopb=0; loopb<10; ++loopb) ArrayA[loopA][loopB]=loopB; int doublestatement::operator() (int a, int b) //orismos yperfortwshs return ArrayA[a][b]; int main() doublestatement ds1; //antikeimeno cout<<"to stoixeio ArrayA[3][6] exei thn timh: "<<ds1(2,6)<<endl; //cout<<"to stoixeio ArrayA[3][6] exei thn timh: "<<ds1[3][6]<<endl; return 0; Σύντομη εξήγηση του προγράμματος. Στο πιο πάνω πρόγραμμα χρησιμοποιούμε υπερφόρτωση του τελεστή παρένθεσης ή αλλιώς τελεστή κλήσης συνάρτησης. Στο αρχείο κεφαλίδας δηλώνουμε την κλάση doublestatement και στο αρχείο του προγράμματος ορίζουμε τις συναρτήσεις της κλάσης. Ορίζουμε δηλαδή τον constructor ο οποίος αρχικοποιεί με τιμές από το 0-9 όλες τις γραμμές του πίνακα ArrayA, αλλά και την συνάρτηση με την οποία γίνεται η υπερφόρτωση του τελεστή κλήσης συνάρτησης. Μέσα στην main() δηλώνουμε ένα αντικείμενο της κλάσης και εξάγουμε στην οθόνη την τιμή ενός συγκεκριμένου στοιχείου του πίνακα ArrayA, όχι όμως με την γνωστή μορφή αλλά με την μορφή που έχουν οι πίνακες σε άλλες γλώσσες προγραμματισμού δηλαδή ds1(2,6). 133

134 ΔΕΙΚΤΕΣ Τι είναι οι δείκτες Οι δείκτες είναι μεταβλητές που δεν έχουν δικές τους τιμές, αλλά αναφέρονται (δείχνουν) σε άλλες μεταβλητές και χρησιμοποιούν τις τιμές τους. Η αναφορά σε μία άλλη μεταβλητή γίνεται με βάση την διεύθυνση που έχει στην μνήμη η μεταβλητή αυτή. Ένας δείκτης λοιπόν έχει ως περιεχόμενο την διεύθυνση της μεταβλητής, άρα έχει έμμεση πρόσβαση στην τιμή της μεταβλητής αφού αναφέρεται στην διεύθυνσή της. Άρα μια μεταβλητή αναφέρεται άμεσα σε μία τιμή ενώ ένας δείκτης αναφέρεται έμμεσα σε μια τιμή. Που τους χρησιμοποιούμε Οι δείκτες είναι πολύ χρήσιμοι για την κατασκευή μιας δομής δεδομένων. Δηλαδή τους χρησιμοποιούμε: στις Λίστες στις Στοίβες στις Ουρές στους Γράφους Σε πολλές γλώσσες προγραμματισμού συναντάμε τους δείκτες, ορισμένες μάλιστα χρησιμοποιούν δείκτες κρυφά από τους χρήστες για να μην τους μπερδεύουν. Οι δείκτες στην ουσία μας επιτρέπουν να κάνουμε καλύτερη διαχείριση μνήμης στα προγράμματά μας. Δείκτες χρησιμοποιούμε επίσης και σαν παραμέτρους σε συναρτήσεις. Δήλωση δεικτών Έστω ότι έχουμε ορίσει την μεταβλητή int a; Η οποία έχει την τιμή

135 Ο δείκτης γι αυτήν την μεταβλητή ορίζεται με τον ίδιο τύπο και με τον τελεστή έμμεσης διευθυνσιοδότησης (*) πριν το όνομά του δηλ: int *ptr; Για να του δώσουμε την διεύθυνση της μεταβλητής χρησιμοποιούμε τον τελεστή διεύθυνσης & δηλ: ptr=&a; Τώρα ο δείκτης ptr δείχνει στην διεύθυνση της μεταβλητής a. Εάν τώρα γράψουμε *ptr ο δείκτης παίρνει το (αναφέρεται στο) περιεχόμενο της a δηλ. το 20. Σχηματική παράσταση δήλωσης δεικτών 135

136 Κώδικας του παραδείγματος include <iostream.h> void main() int a; // δήλωση μεταβλητής a int *ptr; // δήλωση δείκτη ptr a=20; // η τιμή της a=20 &a; // η διεύθυνση της a=0xfff4 ptr=&a; // η διεύθυνση του ptr=0xfff4 *ptr; // η τιμή του ptr=20 Εκφράσεις και πράξεις με δείκτες Οι δείκτες μπορούν να χρησιμοποιηθούν σε αριθμητικές πράξεις μέσα σε εκφράσεις αλλά και σε συγκρίσεις. Οι τιμές που χρησιμοποιούν δεν είναι δικές τους αλλά ανήκουν στις μεταβλητές στις οποίες αναφέρονται (που δείχνουν). Παρακάτω φαίνεται ένα παράδειγμα πράξεων μεταβλητών αλλά και δεικτών. int a, b, c, d *ptr1, *ptr2; a=5; b=10; //έκφραση με πράξεις μεταξύ μεταβλητών c=a*b+a/(b-a); // η c έχει τιμή 11 ptr1=&a; // η διεύθυνση της a πάει στον ptr1 ptr2=&b; // η διεύθυνση της b πάει στον ptr2 //έκφραση με πράξεις μεταξύ δεικτών d=(*ptr1)*(*ptr2)+(*ptr1)/((*ptr2)-(*ptr1)); // η d έχει τιμή

137 Κανόνες χρήσης δεικτών Κατά την χρήση των δεικτών είμαστε υποχρεωμένοι να ακολουθούμε συγκεκριμένους κανόνες οι οποίοι φαίνονται παρακάτω. Κανόνας 1 ος Στους δείκτες εφαρμόζουμε τους αριθμητικούς τελεστές αύξησης κατά ένα ++, μείωσης κατά ένα --, πρόσθεσης ακεραίου + ή +=, αφαίρεσης ακεραίου η - =. Κανόνας 2 ος Εκχώρηση ενός δείκτη σε έναν άλλο γίνεται μόνο εάν είναι και οι δύο του ίδιου τύπου. Σε αντίθετη περίπτωση γίνεται πρώτα μετατροπή τύπου. Κανόνας 3 ος Εξαιρείται ο δείκτης void * ο οποίος δέχεται δείκτη οποιουδήποτε τύπου, αλλά με την σειρά του εκχωρείται σε δείκτη άλλου τύπου μετά από μετατροπή. Κανόνας 4 ος Μπορούμε να συγκρίνουμε δείκτες με τελεστές ισότητας ή συγκριτικούς τελεστές μόνο εάν οι δείκτες δείχνουν σε μεταβλητές ίδιου τύπου. Κανόνας 5 ος Χρησιμοποιούμε αριθμητικές πράξεις δεικτών που βρίσκονται μέσα σε πίνακες αλλά και σε δείκτες που δείχνουν αντικείμενα. 137

138 Χρήση του δείκτη σε πολλές μεταβλητές Μπορεί ένας δείκτης να πάρει τις τιμές πολλών μεταβλητών, μία κάθε φορά. Αυτό γίνεται εάν αλλάζουμε την διεύθυνση στην οποία δείχνει ο δείκτης. Δηλ.: int a=3, b=2; int *ptr; ptr=&a; //o ptr δείχνει στην a *ptr; //παίρνει την τιμή της a (τιμή 3) ptr=&b; // o ptr τώρα δείχνει στην b *ptr; //τώρα παίρνει την τιμή της b (τιμή 2) Ο δείκτης αλλάζει την τιμή της μεταβλητής Ένας δείκτης μπορεί να αλλάξει την τιμή της μεταβλητής στην οποία αναφέρεται αν στο *prt δώσουμε νέα τιμή. Δηλ.: int a, *ptr; a=10; //η a έχει τιμή 10 ptr=&a; // αναφορά του ptr στην a *ptr // το *ptr έχει την τιμή της a. *ptr=12; /* αλλάζει η τιμή του ptr αλλά και της μεταβλητής a που δείχνει. */ 138

139 Δείκτες και πίνακες Έστω ο πιο κάτω πίνακας ακεραίων ar[5] ο οποίος δηλώνεται και αρχικοποιείται με την δήλωση: int ar[5]=22,3,102,10,12; και ο οποίος φαίνεται πιο κάτω: ar[0] ar[1] ar[2] ar[3] ar[4] Διευθύνσεις μνήμης περιεχόμενα Στοιχεία του πίνακα Αν γράψουμε ptr=&ar[0]; o δείκτης prt παίρνει την διεύθυνση του πρώτου στοιχείου του πίνακα ar[]. και αν γράψουμε: *ptr; Τότε ο δείκτης prt έχει το περιεχόμενο 22, δηλ. την τιμή του στοιχείου ar[0]. Εάν θέλουμε να δείξουμε στον επόμενο στοιχείο του πίνακα απλά γράφουμε: ptr++; Εάν θέλουμε να δείξουμε στο τρίτο στοιχείο του πίνακα γράφουμε ptr+=2; Βλέπουμε ότι ένας δείκτης μπορεί να λειτουργεί και σαν μετρητής. 139

140 Για την διεύθυνση του prt γράφουμε: [όπου i=0,1,2,3,4] ptr=&ar[0]+i Ο ptr θα πάρει διαδοχικά τις τιμές: 1000, 1002, 1004, 1006, 1008 που είναι και οι διευθύνσεις των στοιχείων του πίνακα ar[]. Αυτό θα γίνει με την χρήση ενός βρόχου for. Δείκτες και συμβολοσειρές Γνωρίζουμε ότι οι συμβολοσειρές είναι ουσιαστικά μονοδιάστατοι πίνακες τύπου char. Η συμβολοσειρά λοιπόν POINTER μπορεί να δηλωθεί ως εξής: char ca[15]= My Poiter ; Ας ορίσουμε τώρα και έναν δείκτη τύπου char δηλ.: char *ptrch; Mε την δήλωση: ptrch=&ca[0]; ή ptrch=&ca; o δείκτης δείχνει στον πρώτο χαρακτήρα της συμβολοσειράς δηλαδή στο M. Εάν αυξήσουμε κατάλληλα την τιμή του ptrch αυτός θα μας δείξει τον επόμενο χαρακτήρα ή οποιονδήποτε χαρακτήρα ή μια ομάδα χαρακτήρων από την συμβολοσειρά. 140

141 Δείκτες και συναρτήσεις Δείκτες χρησιμοποιούμε επίσης και σαν παραμέτρους σε συναρτήσεις. Το κάνουμε αυτό γιατί αν σε μια συνάρτηση περάσουν οι τιμές των μεταβλητών σαν παράμετροι, η συνάρτηση φτιάχνει αντίγραφα των μεταβλητών και όταν τελειώσει η συνάρτηση τη δουλειά της τα αντίγραφα αυτά σταματούν να υπάρχουν (καταστρέφονται). Αυτό έχει ως αποτέλεσμα αν υπάρχουν οποιεσδήποτε αλλαγές στις τιμές των παραμέτρων που ενδεχομένως να ήταν επιθυμητές μετά το τέλος της συνάρτησης καθίσταται άκυρες. Με την χρήση δεικτών πετυχαίνουμε να αλλάζουμε τις τιμές των μεταβλητών στην διεύθυνση της μεταβλητής. Υπάρχουν δύο τρόποι κλήσης συναρτήσεων σε σχέση με την απόδοση τιμής στι παραμέτρους μιας συνάρτησης. Είναι η κλήση με τιμή και η κλήση με αναφορά σε δείκτη. ΚΛΗΣΗ ΜΕ ΤΙΜΗ Μάθαμε ότι όταν χρησιμοποιούμε συναρτήσεις για υπολογισμούς, μέσα στις παρενθέσεις της συνάρτησης βάζουμε παραμέτρους ή αλλιώς τοπικές μεταβλητές, που σκοπό έχουν να πάρουν αντίγραφα των τιμών των αρχικών μεταβλητών του προγράμματος και να εκτελέσουν τους υπολογισμούς. Αυτή η διαδικασία ονομάζεται κλήση με τιμή. Οι τιμές των αρχικών μεταβλητών δεν επηρεάζονται από την συνάρτηση. ΚΛΗΣΗ ΜΕΣΩ ΑΝΑΦΟΡΑΣ ΜΕ ΔΕΙΚΤΗ Με την χρήση δεικτών στην θέση των παραμέτρων μίας συνάρτησης, μπορούμε να δούμε εκτός από τις τιμές και την διεύθυνση των μεταβλητών, καθώς οι δείκτες δείχνουν απευθείας στο περιεχόμενο της αρχικής μεταβλητής. Ως ετούτου μπορούμε να αλλάξουμε τις τιμές στις αρχικές μεταβλητές ή να επιστρέφουμε με το return παραπάνω από μία τιμές. Αυτή η διαδικασία ονομάζεται κλήση μέσω αναφοράς με δείκτη. 141

142 Διαχείριση μνήμης Όταν θέλουμε να αποθηκεύσουμε πολλά στοιχεία, χρησιμοποιούμε πίνακες που είμαστε υποχρεωμένοι να γνωρίζουμε το μέγεθός τους (πόση μνήμη θα δεσμεύσουμε) και να το καθορίσουμε πριν από την εκτέλεση του προγράμματος. Όταν δεν γνωρίζουμε εκ των προτέρων πόση μνήμη θα χρειαστούμε, χρησιμοποιούμε τους τελεστές new και delete για να δεσμεύσουμε και να αποδεσμεύσουμε τμήματα μνήμης κατά την εκτέλεση του προγράμματος. Αυτό σημαίνει ότι παρόλο που έχουμε δηλώσει στο πρόγραμμα τους τελεστές αυτούς, η μνήμη θα δεσμευθεί όταν το πρόγραμμα εκτελεστεί και όχι από την αρχή όπως συμβαίνει με τους πίνακες. Οι τελεστές new-delete Ο τελεστής new επιστρέφει έναν δείκτη για τον κατάλληλο τύπο δεδομένων δεσμεύοντας ταυτόχρονη την μνήμη που θα χρειαστεί. Ο τελεστής delete αποδεσμεύει τον χώρο στην μνήμη που έχει δεσμεύσει ο new επιστρέφοντας την μνήμη στο σύστημα. Ο τρόπος με τον οποίο λειτουργούν αυτοί οι τελεστές λέγεται δυναμική ανάθεση μνήμης. Παράδειγμα Ας υποθέσουμε ότι έχουμε τις πιο κάτω γραμμές κώδικα. int size; float *array; //dhlwsh deikth cin>>size; //mege8os pinaka //o deikths deixnei ston pinaka array=new float[size]; Σε αυτό το παράδειγμα δηλώνουμε έναν δείκτη *array ως τύπο float και μετά βάζουμε τον δείκτη να δείχνει στον πίνακα τύπου float με πλήθος στοιχείων size. 142

143 Εάν οι εντολές αυτές δεν εκτελούνται εξ αρχής διότι μπορεί να βρίσκονται μέσα σε μία if που να τους επιτρέπει να εκτελεστούν με την επαλήθευση κάποιας συνθήκης, τότε δεν δεσμεύεται μνήμη για τον πίνακα. Ο τελεστής delete για την αποδέσμευση της μνήμης μπαίνει στο τέλος της χρήσης του πίνακα, με τις γωνιακές αγκύλες να τοποθετούνται μετά από το delete (ή αλλιώς πριν τον πίνακα). Η δήλωση είναι η εξής: Delete [] array; Δείκτες και αντικείμενα Οι δείκτες μπορούν να δείχνουν και σε αντικείμενα. Αν δεν γνωρίζουμε εξ αρχής πόσα αντικείμενα θα δημιουργήσουμε, με την χρήση του τελεστή new επιστρέφουμε έναν δείκτη σε ένα ανώνυμο αντικείμενο. Π.χ. cat *c; //dhlwsh deikth thw klashs cat // o deikths deixnei se ena anwnymo antikeimeno ths klashs cat c=new cat; Κατά την εκτέλεση του προγράμματος μπορούμε να δημιουργήσουμε όσα αντικείμενα θέλουμε. Για να καλέσει το αντικείμενο μέσω του δείκτη τις συναρτήσεις μέλη, δεν χρησιμοποιοεί τον τελεστή κλήσης τελεία (.) αλλά τον τελεστή προσπέλασης μέλους (->). 143

144 Δηλαδή: c->readdata(); Και όχι: c.readdata(); Πίνακας δεικτών Μπορούμε όταν έχουμε να δημιουργήσουμε πολλά αντικείμενα σε ένα πρόγραμμα, αντί να βάλουμε τα ίδια τα αντικείμενα σε έναν πίνακα (πίνακας αντικειμένων), να φτιάξουμε έναν πίνακα δεικτών που να δείχνουν τα αντικείμενα. Π.χ. //pinakas deiktwn cat *c_arr[10]; //o pinakas deixnei sthn klash cat c_arr[i]= new cat; //klhsh synarthshs apo ta antikeimena ths klashs c_arr[i]->printdata(); 144

145 ΠΑΡΑΔΕΙΓΜΑΤΑ ΜΕ ΔΕΙΚΤΕΣ Παράδειγμα 1 #include <iostream.h> void main() int a,b; // δήλωση μεταβλητών a και b int *p; // δήλωση δείκτη p a=20; // η τιμή της a=20 &a; // η διεύθυνση της a= 0x0012FF7C p=&a; // η διεύθυνση του p= 0x0012FF7C (1) *p; // η τιμή του a=20 περνά στον p (2) b=*p; // η τιμή του p=20 περνά στη b (3) cout<<"h a einai:"<<a<<" kai h b einai:"<<b<<endl; Σχηματική παράσταση p (1) a (2) 12FF7C 20 12FF7C 20 b (3) στον δείκτη p εκχωρείται ως τιμή η διεύθυνση της a (o p δείχνει στην a), στην b εκχωρείται ως τιμή το περιεχόμενο της μεταβλητής a της οποίας την διεύθυνση έχει ως τιμή ο p (*p δηλ το περιεχόμενο της a). 145

146 Παράδειγμα 2 #include <iostream.h> void main() int a=2, b=5; int *p, *q; p=&a; // η διεύθυνση του a στον p (1) q=&b; // η διεύθυνση του b στον q (1) p=q; //όπου δείχνει ο q να δείχνει και ο p (2) *p=*q; //το περιεχόμενο της b που δείχνει o q //εκχωρείται ως περιεχόμενο στην a που δείχνει ο p.(3) Σχηματική παράσταση O p δείχνει στην O q δείχνει στην Όπου δείχνει ο q να δείχνει και ο p Το περιεχόμενο της b περνάει σαν τιμή στην a 146

147 Δείκτες και συναρτήσεις Παραδειγμα 1 (ΚΛΗΣΗ ΜΕ ΤΙΜΗ) Σε αυτό το πρόγραμμα η συνάρτηση athr μεταβιβάζει αντίγραφα των τιμών των μεταβλητών a και b στις τοπικές μεταβλητές x και y για να υπολογίσει το άθροισμα. Οι μεταβλητές a και b δεν επηρεάζονται από την συνάρτηση. int athr(int x, int y) ; main() int a, b, sum; sum=athr(a, b); int athr(int x, int y) return x+y ; Οι τιμές των a και b δεν επηρεάζονται ΚΛΗΣΗ ΜΕ ΑΝΑΦΟΡΑ Σε αυτό το πρόγραμμα η δήλωση int &i σημαίνει ότι η παράμετρος i αναφέρεται στην μεταβλητή sum και αντιστοίχως η δήλωση int &j σημαίνει ότι η παράμετρος j στην μεταβλητή diff. Ουσιαστικά το i είναι ψευδώνυμο του sum και το j ψευδώνυμο του diff. Οποιαδήποτε αλλαγή υπάρξει στα ψευδώνυμα, αυτομάτως γίνεται και στις μεταβλητές void sumdiff(int &i, int &j, int x, int y); main() int a, b, sum, diff;. sumdiff(sum, diff, a, b);.. void sumdiff(int &i, int &j, int x, int y) i=x+y; j=x-y; Η i ψευδώνυμο της sum και η j ψευδώνυμο της diff 147

148 ΚΛΗΣΗ ΜΕ ΔΕΙΚΤΕΣ Σε αυτό το πρόγραμμα κατά την κλήση της συνάρτησης μεταβιβάζονται οι διευθύνσεις των μεταβλητών sum και diff στους δείκτες *i και *j. Όταν γράψουμε λοιπόν *i=x+y; και *j=x-y; έχουμε πρόσβαση με τους δείκτες *i και *j στο περιεχόμενο των μεταβλητών αυτών. void sumdiff(int *i, int *j, int x, int y); main() int a, b, sum, diff; sumdiff(&sum, &diff, a, b); void sumdiff is(int *i, int *j, int x, int y) *i=x+y; *j=x-y; Ο δείκτης i αλλάζει την τιμή της sum (ο δείκτης i δείχνει στη διεύθυνση της sum) και ο j της diff Παραδειγμα 2 ΚΛΗΣΗ ΜΕ ΤΙΜΗ Σε αυτό το πρόγραμμα μεταβιβάζεται η τιμή της μεταβλητής num στη συνάρτηση doublebyvalue(). Αυτή διπλασιάζει την τιμή και την επιστρέφει στην main() όπου και αποδίδεται στην new_num. Η τιμή της num δεν έχει αλλάξει. #include <iostream.h> int doublebyvalue(int); //dhlosh prototypou int main() int num=10, new_num; cout<<"h arxikh timh einai: "<<num; new_num=doublebyvalue(num);// perasma ths num mesw timhs cout<<endl; // h num den allazei thn timh ths cout<<"h timh ths num einai: "<<num<<endl; // h nea timh paei sthn new_num cout<<"h nea timh einai: "<<new_num<<endl; return 0; // end of main // ypologismos toy diplasioy toy orismatos num 148

149 int doublebyvalue(int x) return 2*x; //diplasiasmos kai epistrofh ths x //end of doublebyvalue ΚΛΗΣΗ ΜΕ ΔΕΙΚΤΕΣ Σε αυτό το πρόγραμμα κατά την κλήση της συνάρτησης doublebyreferwithpointer() μεταβιβάζεται η διεύθυνση της num στον δείκτη *xptr. Έτσι ο δείκτης *xptr μέσα στη συνάρτηση αποκτά πρόσβαση στο περιεχόμενο της μεταβλητής num και την αλλάζει. Μέσα στη main() η μεταβλητή num θα έχει τελικά την νέα τιμή (το διπλάσιο). #include <iostream.h> void doublebyreferwithpointer(int *xptr); //dhlosh prototypou int main() int num=10; cout<<"h arxikh timh einai: "<<num; //perasma ths dieythinshs ths num sth // synarthsh doublebyreferwithpointer() doublebyreferwithpointer(&num); cout<<endl; cout<<"h nea timh einai: "<<num<<endl; return 0; // end of main // ypologismos toy diplasioy toy *xptr // allagh ths timhs ths num sth main void doublebyreferwithpointer(int *xptr) *xptr=2*(*xptr); //diplasiasmos tou *xptr //end of doublebyreferwithpointer 149

150 Δείκτες και πίνακες Στο παρακάτω πρόγραμμα γίνονται: 1) Εκτύπωση των τιμών των στοιχείων του πίνακα με άμεση αναφορά στα στοιχεία, 2) Εκτύπωση των τιμών των στοιχείων του πίνακα με έμμεση αναφορά στα στοιχεία δηλαδή μέσω δεικτών, 3) Εκτύπωση του αθροίσματος των τιμών των στοιχείων του μέσω δεικτών και 4) Εκτύπωση του γινομένου του 2ου με το 4ο στοιχείο του πίνακα. #include <iostream.h> void main() int array[]=10,20,3,98,23; int sum,i,n,*parr; n=4; cout<<"\n\t\t O PINAKAS ARRAY"; cout<<"\n\n STOIXEIA TOY PINAKA ADDRESSES"; cout<<" TIMES TOY PINAKA\n"; for(i=0;i<=n;i++) cout<<"\t array"<<i<<"]"<<"\t\t"<<&array[i]<<"\t\t"<<array[i]<<endl; parr=&array[0]; //o deikths deixnei to prwto stoixeio // ypologismos toy athroismatos // twn stoixeiwn toy me deiktes sum=0; cout<<"\n\n\t O PINAKAW ARRAY ME DEIKTES"; cout<<"\n\n STOIXEIA TOY PINAKA ADDRESSES"; cout<<" TIMES TOY PINAKA\n"; for(i=0;i<=n;i++) sum=sum+*parr; //ypologismos toy athroismatos cout<<"\tarray["<<i<<"]"<<"\t\t"<<parr; cout<<"\t\t"<<*parr++; //deikths san metrhths cout<<endl; cout<<"\nto ATHROISMA TWN STOIXEIWN TOU PINAKA="<<sum<<endl; parr=&array[0]; //o deikths deixnei pali to prwto stoixeio cout<<"\nto GINOMENO TOY 2ou X 4o STOIXEIOY="; cout<<(*(parr+1))*(*(parr+3)); //ginomeno deiktwn cout<<endl<<endl; 150

151 Δείκτες και συμβολοσειρές Στο παρακάτω πρόγραμμα ορίζουμε την συμβολοσειρά VISUAL C++, τυπώνουμε έναν έναν τους χαρακτήρες της, μετά τυπώνουμε τους χαρακτήρες με ανάποδη σειρά και τέλος παίρνουμε τους τρεις τελευταίους χαρακτήρες και τους μεταφέρουμε σε μία άλλη συμβολοσειρά με όνομα CPP. #include <stdio.h> #include <iostream.h> void main() int i,n; char array[]="visual C++"; char cpp[2]; char *ts,*ts1; n=9; ts=&array[0]; //o ts deixnei sto 1o stoixeio cout<<"\n\n EKTYPOSH THS SYMBOLOSEIRAS \n"; cout<<" ================================\n"; cout<<"h SYMBOLOSEIRA ADDRESS DEC ADDRESS HEX"; for(i=0; i<=n; i++) printf("\n array[%d]= %c \t %u \t%x",i,*ts,ts,ts); ts++; ts=&array[0]+n; //o ts deixnei sto prwto+9 stoixeio ara sto 10o cout<<"\n\n EKTYPOSH THS SYMBOLOSEIRAS "; cout<<"apo TO TELOS \n"; cout<<" =================================\n"; cout <<"H SYMBOLOSEIRA ADDRESS DEC ADDRESS HEX"; for(i=n; i>=0; i--) printf("\n array[%d]= %c \t %u \t%x",i,*ts,ts,ts); ts--; ts=&array[7]; //o ts deixnei sto 8o ts1=&cpp[0]; //o ts1 deixnei sto 1o for(i=0; i<=2; i++) *ts1=*ts; //h timh toy 8ou perna sto 1o, tou 9ou sto 2o, kok ts++; ts1++; cout<<"\n\n H SYMBOLOSEIRA CPP[] = \n"; for(i=0; i<=2; i++) //ektypwsh xarakthrwn tou CPP[] printf("%c",cpp[i], i); cout<<endl; 151

152 Δυναμική ανάθεση μνήμης (new - delete) #include <iostream.h> #include <iomanip.h> void main() int ar_size, i, j; float *array; float b=1.25; i=0;j=0; for(j=0;j<2;j++) cout<<"dose plhthos stoixeiwn tou pinaka:"; cin>>ar_size; array=new float[ar_size]; for(i=0;i<ar_size;i++) array[i]=float((i*10.+b)/3.2); for(i=0;i<ar_size;i++) cout<<"\n"<<setw(4)<<i+1<<"o Stoixeio toy pinaka: "<<array[i]; cout<<endl; cout<<endl<<endl; delete [] array; Σύντομη εξήγηση του προγράμματος Στο πιο πάνω πρόγραμμα χρησιμοποιούμε τον τελεστή new πριν από το δεύτερο for. Η δημιουργία του πίνακα θα γίνει 2 φορές (αυτό καθορίζεται από το πρώτο for) και κάθε φορά θα δεσμεύεται μνήμη για τον πίνακα με το new και θα αποδεσμεύεται από το delete το οποίο μπαίνει στο τέλος της χρήσης του πίνακα. Σημ. στο πρόγραμμα αυτό η τιμή του κάθε στοιχείου του πίνακα βγαίνει από τη έκφραση (i*10.+b)/3.2 όπου κάνουμε casting για αλλαγή του τύπου του αποτελέσματος σε float, λόγω του ότι οι μεταβλητές i και b έχουν οριστεί στη αρχή ως int. Δυναμική ανάθεση Το κάθε στοιχείο παίρνει τιμή που βγαίνει από την έκφραση float((i*10.+b)/3.2) Αποδέσμευση μνήμης 152

153 Δείκτες σε αντικείμενα #include <iostream.h> class Atomo private: int id; char name[20]; public: void readdata() cout<<"give code:"; cin>>id; cout<<"give name:"; cin>>name; void printdata() cout<<"the code is: "<<id<<endl; cout<<"the name is: "<<name<<endl; ; void main() Atomo *a; //deikths a ths klashs Atomo a=new Atomo; //desmeysh mnhmhs gia ena antikeimeno toy //typoy atomo sto opoio deixnei o deikths a a->readdata(); //klhsh synarthsewn apo ton deikth a->printdata(); Σύντομη εξήγηση του προγράμματος Σε αυτό το πρόγραμμα δηλώνουμε έναν δείκτη *a του τύπου (κλάσης) Atomo και κατόπιν δεσμεύουμε μνήμη για ένα αντικείμενο (new) του τύπου Atomo στο οποίο δείχνει ο δείκτης a. Στην συνέχεια ο δείκτης a ουσιαστικά καλεί τις συναρτήσεις μέλη της κλάσης Atomo. 153

154 Πίνακας δεικτών #include <iostream.h> class Atomo private: int id; char name[20]; public: void readdata() cout<<"give code:"; cin>>id; cout<<"give name:"; cin>>name; void printdata() cout<<"the code is: "<<id<<endl; cout<<"the name is: "<<name<<endl; ; void main() Atomo *at_arr[100]; //pinakas deiktwn typou Atomo int i=0, j; char choice; do at_arr[i]=new Atomo; //neo antikeimeno at_arr[i]->readdata();//klhsh synarthshs i++; cout<<"more? Y to continue OR N to stop insert: "; cin>>choice; while (choice=='y'); for (j=0; j<i; j++) at_arr[j]->printdata(); Σύντομη εξήγηση του προγράμματος Σε αυτό το πρόγραμμα τα αντικείμενα δημιουργούνται μέσα στο βρόχο do while και καλούν την συνάρτηση readdata(), για να γίνει εισαγωγή των στοιχείων κάθε αντικειμένου, μέχρι να πατηθεί το Ν όπου ο βρόχος do while σταματά και αρχίζει ο βρόχος for για να εκτυπώσει να στοιχεία των αντικειμένων που έχουν εισαχθεί. Όσο πατάμε Υ τόσο ο πίνακας αντικειμένων at_arr του τύπου (κλάσης) Atomo θα παράγει αντικείμενα στα οποία θα δίνουμε τιμές. 154 Εκτύπωση στοιχείων των i αντικειμένων (i = εκεί που σταμάτησε ο μετρητής i++)

155 ΑΡΧΕΙΑ Τι είναι αρχείο Οι πληροφορίες που καλείται να διαχειριστεί ο Η/Υ είναι τόσες πολλές, που η μνήμη του δεν φτάνει να τις επεξεργαστεί όλες μαζί. Γι αυτό τον λόγο τις αποθηκεύουμε σε μονάδες αποθήκευσης (π.χ hdd, cd, dvd) με την μορφή αρχείων. Τα αρχεία είναι ένα σύνολο τιμών του ίδιου τύπου με συγκεκριμένο μήκος. Μήκος του αρχείου είναι ο αριθμός των στοιχείων του. Σημ. Το κενό αρχείο έχει μήκος 0 (μηδέν). Παραδείγματα: 1. το (5, -3, 34, -23, 7) είναι ένα αρχείο ακεραίων τιμών τύπου int μήκους 5 και 2. το ( s, /, a, o, *, _ ) είναι ένα αρχείο αλφαριθμητικών τιμών τύπου char μήκους 8. Μορφοποίηση Τα αρχεία που περιέχουν χαρακτήρες, όπως το παράδειγμα 2, ονομάζονται αρχεία κειμένου ή μορφοποιημένα αρχεία και μπορούν να διαβαστούν εύκολα από έναν κειμενογράφο. Τα αρχεία που περιέχουν αριθμητικές τιμές, όπως το παράδειγμα 1 που μπορεί να έχουν προκύψει από επεξεργασία τιμών και εκφράσεων από τον υπολογιστή, ονομάζονται δυαδικά αρχεία ή μη μορφοποιημένα αρχεία. Τα αρχεία αυτά διαβάζονται από ειδικά προγράμματα. 155

156 Δημιουργία αρχείων Για να δημιουργήσουμε ένα αρχείο στον υπολογιστή, πρέπει πρώτα να φτιάξουμε ένα ρεύμα (stream) από το αρχείο προς το πρόγραμμα και από το πρόγραμμα προς το αρχείο, κατόπιν να βρούμε την αρχή του αρχείου και τέλος να ανοίξουμε (open) το ρεύμα του αρχείου. STREAM Για το σκοπό αυτό χρησιμοποιούμε την κλάση fstream (file stream) του αρχείου κεφαλίδας fstream.h η οποία ανοίγει ρεύματα διπλής κατεύθυνσης και κληρονομεί χαρακτηριστικά από την κλάση iostream καθώς και από την υπερκλάση ios. Στην αρχή του κώδικα θα πρέπει να συμπεριλάβουμε το αρχείο κεφαλίδας fstream.h με την δήλωση: #include <fstream.h> Στο αρχείο κεφαλίδας fstream.h υπάρχουν επίσης και οι κλάσεις: ifstream (input file stream) για ρεύματα από το αρχείο προς το πρόγραμμα και ofstream (output file stream) για ρεύματα από το πρόγραμμα προς το αρχείο. 156

157 IFSTREAM OFSTREAM Εγγραφή σε αρχείο Για να γράψω πληροφορία σε ένα αρχείο χρησιμοποιώ τη δήλωση: ofstream συμβολικό_όνομα( όνομα_αρχείου.txt ); δηλαδή μπορώ να γράψω για παράδειγμα: ofstream my_input_file( test.txt ); κατόπιν ακολουθούν αυτά που θα γράψω στο αρχείο (π.χ μεταβλητές, συμβολοσειρές) χρησιμοποιώντας το συμβολικό όνομα και τον τελεστή εξαγωγής ροής << δηλαδή γράφω: my_input_file<<x; για να στείλω την τιμή της x στο αρχείο test.txt και my_input_file<<char_array; για να στείλω συμβολοσειρά που βρίσκεται στην char_array στο αρχείο test.txt. 157