Αντικειμενοστρεφής προγραμματισμός με τη C++

Transcript

1 Περιεχόμενα Εισαγωγή 25 1 Η γενική εικόνα 33 Γιατί χρειαζόμαστε τον αντικειμενοστρεφή προγραμματισμό;...34 Διαδικασιακές γλώσσες...34 Η αντικειμενοστρεφής προσέγγιση...37 Χαρακτηριστικά των αντικειμενοστρεφών γλωσσών...40 Αντικείμενα...40 Κλάσεις...42 Κληρονομικότητα...42 Ανακύκλωση...45 Δημιουργία νέων τύπων δεδομένων...45 Πολυμορφισμός και υπερφόρτωση...45 C++ και C...46 Βάλτε τις βάσεις...47 Η Ενοποιημένη Γλώσσα Μοντελοποίησης...47 Σύνοψη...49 Ερωτήσεις Βασικές αρχές προγραμματισμού σε C++ 53 Ξεκίνημα...54 Κατασκευή βασικού προγράμματος...54 Συναρτήσεις...55 Εντολές προγράμματος...56 Λευκά διαστήματα...57 Έξοδος με το cout...57 Αλφαριθμητικές σταθερές...58 Οδηγίες...59 Οδηγίες προεπεξεργαστή...59 Αρχεία-κεφαλίδες...59 Η οδηγία using...60 Σχόλια...60 Σύνταξη σχολίων...60 Πότε να χρησιμοποιείτε σχόλια...61 Εναλλακτική σύνταξη σχολίων...61 Ακέραιες μεταβλητές...62 Ορισμός ακέραιων μεταβλητών...62 Δηλώσεις και ορισμοί...64 Ονόματα μεταβλητών...64 Εντολές απόδοσης τιμής...64 Ακέραιες σταθερές...65 Παραλλαγές εξόδου...65 Ο χειριστής endl...65 Άλλοι ακέραιοι τύποι...66

2 Περιεχόμενα 5 Μεταβλητές χαρακτήρων...66 Σταθερές χαρακτήρων...67 Απόδοση αρχικών τιμών (initialization)...68 Ακολουθίες διαφυγής...68 Είσοδος με το cin...69 Μεταβλητές που ορίζονται στο σημείο χρήσης τους...71 Στοίβαξη τελεστών <<...71 Παραστάσεις...71 Προτεραιότητα...71 Τύποι κινητής υποδιαστολής...72 Ο τύπος bool...75 Ο χειριστής setw...76 Σύνοψη για τους τύπους μεταβλητών...78 Τύποι δεδομένων unsigned...79 Μετατροπή τύπου...80 Αυτόματες μετατροπές...81 Ρητές μετατροπές...82 Αριθμητικοί τελεστές...84 Ο τελεστής υπολοίπου...85 Αριθμητικοί τελεστές απόδοσης τιμής...85 Τελεστές προσαύξησης...87 Συναρτήσεις βιβλιοθήκης...89 Αρχεία-κεφαλίδες...90 Αρχεία βιβλιοθήκης...90 Αρχεία-κεφαλίδες και αρχεία βιβλιοθήκης...91 Δύο τρόποι χρήσης της οδηγίας #include...91 Σύνοψη...92 Ερωτήσεις...93 Ασκήσεις Βρόχοι και αποφάσεις 99 Σχεσιακοί τελεστές Βρόχοι Ο βρόχος for Βήματα κατά την αποσφαλμάτωση Παραλλαγές του βρόχου for Ο βρόχος while Προτεραιότητα: Αριθμητικοί και σχεσιακοί τελεστές Ο βρόχος do Πότε να χρησιμοποιείτε τον κάθε βρόχο Αποφάσεις Η εντολή if Η εντολή if...else Η κατασκευή else...if Η εντολή switch Η εντολή break Ο τελεστής συνθήκης...135

3 6 Αντικειμενοστρεφής προγραμματισμός με τη C++ Λογικοί τελεστές Ο λογικός τελεστής AND Ο λογικός τελεστής OR Ο λογικός τελεστής NOT Σύνοψη σχετικά με την προτεραιότητα Άλλες εντολές ελέγχου Η εντολή break Η εντολή continue Η εντολή goto Σύνοψη Ερωτήσεις Ασκήσεις Δομές 155 Δομές Μία απλή δομή Ορισμός της δομής Ορισμός μεταβλητής δομής Προσπέλαση των μελών μιας δομής Άλλα χαρακτηριστικά των δομών Απόδοση αρχικής τιμής σε μέλη δομής Ένα παράδειγμα μέτρησης Δομές μέσα σε δομές Παράδειγμα με ένα παιχνίδι τράπουλας Δομές και κλάσεις Απαριθμήσεις Ημέρες της εβδομάδας Ή το ένα ή το άλλο Οργάνωση των χαρτιών Καθορισμός ακέραιων τιμών Ο τύπος enum δεν είναι τέλειος Άλλα παραδείγματα Σύνοψη Ερωτήσεις Ασκήσεις Συναρτήσεις 185 Απλές συναρτήσεις Δήλωση της συνάρτησης Η κλήση της συνάρτησης Ο ορισμός της συνάρτησης Σύγκριση με τις συναρτήσεις βιβλιοθήκης Απαλοιφή της δήλωσης Μεταβίβαση ορισμάτων σε συναρτήσεις Μεταβίβαση σταθερών Μεταβίβαση μεταβλητών Μεταβίβαση κατ αξία...194

4 Περιεχόμενα 7 Οι δομές ως ορίσματα Ονόματα στη δήλωση Επιστροφή τιμών από συναρτήσεις Η εντολή return Επιστροφή μεταβλητών δομής Ορίσματα αναφοράς Μεταβίβαση απλών τύπων δεδομένων κατ' αναφορά Μια πιο πολύπλοκη μεταβίβαση κατ' αναφορά Μεταβίβαση δομών κατ' αναφορά Σημειώσεις για τη μεταβίβαση κατ' αναφορά Υπερφόρτωση συναρτήσεων Διαφορετικό πλήθος ορισμάτων Διαφορετικά είδη ορισμάτων Αναδρομή Εμβόλιμες συναρτήσεις Προεπιλεγμένα ορίσματα Εμβέλεια και κλάση αποθήκευσης Τοπικές μεταβλητές Κλάση αποθήκευσης Καθολικές μεταβλητές Στατικές τοπικές μεταβλητές Αποθήκευση Επιστροφή κατ' αναφορά Κλήσεις συναρτήσεων στην αριστερή πλευρά του συμβόλου ίσον Μην ανησυχείτε ακόμη Ορίσματα const σε συναρτήσεις Σύνοψη Ερωτήσεις Ασκήσεις Αντικείμενα και κλάσεις 239 Μια απλή κλάση Κλάσεις και αντικείμενα Ορισμός της κλάσης Χρήση της κλάσης Κλήση συναρτήσεων-μελών Αντικείμενα της C++ ως φυσικά αντικείμενα Τα ανταλλακτικά συσκευών ως αντικείμενα Κύκλοι ως αντικείμενα Αντικείμενα της C++ ως τύποι δεδομένων Συναρτήσεις δόμησης Παράδειγμα μετρητή Ένα παράδειγμα γραφικών Συναρτήσεις αποδόμησης...256

5 8 Αντικειμενοστρεφής προγραμματισμός με τη C++ Αντικείμενα ως ορίσματα συναρτήσεων Υπερφόρτωση συναρτήσεων δόμησης Συναρτήσεις-μέλη που ορίζονται έξω από την κλάση Αντικείμενα ως ορίσματα Η προεπιλεγμένη συνάρτηση δόμησης αντιγράφου Επιστροφή αντικειμένων από συναρτήσεις Ορίσματα και αντικείμενα Παράδειγμα με παιχνίδι της τράπουλας Δομές και κλάσεις Κλάσεις, αντικείμενα, και μνήμη Στατικά δεδομένα κλάσης Χρήσεις των στατικών μελών δεδομένων κλάσης Ένα παράδειγμα στατικών δεδομένων κλάσης Ξεχωριστή δήλωση και ορισμός const και κλάσεις Συναρτήσεις-μέλη const Αντικείμενα const Τι σημαίνουν όλα αυτά; Σύνοψη Ερωτήσεις Ασκήσεις Πίνακες και αλφαριθμητικά 289 Βασικά στοιχεία για τους πίνακες Ορισμός πινάκων Στοιχεία πίνακα Προσπέλαση στοιχείων πίνακα Μέσος όρος στοιχείων πίνακα Απόδοση αρχικών τιμών σε πίνακες Πολυδιάστατοι πίνακες Μεταβίβαση πινάκων σε συναρτήσεις Πίνακες δομών Πίνακες ως μέλη δεδομένων σε κλάσεις Πίνακες αντικειμένων Πίνακες αποστάσεων στο Αγγλικό σύστημα μέτρησης Πίνακας με τραπουλόχαρτα Αλφαριθμητικά της C Αλφαριθμητικές μεταβλητές τύπου C Αποφυγή υπερχείλισης της προσωρινής αποθήκευσης Αλφαριθμητικές σταθερές Ανάγνωση ενσωματωμένων κενών Ανάγνωση πολλών γραμμών Αντιγραφή αλφαριθμητικού με το δύσκολο τρόπο Αντιγραφή αλφαριθμητικού με τον εύκολο τρόπο Πίνακες αλφαριθμητικών Αλφαριθμητικά ως μέλη κλάσης Τύπος αλφαριθμητικού ορισμένος από το χρήστη...326

6 Περιεχόμενα 9 Η κλάση string της Standard C Ορισμός και ανάθεση αντικειμένων string Είσοδος/Έξοδος με αντικείμενα string Εύρεση αντικειμένων string Τροποποίηση αντικειμένων string Σύγκριση αντικειμένων string Προσπέλαση χαρακτήρων σε αντικείμενα string Άλλες συναρτήσεις της κλάσης string Σύνοψη Ερωτήσεις Ασκήσεις Υπερφόρτωση τελεστών 345 Υπερφόρτωση μονομελών τελεστών Η δεσμευμένη λέξη operator Ορίσματα τελεστών Επιστρεφόμενες τιμές τελεστών Ανώνυμα προσωρινά αντικείμενα Επιθεματική σημειογραφία Υπερφόρτωση διμελών τελεστών Αριθμητικοί τελεστές Συνένωση αλφαριθμητικών Πολλαπλή υπερφόρτωση Τελεστές σύγκρισης Αριθμητικοί τελεστές απόδοσης τιμής Ο τελεστής αριθμοδείκτη([]) Μετατροπή δεδομένων Μετατροπές μεταξύ βασικών τύπων Μετατροπές μεταξύ αντικειμένων και βασικών τύπων Μετατροπές μεταξύ αντικειμένων διαφορετικών κλάσεων Μετατροπές: πότε να χρησιμοποιείτε τι Διαγράμματα κλάσεων UML Συσχετίσεις Πλοηγησιμότητα Παγίδες κατά την υπερφόρτωση τελεστών και τη μετατροπή δεδομένων Χρησιμοποιήστε παρόμοιες έννοιες Χρησιμοποιήστε παρόμοια σύνταξη Δείξτε αυτοσυγκράτηση Αποφύγετε τις αμφισημίες Δεν μπορούν να υπερφορτωθούν όλοι οι τελεστές Οι δεσμευμένες λέξεις explicit και mutable Αλλαγή δεδομένων αντικειμένων const με χρήση της mutable Σύνοψη Ερωτήσεις Ασκήσεις...393

7 10 Αντικειμενοστρεφής προγραμματισμός με τη C++ 9 Κληρονομικότητα 397 Παράγωγη κλάση και βασική κλάση Καθορισμός της παράγωγης κλάσης Η γενίκευση σε διαγράμματα κλάσεων UML Προσπέλαση μελών της βασικής κλάσης Το προσδιοριστικό πρόσβασης protected Συναρτήσεις δόμησης παραγώγων κλάσεων Υποσκέλιση συναρτήσεων-μελών Ποια συνάρτηση χρησιμοποιείται; Επίλυση εμβέλειας σε συναρτήσεις που έχουν υποστεί υποσκέλιση Κληρονομικότητα στην κλάση Αγγλικών μονάδων μέτρησης Distance Λειτουργία του προγράμματος ENGLEN Συναρτήσεις δόμησης στην DistSign Συναρτήσεις-μέλη της DistSign Υποστήριξη της κληρονομικότητας Ιεραρχίες κλάσεων "Αφηρημένη" βασική κλάση Συναρτήσεις δόμησης και συναρτήσεις-μέλη Κληρονομικότητα και σχήματα γραφικών Δημόσια και ιδιωτική κληρονομικότητα Συνδυασμοί πρόσβασης Προσδιοριστικά πρόσβασης: πότε να χρησιμοποιείτε τι Επίπεδα κληρονομικότητας Πολλαπλή κληρονομικότητα Συναρτήσεις-μέλη στην πολλαπλή κληρονομικότητα Ιδιωτικές παράγωγες κλάσεις στο πρόγραμμα EMPMULT Συναρτήσεις δόμησης στην πολλαπλή κληρονομικότητα Αμφισημία στην πολλαπλή κληρονομικότητα Συσσώρευση: κλάσεις στο εσωτερικό κλάσεων Η συσσώρευση στο πρόγραμμα EMPCONT Σύνθεση: μια ισχυρότερη συσσώρευση Κληρονομικότητα και ανάπτυξη προγραμμάτων Σύνοψη Ερωτήσεις Ασκήσεις Δείκτες 455 Διευθύνσεις και δείκτες Ο τελεστής διεύθυνσης & Μεταβλητές δείκτη Προσπέλαση της μεταβλητής στην οποία δείχνει ο δείκτης Δείκτης σε void Δείκτες και πίνακες Σταθερές δείκτη και μεταβλητές δείκτη...468

8 Περιεχόμενα 11 Δείκτες και συναρτήσεις Μεταβίβαση απλών μεταβλητών Μεταβίβαση πινάκων Ταξινόμηση στοιχείων πίνακα Δείκτες και αλφαριθμητικά της C Δείκτες σε αλφαριθμητικές σταθερές Αλφαριθμητικά ως ορίσματα συναρτήσεων Αντιγραφή αλφαριθμητικού με χρήση δεικτών Συναρτήσεις βιβλιοθήκης για αλφαριθμητικά Δείκτες και το τροποποιητικό const Πίνακες δεικτών σε αλφαριθμητικά Διαχείριση μνήμης: new και delete Ο τελεστής new Ο τελεστής delete Κλάση αλφαριθμητικών που χρησιμοποιεί τον τελεστή new Δείκτες σε αντικείμενα Αναφορά σε μέλη Μια άλλη προσέγγιση του τελεστή new Πίνακας δεικτών προς αντικείμενα Ένα παράδειγμα συνδεδεμένης λίστας Αλυσίδα δεικτών Προσθήκη στοιχείου στη λίστα Εμφάνιση των περιεχομένων της λίστας Αυτοτελείς κλάσεις Αναβάθμιση του προγράμματος LINKLIST Δείκτες προς δείκτες Ταξινόμηση δεικτών Ο τύπος δεδομένων person** Σύγκριση αλφαριθμητικών Ένα παράδειγμα συντακτικής ανάλυσης Ανάλυση αριθμητικών παραστάσεων Το πρόγραμμα PARSE Προσομοίωση ιπποδρομίας Σχεδίαση της ιπποδρομίας Η πολλαπλότητα στη UML Διαγράμματα καταστάσεων UML Καταστάσεις Μεταβάσεις Μετάβαση από κατάσταση σε κατάσταση Αποσφαλμάτωση δεικτών Σύνοψη Ερωτήσεις Ασκήσεις...523

9 12 Αντικειμενοστρεφής προγραμματισμός με τη C++ 11 Εικονικές συναρτήσεις 529 Εικονικές συναρτήσεις Προσπέλαση κανονικών συναρτήσεων-μελών με δείκτες Προσπέλαση εικονικών συναρτήσεων-μελών με δείκτες Όψιμη σύνδεση Αφηρημένες κλάσεις και γνήσιες εικονικές συναρτήσεις Εικονικές συναρτήσεις και η κλάση person Εικονικές συναρτήσεις σε ένα παράδειγμα γραφικών Εικονικές συναρτήσεις αποδόμησης Εικονικές βασικές κλάσεις Φίλες συναρτήσεις Οι φίλες συναρτήσεις ως γέφυρες Παραβίαση των τειχών Παράδειγμα με το Αγγλικό σύστημα μονάδων μέτρησης αποστάσεων Ευκολότερη σύνταξη με φίλες συναρτήσεις Φίλες κλάσεις Στατικές συναρτήσεις Προσπέλαση στατικών συναρτήσεων Αρίθμηση των αντικειμένων Εξέταση των συναρτήσεων αποδόμησης Απόδοση αρχικών τιμών με ανάθεση και αντιγραφή Υπερφόρτωση του τελεστή απόδοσης τιμής Η συνάρτηση δόμησης αντιγράφου Διαγράμματα αντικειμένων UML Μια κλάση String με αποδοτική διαχείριση της μνήμης Ο δείκτης this Προσπέλαση μελών δεδομένων με το δείκτη this Χρήση του δείκτη this για επιστροφή τιμών Αναθεωρημένο πρόγραμμα STRIMEM Δυναμικές πληροφορίες τύπων Έλεγχος του τύπου μιας κλάσης με τον τελεστή dynamic_cast Αλλαγή τύπου ενός δείκτη με τον τελεστή dynamic_cast Ο τελεστής typeid Σύνοψη Ερωτήσεις Ασκήσεις Ρεύματα και αρχεία 593 Κλάσεις ρευμάτων Πλεονεκτήματα των ρευμάτων Η ιεραρχία των κλάσεων ρευμάτων Η κλάση ios Η κλάση istream Η κλάση ostream Η κλάση iostream και οι κλάσεις _withassign...602

10 Περιεχόμενα 13 Σφάλματα ρευμάτων Bit κατάστασης σφαλμάτων Είσοδος αριθμών Υπερβολικά πολλοί χαρακτήρες Είσοδος που δεν είναι είσοδος Είσοδος αλφαριθμητικών και χαρακτήρων Αποστάσεις χωρίς σφάλματα Είσοδος/έξοδος σε αρχεία δίσκου με ρεύματα Μορφοποιημένη είσοδος/έξοδος σε αρχεία Εγγραφή δεδομένων Ανάγνωση δεδομένων Αλφαριθμητικά με ενσωματωμένα κενά Είσοδος/έξοδος χαρακτήρων Δυαδική είσοδος/έξοδος Ο τελεστής reinterpret_cast Κλείσιμο αρχείων Είσοδος/έξοδος αντικειμένων Εγγραφή αντικειμένου στο δίσκο Ανάγνωση αντικειμένου από το δίσκο Συμβατές δομές δεδομένων Είσοδος/έξοδος με πολλά αντικείμενα Δείκτες αρχείων Καθορισμός της θέσης Καθορισμός της σχετικής απόστασης Η συνάρτηση tellg() Χειρισμός σφαλμάτων εισόδου/εξόδου σε αρχεία Αντίδραση σε σφάλματα Ανάλυση σφαλμάτων Είσοδος/έξοδος αρχείων με συναρτήσεις-μέλη Αντικείμενα που γράφουν και διαβάζουν τον εαυτό τους Κλάσεις που διαβάζουν και γράφουν τον εαυτό τους Υπερφόρτωση των τελεστών εξαγωγής και εισαγωγής Υπερφόρτωση των cout και cin Υπερφόρτωση για αρχεία Η μνήμη ως αντικείμενο ρεύματος Ορίσματα γραμμής διαταγών Έξοδος στον εκτυπωτή Σύνοψη Ερωτήσεις Ασκήσεις...654

11 14 Αντικειμενοστρεφής προγραμματισμός με τη C++ 13 Προγράμματα με πολλά αρχεία 659 Λόγοι για τη χρήση προγραμμάτων με πολλά αρχεία Βιβλιοθήκες κλάσεων Δημιουργία προγράμματος με πολλά αρχεία Αρχεία-κεφαλίδες Κατάλογος Έργα Επικοινωνία μεταξύ αρχείων Επικοινωνία μεταξύ πηγαίων αρχείων Αρχεία-κεφαλίδες Χώροι ονομάτων Ορισμός χώρου ονομάτων Προσπέλαση μελών χώρου ονομάτων Χώροι ονομάτων σε αρχεία-κεφαλίδες Κλάση πολύ μεγάλων αριθμών Αριθμοί ως αλφαριθμητικά Το προσδιοριστικό της κλάσης Οι συναρτήσεις-μέλη Το πρόγραμμα εφαρμογής Προσομοίωση ανελκυστήρα σε πολυώροφο κτήριο Εκτέλεση του προγράμματος ELEV Αίτηση για μεταφορά σε όροφο Σχεδιασμός του συστήματος Λίστες του προγράμματος ELEV Διάγραμμα καταστάσεων για το πρόγραμμα ELEV Σύνοψη Ερωτήσεις Έργα Πρότυπα και εξαιρέσεις 707 Πρότυπα συναρτήσεων Ένα απλό πρότυπο συναρτήσεων Πρότυπα συναρτήσεων με πολλά ορίσματα Τα ορίσματα προτύπων πρέπει να ταιριάζουν Παραλλαγή σύνταξης Περισσότερα από ένα ορίσματα προτύπου Γιατί όχι μακροεντολές; Τι λειτουργεί; Ξεκινήστε με μια κανονική συνάρτηση Πρότυπα κλάσεων Το όνομα της κλάσης εξαρτάται από τα συμφραζόμενα Μια κλάση συνδεδεμένης λίστας που χρησιμοποιεί πρότυπα Αποθήκευση τύπων δεδομένων που έχουν οριστεί από το χρήστη Η UML και τα πρότυπα Εξαιρέσεις Γιατί χρειαζόμαστε τις εξαιρέσεις; Σύνταξη εξαιρέσεων...730

12 Περιεχόμενα 15 Ένα απλό παράδειγμα εξαίρεσης Η σειρά των συμβάντων Πολλαπλές εξαιρέσεις Εξαιρέσεις με την κλάση Distance Εξαιρέσεις με ορίσματα Η κλάση bad_alloc Σημειώσεις σχετικά με τις εξαιρέσεις Σύνοψη Ερωτήσεις Ασκήσεις Η Καθιερωμένη Βιβλιοθήκη Προτύπων 751 Εισαγωγή στην STL Αποδέκτες Ακολουθιακοί αποδέκτες Συνειρμικοί αποδέκτες Συναρτήσεις-μέλη Προσαρμογείς αποδεκτών Αλγόριθμοι Επαναλήπτες Πιθανά προβλήματα με την STL Αλγόριθμοι Ο αλγόριθμος find() Αρχεία-κεφαλίδες Περιοχές τιμών Ο αλγόριθμος count() Ο αλγόριθμος sort() Ο αλγόριθμος search() Ο αλγόριθμος merge() Αντικείμενα συναρτήσεων Ο αλγόριθμος for_each() Ο αλγόριθμος transform() Ακολουθιακοί αποδέκτες Διανύσματα Συναρτήσεις-μέλη push_back(), size(), και operator[] Οι συναρτήσεις-μέλη swap(), empty(), back(), και pop_back() Συναρτήσεις-μέλη insert() και erase() Λίστες Συναρτήσεις-μέλη push_front(), front(), και pop_front() Συναρτήσεις-μέλη reverse(), merge(), και unique() Ουρές διπλής εισόδου Επαναλήπτες Οι επαναλήπτες ως έξυπνοι δείκτες Οι επαναλήπτες ως διασύνδεση Ταίριασμα αλγορίθμων με αποδέκτες Οι επαναλήπτες σε δράση...785

13 16 Αντικειμενοστρεφής προγραμματισμός με τη C++ Εξειδικευμένοι επαναλήπτες Προσαρμογείς επαναληπτών Επαναλήπτες ρευμάτων Συνειρμικοί αποδέκτες Σύνολα και πολυσύνολα Χάρτες και πολυχάρτες Αποθήκευση αντικειμένων που έχουν οριστεί από το χρήστη Ένα σύνολο αντικειμένων person Λίστα αντικειμένων person Αντικείμενα συναρτήσεων Προκαθορισμένα αντικείμενα συναρτήσεων Γραφή των δικών σας αντικειμένων συναρτήσεων Αντικείμενα συναρτήσεων για την τροποποίηση της συμπεριφοράς αποδεκτών Σύνοψη Ερωτήσεις Ασκήσεις Αντικειμενοστρεφής ανάπτυξη λογισμικού 827 Η εξέλιξη των διαδικασιών ανάπτυξης λογισμικού Η άμεση προσέγγιση Η διαδικασία του "καταρράκτη" Αντικειμενοστρεφής προγραμματισμός Σύγχρονες διαδικασίες Μοντελοποίηση περιπτώσεων χρήσης Ηθοποιοί Περιπτώσεις χρήσης Σενάρια Διαγράμματα περιπτώσεων χρήσης Περιγραφές περιπτώσεων χρήσης Από τις περιπτώσεις χρήσης στις κλάσεις Το προγραμματιστικό πρόβλημα Χειρόγραφες φόρμες Παραδοχές Η φάση επεξεργασίας του προγράμματος LANDLORD Ηθοποιοί Περιπτώσεις χρήσης Περιγραφές περιπτώσεων χρήσης Σενάρια Διαγράμματα δραστηριοτήτων UML Από τις περιπτώσεις χρήσης στις κλάσεις Κατάλογος των ουσιαστικών Βελτίωση του καταλόγου Ανακάλυψη ιδιοτήτων Από τα ρήματα στα μηνύματα Διαγράμματα κλάσεων Ακολουθιακά διαγράμματα...846

14 Περιεχόμενα 17 Γραφή κώδικα Το αρχείο-κεφαλίδα Τα αρχεία.cpp Ακόμη περισσότερες απλουστεύσεις Αλληλεπίδραση με το πρόγραμμα Τελικές σκέψεις Σύνοψη Ερωτήσεις Έργα Α Πίνακας ASCII 875 Β Πίνακας προτεραιότητας και δεσμευμένες λέξεις στη C Πίνακας προτεραιότητας Δεσμευμένες λέξεις Γ Microsoft Visual C Στοιχεία της οθόνης Προγράμματα ενός αρχείου Δόμηση υπάρχοντος αρχείου Γραφή νέου αρχείου Σφάλματα Πληροφορίες τύπων κατά το χρόνο εκτέλεσης (RTTI) Προγράμματα με πολλά αρχεία Έργα και χώροι εργασίας Ανάπτυξη του έργου Αποθήκευση, κλείσιμο, και άνοιγμα έργων Δόμηση προγραμμάτων με συναρτήσεις Console Graphics Lite Αποσφαλμάτωση Βηματική εκτέλεση Παρακολούθηση μεταβλητών Εκτέλεση των εντολών στο εσωτερικό συναρτήσεων Σημεία διακοπής Δ Borland C++ Builder 897 Εκτέλεση των προγραμμάτων των παραδειγμάτων με το C++ Builder Καθαρισμός της οθόνης Δημιουργία νέου έργου Ονομασία και αποθήκευση έργου Ξεκίνημα με υπάρχοντα αρχεία Μεταγλώττιση, σύνδεση, και εκτέλεση Εκτέλεση από το C++ Builder Εκτέλεση από το MS-DOS Προμεταγλωττισμένα αρχεία-κεφαλίδες Κλείσιμο και άνοιγμα έργων...902

15 18 Αντικειμενοστρεφής προγραμματισμός με τη C++ Προσθήκη αρχείου-κεφαλίδας στο έργο σας Δημιουργία νέου αρχείου-κεφαλίδας Διόρθωση υπάρχοντος αρχείου-κεφαλίδας Ενημέρωση του C++ Builder για τη θέση του αρχείου-κεφαλίδας Έργα με πολλά πηγαία αρχεία Δημιουργία πρόσθετων πηγαίων αρχείων Προσθήκη υπαρχόντων αρχείων στο έργο σας Ο Διαχειριστής έργων Προγράμματα με συναρτήσεις του πακέτου Console Graphics Lite Αποσφαλμάτωση Βηματική εκτέλεση Παρακολούθηση μεταβλητών Εκτέλεση εντολών στο εσωτερικό συναρτήσεων Σημεία διακοπής Ε Console Graphics Lite 907 Χρήση ρουτινών του πακέτου Console Graphics Lite Οι συναρτήσεις του πακέτου Console Graphics Lite Υλοποιήσεις των συναρτήσεων του πακέτου Console Graphics Lite Μεταγλωττιστές τής Microsoft Μεταγλωττιστές τής Borland Λίστες πηγαίου κώδικα Λίστα του MSOFTCON.H Λίστα του MSOFTCON.CPP Λίστα του BORLACON.H Λίστα του BORLACON.CPP ΣΤ Αλγόριθμοι και συναρτήσεις-μέλη της STL 921 Αλγόριθμοι Συναρτήσεις-μέλη Επαναλήπτες Ζ Απαντήσεις ερωτήσεων και ασκήσεων 939 Κεφάλαιο Απαντήσεις στις ερωτήσεις Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων...951

16 Περιεχόμενα 19 Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Λύσεις των ασκήσεων Κεφάλαιο Απαντήσεις στις ερωτήσεις Ζ Βιβλιογραφία 1003 C++ για προχωρημένους Έγγραφα προδιαγραφών Η Ενοποιημένη Γλώσσα Μοντελοποίησης Η Ιστορία της C Άλλα θέματα Ευρετήριο 1007

17 Κληρονομικότητα ΚΕΦΑΛΑΙΟ 9 ΣΕ ΑΥΤΟ ΤΟ ΚΕΦΑΛΑΙΟ Παράγωγη κλάση και βασική κλάση 399 Συναρτήσεις δόμησης παραγώγων κλάσεων 406 Υποσκέλιση συναρτήσεων-μελών 408 Ποια συνάρτηση χρησιμοποιείται; 409 Κληρονομικότητα στην κλάση Αγγλικών μονάδων μέτρησης Distance 410 Ιεραρχίες κλάσεων 414 Κληρονομικότητα και σχήματα γραφικών 419 Δημόσια και ιδιωτική κληρονομικότητα 422 Επίπεδα κληρονομικότητας 425 Πολλαπλή κληρονομικότητα 429 Ιδιωτικές παράγωγες κλάσεις στο πρόγραμμα EMPMULT 435 Αμφισημία στην πολλαπλή κληρονομικότητα 439 Συσσώρευση: κλάσεις στο εσωτερικό κλάσεων 440 Κληρονομικότητα και ανάπτυξη προγραμμάτων 446

18 398 Κεφάλαιο 9 Η κληρονομικότητα είναι πιθανότατα η πιο ισχυρή λειτουργία του αντικειμενοστρεφούς προγραμματισμού, μετά βέβαια από τις κλάσεις. Η κληρονομικότητα είναι η διαδικασία της δημιουργίας νέων κλάσεων, που ονομάζονται παράγωγες κλάσεις (derived classes), από τις υπάρχουσες ή βασικές κλάσεις (base classes). Η παράγωγη κλάση κληρονομεί όλες τις δυνατότητες της βασικής κλάσης, αλλά μπορεί να τις "εκλεπτύνει" ή να τις "καλλωπίζει". Η βασική κλάση παραμένει αναλλοίωτη μετά από αυτή τη διαδικασία. Η σχέση της κληρονομικότητας φαίνεται στην Εικόνα 9.1. ΕΙΚΟΝΑ 9.1 Κληρονομικότητα. Το βέλος σε αυτή την εικόνα δείχνει σε αντίθετη κατεύθυνση από αυτή που θα περιμένατε. Αν έδειχνε προς τα κάτω, θα το λέγαμε κληρονομικότητα. Ωστόσο, η πιο συνηθισμένη προσέγγιση είναι να κατευθύνουμε το βέλος προς τα επάνω, από την παράγωγη κλάση προς τη βασική κλάση, και θεωρούμε ότι το βέλος έχει την έννοια "παράγεται από".

19 Κληρονομικότητα 399 Η κληρονομικότητα αποτελεί ουσιώδες τμήμα του ΑΣΠ. Το μεγάλο της πλεονέκτημα είναι ότι επιτρέπει την ανακύκλωση του κώδικα. Αφού γραφεί και αποσφαλματωθεί (debugged), μια βασική κλάση δεν χρειάζεται να την πειράξετε ξανά, αλλά μπορείτε να την προσαρμόσετε ώστε να λειτουργεί σε διαφορετικές συνθήκες. Η ανακύκλωση του υπάρχοντος κώδικα εξοικονομεί χρόνο και χρήματα και αυξάνει την αξιοπιστία του προγράμματος. Η κληρονομικότητα μπορεί επίσης να βοηθήσει στην αρχική σύλληψη ενός προβλήματος προγραμματισμού, καθώς και στο συνολικό σχεδιασμό του προγράμματος. Ένα αποτέλεσμα της ανακύκλωσης είναι η ευκολία στη διανομή βιβλιοθηκών κλάσεων. Ένας προγραμματιστής μπορεί να χρησιμοποιήσει μια κλάση που δημιουργήθηκε από κάποιο άλλο άτομο ή εταιρεία και, χωρίς να την τροποποιήσει, να παραγάγει άλλες κλάσεις που θα είναι κατάλληλες για τις συγκεκριμένες συνθήκες. Αφού δούμε στην πράξη μερικές ειδικές περιπτώσεις κληρονομικότητας, θα εξετάσουμε τα χαρακτηριστικά της κληρονομικότητας που αναφέραμε προηγουμένως. Παράγωγη κλάση και βασική κλάση Θυμάστε το παράδειγμα COUNTPP3 στο Κεφάλαιο 8, "Υπερφόρτωση τελεστών"; Αυτό το πρόγραμμα χρησιμοποιούσε την κλάση Counter ως μεταβλητή μετρητή γενικής χρήσης. Η μέτρηση μπορούσε μέσω των συναρτήσεων δόμησης να πάρει αρχική τιμή 0 ή κάποιο καθορισμένο αριθμό, ή να αυξηθεί με τον τελεστή ++, ή να διαβαστεί με τη συνάρτηση get_count(). Ας υποθέσουμε ότι εργαστήκαμε πολύ και σκληρά για να κάνουμε την κλάση Counter να λειτουργεί ακριβώς με τον τρόπο που θέλουμε, και ότι είμαστε ευχαριστημένοι με το αποτέλεσμα με εξαίρεση ένα μόνο πράγμα. Στην πραγματικότητα, χρειαζόμαστε έναν τρόπο για να μειώνουμε το μετρητή. Ί- σως μετρούμε τον κόσμο που μπαίνει σε μια τράπεζα, και θέλουμε να αυξάνουμε το μετρητή όταν κάποιος μπαίνει και να τον μειώνουμε όταν βγαίνει, ώστε κάθε στιγμή ο μετρητής να αντιπροσωπεύει το πλήθος των ατόμων που βρίσκονται μέσα στην τράπεζα. Θα μπορούσαμε να βάλουμε κατευθείαν στον πηγαίο κώδικα της κλάσης Counter μια ρουτίνα μείωσης. Ωστόσο, υπάρχουν διάφοροι λόγοι για τους οποίους μπορεί να μη θέλουμε να κάνουμε κάτι τέτοιο. Πρώτον, η κλάση Counter λειτουργεί πολύ καλά και έχει περάσει από πολλές ώρες δοκιμών και διόρθωσης σφαλμάτων. (Φυσικά, σε αυτή την περίπτωση αυτό είναι υπερβολή, αλλά αυτό θα μπορούσε να ισχύει για μια μεγαλύτερη και πιο σύνθετη κλάση.) Αν αρχίσουμε να παίζουμε με τον πηγαίο κώδικα της Counter, τότε η διαδικασία ελέγχου θα έπρεπε να επαναληφθεί, και βεβαίως μπορεί να πειράξουμε κάτι και να χρειαστούμε ώρες για να διορθώσουμε έναν κώδικα που λειτουργούσε θαυμάσια πριν τον τροποποιήσουμε. Σε μερικές περιπτώσεις μπορεί να υπάρχει και άλλος λόγος για να αποφύγουμε την τροποποίηση της κλάσης Counter: μπορεί να μην έχουμε πρόσβαση στον πηγαίο της κώδικα, ειδικά μάλιστα αν αυτή έχει διανεμηθεί μέσα σε μια βιβλιοθήκη κλάσεων. (Αυτό το θέμα θα το εξετάσουμε περισσότερο στο Κεφάλαιο 13, "Προγράμματα με πολλά αρχεία".) Για να αποφύγουμε αυτά τα προβλήματα, μπορούμε να χρησιμοποιήσουμε την κληρονομικότητα για να δημιουργήσουμε μια νέα κλάση που θα βασίζεται στην Counter, χωρίς να τροποποιήσουμε την ίδια την Counter. Θα δούμε τώρα τη λίστα του προγράμματος COUNTEN, το οποίο περιλαμβάνει μια νέα κλάση, την CountDn, που προσθέτει στην κλάση Counter έναν τελεστή μείωσης:

20 400 Κεφάλαιο 9 // counten.cpp // κληρονομικότητα με την κλάση Counter #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// class Counter //βασική κλάση protected: //ΣΗΜΕΙΩΣΗ: η count δεν είναι unsigned int count; //ιδιωτικό μέλος public: Counter() : count(0) //συνάρτηση δόμησης χωρίς ορίσματα } Counter(int c) : count(c) //συνάρτηση ενός ορίσματος } unsigned int get_count() const //επιστροφή της count return count; } Counter operator ++ () //αύξηση της count (προθεματική) return Counter(++count); } }; //////////////////////////////////////////////////////////////// class CountDn : public Counter //παράγωγη κλάση public: Counter operator -- () //μείωση της count (προθεματική) return Counter(--count); } }; //////////////////////////////////////////////////////////////// int main() CountDn c1; //c1 της κλάσης CountDn cout << "\nc1=" << c1.get_count(); ++c1; ++c1; ++c1; cout << "\nc1=" << c1.get_count(); //εμφάνιση του c1 //αύξηση του c1 3 φορές //εμφάνιση του c1 --c1; --c1; cout << "\nc1=" << c1.get_count(); cout << endl; return 0; } //μείωση του c1 δύο φορές //εμφάνιση του c1 Η λίστα του προγράμματος ξεκινά με την κλάση Counter, η οποία (με μια μικρή εξαίρεση που θα δούμε αργότερα) δεν έχει αλλάξει από τη μορφή που είχε στο COUNTPP3. Σημειώστε ότι, για λόγους απλότητας, δεν βασίσαμε το πρόγραμμά μας στο πρόγραμμα POSTFIX το οποίο ενσωμάτωνε το δεύτερο υπερφορτωμένο τελεστή ++ ώστε να παρέχει και τη δυνατότητα επιθεματικής σημειογραφίας.

21 Κληρονομικότητα 401 Καθορισμός της παράγωγης κλάσης Μετά από την κλάση Counter, ακολουθεί στον κώδικα η προδιαγραφή μιας νέας κλάσης, της CountDn. Αυτή η κλάση ενσωματώνει μια νέα συνάρτηση, την operator--(), η οποία μειώνει τη μέτρηση. Ωστόσο και αυτό είναι το βασικό η νέα κλάση CountDn κληρονομεί όλα τα χαρακτηριστικά της κλάσης Counter. Η CountDn δεν χρειάζεται συνάρτηση δόμησης ούτε και τις συναρτήσεις get_count() ή operator++(), αφού αυτές υπάρχουν ήδη στην Counter. Η πρώτη γραμμή της CountDn καθορίζει ότι παράγεται από την Counter: class CountDn : public Counter Εδώ χρησιμοποιούμε μία άνω και κάτω τελεία (όχι δύο άνω και κάτω τελείες, που χρησιμοποιούνται για τον τελεστή επίλυσης εμβέλειας), ακολουθούμενη από τη δεσμευμένη λέξη public και το όνομα της βασικής κλάσης Counter. Αυτό ορίζει τη σχέση μεταξύ των κλάσεων. Η γραμμή αυτή λέει ότι η CountDn παράγεται από τη βασική κλάση Counter. (Το αποτέλεσμα της δεσμευμένης λέξης public θα την εξετάσουμε αργότερα.) Η γενίκευση σε διαγράμματα κλάσεων UML Στη UML, η κληρονομικότητα ονομάζεται γενίκευση (generalization) επειδή η γονική κλάση (parent class) είναι μια πιο γενική μορφή της θυγατρικής κλάσης (child class). Ή, για να το θέσουμε διαφορετικά, το τέκνο είναι μια πιο εξειδικευμένη εκδοχή του γονέα. (Παρουσιάσαμε τη UML στο Κεφάλαιο 1, "Η γενική εικόνα", και συναντήσαμε τα διαγράμματα κλάσεων στο Κεφάλαιο 8, "Υπερφόρτωση τελεστών".) Η γενίκευση στο πρόγραμμα COUNTEN παρουσιάζεται στην Εικόνα 9.2. Counter count counter() counter(int) get_count() operator++() CountDn operator--() ΕΙΚΟΝΑ 9.2 Διάγραμμα κλάσεων UML για τo πρόγραμμα COUNTEN.

22 402 Κεφάλαιο 9 Στα διαγράμματα κλάσεων της UML η γενίκευση υποδηλώνεται από μια τριγωνική (κλειστή) αιχμή βέλους στη γραμμή που συνδέει τη γονική και τη θυγατρική κλάση. Να θυμάστε ότι το βέλος αυτό σημαίνει κληρονομείται από ή παράγεται από ή είναι πιο εξειδικευμένη εκδοχή του. Η κατεύθυνση του βέλους τονίζει το γεγονός ότι η παράγωγη κλάση αναφέρεται σε συναρτήσεις και δεδομένα της βασικής κλάσης, ενώ η βασική κλάση δεν έχει πρόσβαση στην παράγωγη κλάση. Παρατηρήστε ότι έχουμε προσθέσει χαρακτηριστικά (μέλη δεδομένων) και λειτουργίες (συναρτήσειςμέλη) στις κλάσεις του διαγράμματος. Η περιοχή στην κορυφή περιέχει τον τίτλο της κλάσης, η περιοχή στο μέσο περιέχει τα χαρακτηριστικά, και η κάτω περιοχή είναι για τις λειτουργίες. Προσπέλαση μελών της βασικής κλάσης Ένα σημαντικό θέμα στην κληρονομικότητα είναι να γνωρίζετε πότε μπορεί να χρησιμοποιηθεί μια συνάρτηση-μέλος της βασικής κλάσης από αντικείμενα της παράγωγης κλάσης. Αυτό ονομάζεται προσπελασιμότητα (accessibility). Ας δούμε πώς χειρίζεται ο μεταγλωττιστής το θέμα της προσπελασιμότητας στο παράδειγμα COUNTEN. Αντικατάσταση των συναρτήσεων δόμησης της βασικής κλάσης Στο τμήμα main() του προγράμματος COUNTEN δημιουργούμε ένα αντικείμενο της κλάσης CountDn: CountDn c1; Αυτό δημιουργεί το c1 ως αντικείμενο της κλάσης CountDn και του δίνει αρχική τιμή 0. Για σταθείτε όμως πώς είναι δυνατόν να γίνεται αυτό; Δεν υπάρχει συνάρτηση δόμησης στο δηλωτικό της κλάσης CountDn, οπότε ποια οντότητα πραγματοποιεί την απόδοση αρχικής τιμής; Φαίνεται ότι τουλάχιστον κάτω από ορισμένες συνθήκες αν δεν καθορίσετε συνάρτηση δόμησης, η παράγωγη κλάση θα χρησιμοποιήσει μια κατάλληλη συνάρτηση δόμησης της βασικής κλάσης. Στο πρόγραμμα COUNTEN δεν υπάρχει συνάρτηση δόμησης στην CountDn, και έτσι ο μεταγλωττιστής χρησιμοποιεί τη χωρίς ορίσματα συνάρτηση δόμησης της Count. Η ευελιξία του μεταγλωττιστή να χρησιμοποιεί μια συνάρτηση επειδή δεν υπάρχει άλλη διαθέσιμη εμφανίζεται συχνά σε περιπτώσεις κληρονομικότητας. Συνήθως αυτή η αντικατάσταση είναι ακριβώς εκείνο που θέλετε, αλλά μερικές φορές μπορεί να είναι αποκαρδιωτική. Αντικατάσταση συναρτήσεων-μελών της βασικής κλάσης Το αντικείμενο c1 της κλάσης CountDn χρησιμοποιεί επίσης τις συναρτήσεις operator++() και get_count() από την κλάση Counter. Η πρώτη χρησιμοποιείται για την αύξηση του c1: c1++; και η δεύτερη χρησιμοποιείται για την εμφάνιση της μέτρησης του c1: cout << "\nc1=" << c1.get_count(); Και πάλι ο μεταγλωττιστής, μη βρίσκοντας αυτές τις συναρτήσεις στην κλάση της οποίας είναι μέλος το c1, χρησιμοποιεί τις συναρτήσεις-μέλη της βασικής κλάσης.

23 Κληρονομικότητα 403 Έξοδος του COUNTEN Στη συνάρτηση main() αυξάνουμε τρεις φορές το c1, τυπώνουμε την τιμή που προκύπτει, μειώνουμε δύο φορές το c1, και τελικά τυπώνουμε πάλι την τιμή του. Εδώ έχουμε την έξοδο: c1=0 < μετά την απόδοση αρχικής τιμής c1=3 < μετά από c1++, c1++, c1++ c1=1 < μετά από c1--, c1-- Ο τελεστής ++, οι συναρτήσεις δόμησης, η συνάρτηση get_count() της κλάσης Counter, και ο τελεστής -- της κλάσης CountDn, λειτουργούν όλα με αντικείμενα τύπου CountDn. Το προσδιοριστικό πρόσβασης protected Μέχρι τώρα, αυξήσαμε τη λειτουργικότητα της κλάσης χωρίς να την τροποποιήσουμε. Τέλος πάντων, σχεδόν χωρίς να την τροποποιήσουμε. Ας δούμε τη μοναδική αλλαγή που κάναμε στην κλάση Counter. Τα δεδομένα στις κλάσεις που έχουμε δει μέχρι τώρα, μεταξύ των οποίων και το count στην κλάση Counter του προηγούμενου προγράμματος COUNTPP3, έχουν χρησιμοποιήσει το προσδιοριστικό πρόσβασης (access specifier) private. Στην κλάση Counter του προγράμματος COUNTEN, το count παίρνει ένα νέο προσδιοριστικό, το protected (προστατευμένο). Τι κάνει αυτό; Ας επαναλάβουμε πρώτα όλα όσα ξέρουμε για τα προσδιοριστικά πρόσβασης private και public. Μια συνάρτηση-μέλος μιας κλάσης μπορεί πάντοτε να προσπελάσει τα μέλη της κλάσης, είτε είναι ιδιωτικά είτε είναι δημόσια. Όμως, ένα αντικείμενο της κλάσης που ορίζεται έξω από την κλάση μπορεί να προσπελάσει μόνο τα δημόσια μέλη της κλάσης (χρησιμοποιώντας, για παράδειγμα, τον τελεστή τελείας). Δεν επιτρέπεται να χρησιμοποιήσει ιδιωτικά μέλη. Για παράδειγμα, έστω ότι το αντικείμενο obja είναι παρουσία της κλάσης A και η συνάρτηση funca() είναι συνάρτηση-μέλος της Α. Τότε στη main() (ή σε οποιαδήποτε άλλη συνάρτηση που δεν είναι μέλος της Α), η εντολή obja.funca(); δεν θα είναι αποδεκτή εκτός αν η func() είναι δημόσια. Το αντικείμενο obja δεν μπορεί να προσπελάζει ιδιωτικά μέλη της κλάσης Α. Τα ιδιωτικά μέλη είναι, τέλος πάντων, ιδιωτικά. Αυτό φαίνεται στην Εικόνα 9.3. Αυτά είναι όλα όσα πρέπει να ξέρουμε αν δεν χρησιμοποιούμε την κληρονομικότητα. Με την κληρονομικότητα όμως, υπάρχει μια ολόκληρη γκάμα πρόσθετων δυνατοτήτων. Το ερώτημα που μας απασχολεί αυτή τη στιγμή είναι αν θα μπορούν οι συναρτήσεις-μέλη της παράγωγης κλάσης να προσπελάσουν μέλη της βασικής κλάσης. Με άλλα λόγια, μπορεί η operator--() της CountDn να προσπελάσει το μέλος δεδομένων count της Counter; Η απάντηση είναι ότι οι συναρτήσεις-μέλη μπορούν να προσπελάσουν μέλη της βασικής κλάσης μόνο αν τα μέλη αυτά είναι public (δημόσια) ή protected (προστατευμένα). Δεν μπορούν όμως να προσπελάσουν μέλη που είναι private (ιδιωτικά). Δεν θέλουμε να κάνουμε το count δημόσιο (public), αφού αυτό θα επέτρεπε την προσπέλασή του από οποιαδήποτε συνάρτηση σε οποιοδήποτε σημείο μέσα στο πρόγραμμα και θα εξαφάνιζε το πλεονέκτημα της απόκρυψης δεδομένων. Από την άλλη πλευρά, το προστατευμένο μέλος (protected) μπορεί να προσπελαστεί από συναρτήσεις-μέλη μέσα στη δική του κλάση ή και εδώ είναι το κλειδί σε οποιαδήποτε κλάση που έχει παραχθεί από την κλάση του. Δεν μπορεί να προσπελαστεί από

24 404 Κεφάλαιο 9 συναρτήσεις που βρίσκονται έξω από αυτές τις κλάσεις, όπως η main(). Αυτό ακριβώς είναι που θέλουμε. Η κατάσταση αυτή φαίνεται στην Εικόνα 9.4. Η συνάρτηση-μέλος της κλάσης Α μπορεί να προσπελάσει και τα ιδιωτικά και τα δημόσια μέλη. κλάση A private Δεν επιτρέπεται public ObjA ΕΙΚΟΝΑ 9.3 Προσδιοριστικά πρόσβασης χωρίς κληρονομικότητα. Το αντικείμενο της κλάσης Α μπορεί να προσπελάσει μόνο τα δημόσια μέλη της Α. ΕΙΚΟΝΑ 9.4 Προσδιοριστικά πρόσβασης με κληρονομικότητα.

25 Κληρονομικότητα 405 Ο Πίνακας 9.1 συνοψίζει την κατάσταση με διαφορετικό τρόπο: ΠΙΝΑΚΑΣ 9.1 Κληρονομικότητα και προσπελασιμότητα Προσδιοριστικό Προσπελάσιμο από Προσπελάσιμο από Προσπελάσιμο από πρόσβασης τη δική του κλάση παράγωγη κλάση αντικείμενα έξω από την κλάση public ναι ναι ναι protected ναι ναι όχι private ναι όχι όχι Το συμπέρασμα είναι ότι, αν γράφετε μια κλάση που υποψιάζεστε ότι μπορεί να χρησιμοποιηθεί στο μέλλον ως βασική κλάση για άλλες παράγωγες κλάσεις, τότε τα δεδομένα-μέλη που θα χρειαστεί να προσπελάσουν οι παράγωγες κλάσεις θα πρέπει να έχουν το προσδιοριστικό protected, και όχι το private. Αυτό εξασφαλίζει ότι η κλάση θα έχει τη "δυνατότητα κληροδότησης". Κίνδυνοι του προσδιοριστικού protected Θα πρέπει να γνωρίζετε ότι υπάρχει ένα μειονέκτημα όταν δίνετε την ιδιότητα protected στα μέλη της κλάσης. Ας υποθέσουμε ότι έχετε γράψει μια βιβλιοθήκη κλάσεων και την έχετε διαθέσει σε άλλους. Οποιοσδήποτε προγραμματιστής που θα αγοράσει αυτή τη βιβλιοθήκη θα μπορεί να προσπελάσει τα προστατευμένα μέλη των κλάσεών σας με απλή παραγωγή άλλων κλάσεων από αυτές. Αυτό κάνει τα προστατευμένα μέλη πολύ λιγότερο ασφαλή, σε σύγκριση με τα ιδιωτικά μέλη. Για να αποφύγετε την αλλοίωση των δεδομένων, συχνά είναι πιο ασφαλές να αναγκάζετε τις παράγωγες κλάσεις να προσπελάζουν τα δεδομένα της βασικής κλάσης με τη χρήση μόνο δημόσιων συναρτήσεων-μελών της βασικής κλάσης, όπως πρέπει να κάνουν τα κανονικά προγράμματα main(). Η χρήση του προσδιοριστικού protected οδηγεί σε απλούστερα προγράμματα, οπότε και εμείς θα το χρησιμοποιήσουμε ίσως περισσότερο από ό,τι θα έπρεπε στα παραδείγματα του βιβλίου. Για τα δικά σας προγράμματα θα πρέπει να σταθμίσετε τα πλεονεκτήματα και τα μειονεκτήματα που παρέχει το προσδιοριστικό protected. Αμετάβλητη βασική κλάση Θυμηθείτε ότι, ακόμα και αν έχουν παραχθεί άλλες κλάσεις από αυτή, η βασική κλάση παραμένει αμετάβλητη. Στο τμήμα main() του προγράμματος COUNTEN, θα μπορούσαμε να ορίσουμε αντικείμενα τύπου Counter: Counter c2; < αντικείμενο βασικής κλάσης Αυτά τα αντικείμενα θα συμπεριφέρονταν όπως και αν δεν υπήρχε η CountDn. Παρατηρήστε επίσης ότι η κληρονομικότητα δεν λειτουργεί αντίστροφα. Η βασική κλάση και τα α- ντικείμενά της δεν γνωρίζουν τίποτε για όποιες κλάσεις προκύπτουν από τη βασική κλάση. Στο συγκεκριμένο παράδειγμα, αυτό σημαίνει ότι τα αντικείμενα της κλάσης Counter, όπως το c2 που ορίσαμε εδώ, δεν μπορούν να χρησιμοποιήσουν τη συνάρτηση operator--() που υπάρχει στην CountDn. Αν θέλετε ένα μετρητή που να μπορείτε να μειώνετε, τότε αυτός θα πρέπει να ανήκει στην κλάση CountDn και όχι στην Counter.

26 406 Κεφάλαιο 9 Άλλοι όροι Σε ορισμένες γλώσσες, η βασική κλάση ονομάζεται υπερκλάση (superclass) και η παράγωγη κλάση υποκλάση (subclass). Επίσης, ορισμένοι συγγραφείς αναφέρουν τη βασική κλάση ως γονική (parent) και την παράγωγη κλάση ως θυγατρική (child). Συναρτήσεις δόμησης παραγώγων κλάσεων Στο πρόγραμμα COUNTEN, υπάρχει κάποιο πρόβλημα που δεν έχει κάνει ακόμα την εμφάνισή του. Τι θα συμβεί αν θελήσουμε να δώσουμε αρχική τιμή σε ένα αντικείμενο CountDn; Μπορεί να χρησιμοποιηθεί η συνάρτηση δόμησης ενός ορίσματος της Counter; Η απάντηση είναι όχι. Όπως είδαμε στο COUNTEN, ο μεταγλωττιστής θα χρησιμοποιήσει μια συνάρτηση δόμησης της βασικής κλάσης χωρίς ορίσματα, αλλά δεν θα το κάνει για τις πιο σύνθετες συναρτήσεις δόμησης. Για να μπορεί να λειτουργήσει ένας τέτοιος ορισμός, θα πρέπει να γράψουμε ένα νέο σύνολο συναρτήσεων δόμησης για την παράγωγη κλάση. Αυτό φαίνεται στο πρόγραμμα COUNTEN2: // counten2.cpp // συναρτήσεις δόμησης στην παράγωγη κλάση #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// class Counter protected: //ΠΡΟΣΟΧΗ: η count δεν είναι unsigned int count; //ιδιωτικό μέλος public: Counter() : count(0) //συνάρτηση δόμησης, χωρίς ορίσματα } Counter(int c) : count(c) //συνάρτηση δόμησης, ένα όρισμα } unsigned int get_count() const //επιστροφή της count return count; } Counter operator ++ () //αύξηση της count (προθεματική) return Counter(++count); } }; //////////////////////////////////////////////////////////////// class CountDn : public Counter public: CountDn() : Counter() //συνάρτηση δόμησης, χωρίς ορίσματα } CountDn(int c) : Counter(c) //συνάρτηση δόμησης, με ένα όρισμα } CountDn operator -- () //μείωση της count (προθεματική) return CountDn(--count); } };

27 Κληρονομικότητα 407 //////////////////////////////////////////////////////////////// int main() CountDn c1; //κλάση CountDn CountDn c2(100); cout << "\nc1=" << c1.get_count(); cout << "\nc2=" << c2.get_count(); ++c1; ++c1; ++c1; cout << "\nc1=" << c1.get_count(); --c2; --c2; cout << "\nc2=" << c2.get_count(); //εμφάνιση //εμφάνιση //αύξηση του c1 //εμφάνιση του c1 //μείωση του c2 //εμφάνιση του c2 CountDn c3 = --c2; cout << "\nc3=" << c3.get_count(); cout << endl; return 0; } //δημιουργία του c3 από το c2 //εμφάνιση του c3 Αυτό το πρόγραμμα χρησιμοποιεί δύο νέες συναρτήσεις δόμησης στην κλάση CountDn. Εδώ έχουμε τη συνάρτηση δόμησης χωρίς ορίσματα: CountDn() : Counter() } Αυτή η συνάρτηση δόμησης έχει ένα άγνωστο χαρακτηριστικό: το όνομα της συνάρτησης που ακολουθεί την άνω και κάτω τελεία. Αυτή η κατασκευή υποχρεώνει τη συνάρτηση δόμησης CountDn() να καλέσει τη συνάρτηση δόμησης Counter()της βασικής κλάσης. Στη main(), όταν λέμε CountDn c1; ο μεταγλωττιστής δημιουργεί ένα αντικείμενο τύπου CountDn και μετά καλεί τη συνάρτηση δόμησης Counter για να του δώσει αρχική τιμή. Αυτή η συνάρτηση δόμησης καλεί με τη σειρά της τη συνάρτηση δόμησης Counter που θα φέρει σε πέρας την εργασία. Η συνάρτηση δόμησης CountDn() θα μπορούσε να περιέχει και άλλες δικές της εντολές, αλλά σε αυτή την περίπτωση δεν χρειάζεται να το κάνει και, έτσι, το σώμα της συνάρτησης μέσα στα άγκιστρα είναι κενό. Η εντολή CountDn c2(100); στη main() χρησιμοποιεί τη συνάρτηση δόμησης ενός ορίσματος της κλάσης CountDn. Και αυτή η συνάρτηση δόμησης καλεί την αντίστοιχη συνάρτηση δόμησης της βασικής κλάσης: CountDn(int c) : Counter(c) < το όρισμα c μεταβιβάζεται στην Counter }

28 408 Κεφάλαιο 9 Αυτή η κατασκευή αναγκάζει το όρισμα c να μεταβιβαστεί από την CountDn() στην Counter(), όπου χρησιμοποιείται για να δώσει αρχική τιμή στο αντικείμενο. Μετά την απόδοση αρχικών τιμών στα αντικείμενα c1 και c2 στη main(), αυξάνουμε το ένα και μειώνουμε το άλλο και μετά τυπώνουμε το αποτέλεσμα. Η συνάρτηση δόμησης ενός ορίσματος χρησιμοποιείται επίσης και σε μια εντολή ανάθεσης τιμής: CountDn c3 = --c2; Υποσκέλιση συναρτήσεων-μελών Μέσα σε μια παράγωγη κλάση, μπορείτε να χρησιμοποιήσετε συναρτήσεις-μέλη που υποσκελίζουν (override) αυτές που υπάρχουν στη βασική κλάση δηλαδή, έχουν το ίδιο όνομα με αυτές. Μπορεί να χρειαστεί να κάνετε κάτι τέτοιο ώστε οι κλήσεις του προγράμματός σας να λειτουργούν με τον ίδιο τρόπο για αντικείμενα τόσο της βασικής όσο και της παράγωγης κλάσης. Θα δούμε τώρα ένα παράδειγμα που βασίζεται στο πρόγραμμα STAKARAY του Κεφαλαίου 7, "Πίνακες και αλφαριθμητικά". Εκείνο το πρόγραμμα δημιουργούσε το μοντέλο μιας στοίβας ενός απλού μηχανισμού αποθήκευσης δεδομένων. Σας επέτρεπε να τοποθετείτε (push) ακεραίους μέσα στη στοίβα και να τους εξάγετε από αυτή. Ωστόσο, το πρόγραμμα STAKARAY είχε ένα ελάττωμα. Αν επιχειρούσατε να τοποθετήσετε περισσότερα στοιχεία στη στοίβα, το πρόγραμμα μπορούσε να "καταρρεύσει" επειδή τα δεδομένα θα έμπαιναν στη μνήμη σε θέσεις πέρα από το τέλος του πίνακα st[]. Επιπλέον, αν επιχειρούσατε να βγάλετε περισσότερα στοιχεία από τη στοίβα το αποτέλεσμα δεν θα είχε κανένα νόημα, αφού θα διαβάζατε δεδομένα από θέσεις της μνήμης έξω από τον πίνακα. Για να "θεραπεύσουμε" αυτά τα ελαττώματα δημιουργήσαμε μια νέα κλάση, τη Stack2, που είναι παράγωγη της Stack. Τα αντικείμενα της Stack2 συμπεριφέρονται ακριβώς με τον ίδιο τρόπο όπως και εκείνα της Stack, με τη διαφορά ότι θα ειδοποιηθείτε αν επιχειρήσετε να τοποθετήσετε περισσότερα στοιχεία στη στοίβα ή αν επιχειρήσετε να εξαγάγετε στοιχεία από μια κενή στοίβα. Η λίστα του προγράμματος STAKEN είναι η εξής: // staken.cpp // υπερφόρτωση συναρτήσεων στη βασική και τις παράγωγες κλάσεις #include <iostream> using namespace std; #include <process.h> //για την exit() //////////////////////////////////////////////////////////////// class Stack protected: //ΠΡΟΣΟΧΗ: δεν μπορεί να είναι ιδιωτικά enum MAX = 3 }; //μέγεθος του πίνακα της στοίβας int st[max]; //στοίβα: πίνακας ακεραίων int top; //αριθμοδείκτης της κορυφής της στοίβας public: Stack() //συνάρτηση δόμησης top = -1; } void push(int var) //τοποθέτηση αριθμού στη στοίβα st[++top] = var; } int pop() //εξαγωγή αριθμού από τη στοίβα

29 Κληρονομικότητα 409 return st[top--]; } }; //////////////////////////////////////////////////////////////// class Stack2 : public Stack public: void push(int var) //τοποθέτηση αριθμού στη στοίβα if(top >= MAX-1) //σφάλμα αν η στοίβα είναι πλήρης cout << "\nerror: stack is full"; exit(1); } Stack::push(var); //κλήση της push() της κλάσης Stack } int pop() //εξαγωγή αριθμού από τη στοίβα if(top < 0) //σφάλμα αν η στοίβα είναι κενή cout << "\nerror: stack is empty\n"; exit(1); } return Stack::pop(); //κλήση της pop() της κλάσης Stack } }; //////////////////////////////////////////////////////////////// int main() Stack2 s1; s1.push(11); s1.push(22); s1.push(33); //τοποθέτηση μερικών τιμών στη στοίβα cout << endl << s1.pop(); cout << endl << s1.pop(); cout << endl << s1.pop(); cout << endl << s1.pop(); cout << endl; return 0; } //εξαγωγή μερικών τιμών από τη στοίβα //ωπ, εξαγάγαμε πάρα πολλά Σε αυτό το πρόγραμμα, η κλάση Stack είναι ακριβώς ίδια όπως και στο πρόγραμμα STAKARAY, με τη διαφορά ότι τα μέλη δεδομένων είναι τώρα προστατευμένα (protected). Ποια συνάρτηση χρησιμοποιείται; Η κλάση Stack2 περιέχει δύο συναρτήσεις, τις push() και pop(). Αυτές οι συναρτήσεις έχουν τα ίδια ονόματα και τους ίδιους τύπους ορισμάτων και επιστρεφόμενων τιμών όπως και οι συναρτήσεις της Stack. Όταν τις καλούμε από τη main(), σε προτάσεις όπως η επόμενη s1.push(11);

30 410 Κεφάλαιο 9 πώς καταλαβαίνει ο μεταγλωττιστής ποια από τις δύο συναρτήσεις push() θα χρησιμοποιήσει; Ο κανόνας είναι ο εξής: όταν υπάρχει η ίδια συνάρτηση και στη βασική και στην παράγωγη κλάση, τότε εκτελείται η συνάρτηση της παράγωγης κλάσης. (Αυτό ισχύει για τα αντικείμενα της παράγωγης κλάσης. Τα αντικείμενα της βασικής κλάσης δεν γνωρίζουν τίποτε για την παράγωγη κλάση και χρησιμοποιούν πάντοτε τις συναρτήσεις της βασικής κλάσης.) Στην περίπτωση αυτή, λέμε ότι η συνάρτηση της παράγωγης κλάσης υποσκελίζει (override) τη συνάρτηση της βασικής κλάσης. Έτσι, στην προηγούμενη πρόταση, αφού το s1 είναι αντικείμενο της κλάσης Stack2, θα εκτελεστεί η συνάρτηση push() της κλάσης Stack2 και όχι αυτή της Stack. Η συνάρτηση push() της Stack2 ελέγχει αν η στοίβα είναι πλήρης. Αν είναι, εμφανίζει ένα μήνυμα σφάλματος και προκαλεί την έξοδο από το πρόγραμμα. Αν δεν είναι, καλεί τη συνάρτηση push()της κλάσης Stack. Παρόμοια, η συνάρτηση pop() της Stack2 ελέγχει αν η στοίβα είναι κενή. Αν είναι. εμφανίζει ένα μήνυμα σφάλματος και τερματίζει το πρόγραμμα, διαφορετικά καλεί τη συνάρτηση pop()της κλάσης Stack. Στη main() τοποθετούμε (push) τρία στοιχεία στη στοίβα, αλλά εξάγουμε (pop) τέσσερα. Η τελευταία εξαγωγή στοιχείου παράγει ένα μήνυμα σφάλματος Error: stack is empty και τερματίζει το πρόγραμμα. Επίλυση εμβέλειας σε συναρτήσεις που έχουν υποστεί υποσκέλιση Πώς γίνεται οι push() και pop() της Stack2 να προσπελάζουν τις push() και pop() της κλάσης Stack; Χρησιμοποιούν τον τελεστή επίλυσης εμβέλειας :: στις αντίστοιχες εντολές: Stack::push(var); και return Stack::pop(); Αυτές οι εντολές ορίζουν ότι θα κληθούν οι συναρτήσεις push() και pop() της Stack. Χωρίς τον τελεστή επίλυσης εμβέλειας, ο μεταγλωττιστής θα νόμιζε ότι οι συναρτήσεις push() και pop() της Stack2 καλούν τον εαυτό τους, που σε αυτή την περίπτωση θα οδηγούσε σε αστοχία του προγράμματος. Χρησιμοποιώντας τον τελεστή επίλυσης εμβέλειας, μπορείτε να καθορίσετε επακριβώς ποιας κλάσης είναι μέλος η συνάρτηση. Κληρονομικότητα στην κλάση Αγγλικών μονάδων μέτρησης Distance Θα δούμε τώρα ένα κάπως πιο σύνθετο παράδειγμα κληρονομικότητας. Μέχρι τώρα σε αυτό το βιβλίο, τα διάφορα προγράμματα που χρησιμοποιούσαν την κλάση Αγγλικών μονάδων μέτρησης Distance θεωρούσαν ότι οι αποστάσεις που θα αναπαριστούσαν ήταν πάντοτε θετικές. Συνήθως αυτή είναι άλλωστε η κατάσταση στα αρχιτεκτονικά σχέδια.

31 Κληρονομικότητα 411 Ωστόσο, αν για παράδειγμα μετρούσαμε τη στάθμη των υδάτων στον Ειρηνικό Ωκεανό καθώς μεταβάλλεται με την παλίρροια, θα θέλαμε να αναπαραστήσουμε και αρνητικά μεγέθη σε πόδια και ίντσες. (Η στάθμη της παλίρροιας κάτω από τη μέση κατώτατη στάθμη των υδάτων λέγεται αρνητική παλίρροια, και επιτρέπει στους αλιείς αχιβάδων να εκμεταλλευθούν μεγαλύτερη έκταση της αποστραγγισμένης ακτής.) Ας παραγάγουμε μια νέα κλάση από την Distance. Αυτή η κλάση θα προσθέσει ένα μόνο στοιχείο δεδομένων στις μετρήσεις σε πόδια και ίντσες: ένα πρόσημο που μπορεί να είναι θετικό ή αρνητικό. Αφού προσθέσουμε το πρόσημο, θα χρειαστεί να αλλάξουμε και τις συναρτήσεις-μέλη ώστε να μπορούν να λειτουργήσουν με προσημασμένες αποστάσεις. Ακολουθεί η λίστα του προγράμματος ENGLEN: // englen.cpp // κληρονομικότητα με αποστάσεις σε Αγγλικές μονάδες μέτρησης #include <iostream> using namespace std; enum posneg pos, neg }; //για το πρόσημο στη DistSign //////////////////////////////////////////////////////////////// class Distance //κλάση Distance protected: //ΣΗΜΕΙΩΣΗ: δεν μπορεί να είναι ιδιωτικά int feet; float inches; public: //συνάρτηση δόμησης χωρίς ορίσματα Distance() : feet(0), inches(0.0) } //συνάρτηση δόμησης 2 ορισμάτων Distance(int ft, float in) : feet(ft), inches(in) } void getdist() //λήψη μήκους από το χρήστη cout << "\nenter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; } void showdist() const //εμφάνιση απόστασης cout << feet << "\'-" << inches << '\"'; } }; //////////////////////////////////////////////////////////////// class DistSign : public Distance //προσθήκη προσήμου στη Distance private: posneg sign; //το πρόσημο, ή θετικό ή αρνητικό public: //συνάρτηση δόμησης χωρίς ορίσματα DistSign() : Distance() //κλήση συνάρτησης δόμησης της βασικής κλάσης sign = pos; } //ορισμός προσήμου σε +