Αντικειμενοστραφής Προγραμματισμός

User Tools

Site Tools

Trace:
cpp:exception

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Next revisionBoth sides next revision
cpp:exception [2018/05/21 02:00] – [Ένα 2ο παράδειγμα] gthanoscpp:exception [2019/05/06 07:19] – [Stack Unwinding] gthanos
Line 1: Line 1:
-====== Διαχείριση Εξαιρέσεων ======+====== Δημιουργία & Διαχείριση Εξαιρέσεων ======
  
-Ας εξετάσουμε την κλάση **Vector** που είδαμε στην υπερφόρτωση των τελεστών. Ο προσδιοριστής //nothrow// σε συνδυασμό με τον τελεστή **new** μας υποχρεώνει να ελέγξουμε την επιστρεφόμενη τιμή του τελεστή **new** για να δούμε έαν έχει αποτύχει η διαδικασία δέσμευσης μνήμης ή όχι και στην περίπτωση που έχουμε αποτυχία τερματίζουμε το πρόγραμμα. +Ας εξετάσουμε την κλάση **Vector** που είδαμε στην ενότητα της υπερφόρτωση τελεστών. Ο προσδιοριστής //nothrow// σε συνδυασμό με τον τελεστή **new** μας υποχρεώνει να ελέγξουμε την επιστρεφόμενη τιμή του τελεστή **new** για να δούμε έαν έχει αποτύχει η διαδικασία δέσμευσης μνήμης ή όχι και στην περίπτωση που έχουμε αποτυχία τερματίζουμε το πρόγραμμα. 
  
 <code cpp Vector.cpp> <code cpp Vector.cpp>
Line 43: Line 43:
 </code> </code>
  
-Αν και η παραπάνω διαδικασία δεν είναι λανθασμένη, έχει το βασικό μειονέκτημα ότι θα πρέπει να τερματίσουμε το πρόγραμμα, ακόμη και εάν ο λόγος αποτυχίας είναι ότι ο χρήστης της κλάσης επέτρεψε το πέρασμα αρνητικής τιμής ως όρισμα στον κατασκευαστή.+Αν και η παραπάνω διαδικασία δεν είναι λανθασμένη, έχει το βασικό μειονέκτημα ότι θα πρέπει να τερματίσουμε το πρόγραμμα, ακόμη και εάν ο λόγος αποτυχίας είναι ότι ο χρήστης της κλάσης επέτρεψε το πέρασμα αρνητικής τιμής ως όρισμα στον κατασκευαστή. Ο λόγος είναι ότι στην περίπτωση που αποτύχει η δέσμευση της μνήμης, λόγω λανθασμένου ορίσματος, ο κατασκευαστής της κλάσης **Vector** επιστρέφει ένα αντικείμενο το οποίο δεν είναι σωστά αρχικοποιημένο.
  
 <code cpp VectorUse.cpp> <code cpp VectorUse.cpp>
Line 58: Line 58:
 </code> </code>
  
-Η παραγωγή ενός exception μπορεί να επιλύσει πιο αποτελεσματικά το παραπάνω πρόβλημα διότι επιτρέπει την διαχείριση γεγονότων που δεν επιτρέπουν την ομαλή ροή του προγράμματος. Στο παράδειγμα του κατασκευαστή της κλάσης **Vector**, η αποτυχία κλήσης του τελεστή **new** (χωρίς τον προσδιοριστή //notrhow//) παράγει ένα //exception// τύπου [[http://www.cplusplus.com/reference/new/bad_alloc/|std::bad_alloc]], το οποίο μπορούμε να διαχειριστούμε, όπως παρακάτω:+Η παραγωγή ενός //exception// μπορεί να επιλύσει πιο αποτελεσματικά το παραπάνω πρόβλημα, διότι υποστηρίζει τη διαχείριση συμβάντων που δεν επιτρέπουν την ομαλή εκτέλεση του προγράμματος. Στο παράδειγμα του κατασκευαστή της κλάσης **Vector**, η αποτυχία κλήσης του τελεστή **new** (χωρίς τον προσδιοριστή //notrhow//) παράγει ένα //exception// τύπου [[http://www.cplusplus.com/reference/new/bad_alloc/|std::bad_alloc]], το οποίο μπορούμε να διαχειριστούμε στη μέθοδο //main//, όπως παρακάτω:
  
 <code cpp Vector.cpp> <code cpp Vector.cpp>
Line 78: Line 78:
 Vector::Vector(int length) { Vector::Vector(int length) {
   size = length;   size = length;
-  array = new (nothrow) int[size];+  array = new int[size];
   for(int i=0; i<size; i++)   for(int i=0; i<size; i++)
     array[i] = 0;     array[i] = 0;
Line 117: Line 117:
  
 <WRAP tip 80% center round> <WRAP tip 80% center round>
-Αν και στο παραπάνω απλό παράδειγμα είναι προφανές ότι είναι πιο απλό να ελέγξει κανείς το μέγεθος της παραμέτρου size πριν καλέσει τον κατασκευαστή, κάτι τέτοιο είναι δύσκολο να εφαρμοστεί σε όλες τις περιπτώσεις, όπως για παράδειγμα το μέγεθος **size** παράγεται δυναμικά από το πρόγραμμα και ο κατασκευαστής καλείται σε αρκετά διαφορετικά σημεία του προγράμματος.+Στο παραπάνω απλό παράδειγμα είναι προφανές ότι είναι πιο απλό να ελέγξει κανείς το μέγεθος της παραμέτρου //size// πριν καλέσει τον κατασκευαστή. Σε αυτή την περίπτωση, ο έλεγχος θα πρέπει να γίνεται από το χρήστη της εκάστοτε βιβλιοθήκης, ενώ η βιβλιοθήκη δεν παρέχει καμία εγγύηση για τον τρόπο συμπεριφοράς της εάν περαστούν λανθασμένα ορίσματα. Τα //exceptions// εξασφαλίζουν ότι η βιβλιοθήκη θα παράξει μία εξαίρεση εάν η δέσμευση της μνήμης αποτύχει.
 </WRAP> </WRAP>
 ===== Τύποι παραγόμενων εξαιρέσεων ===== ===== Τύποι παραγόμενων εξαιρέσεων =====
Line 164: Line 164:
         break;         break;
       case 4:       case 4:
-        throw string("C++"); //throw a string+        throw string("C++"); //throw a std::string
         break;         break;
       case 5:       case 5:
Line 170: Line 170:
         break;         break;
       default:       default:
-        c = -10; throw c;  // throw a character (default option)+        c = -10; throw c;  // throw a character
         break;         break;
     }     }
Line 204: Line 204:
 </WRAP> </WRAP>
  
-===== Κληρονομικότητα ===== 
  
-Ας υποθέσουμε ότι έχουμε τη σχέση κληρονομικότητας μεταξύ των κλάσεων **BaseException** και **DerivedException**, όπως παρακάτω: 
  
-<code cpp BaseException.h> +===== Διαχείριση μίας εξαίρεσης και παραγωγή νέας εξαίρεσης κατά την διαχείριση της =====
-using namespace std; +
- +
-class BaseException: public std::exception { +
-protected: +
-  int a; +
-public: +
-  BaseException(int a) { this->a = a; } +
-  const char* what() const throw() { +
-    //char s[64]; +
-    char *s = new char [64]; +
-    sprintf(s, "BaseException, a: %d\n", a); +
-    return s; +
-  } +
-}; +
-</code> +
- +
-<code cpp DerivedException.h> +
-#include "BaseException.h" +
-using namespace std; +
- +
-class DerivedException: public BaseException { +
-  int b; +
-public: +
-  DerivedException(int a, int b): BaseException(a) { this->b = b; } +
-  const char* what() const throw() { +
-    char *s = new char [64]; +
-    sprintf(s, "DerivedException, a: %d, b: %d\n", a, b); +
-    return s; +
-  } +
-}; +
-</code> +
- +
-<code cpp ExceptionUse.cpp> +
-#include <iostream> +
-#include "DerivedException.h" +
-using namespace std; +
- +
-int main() { +
-  try { +
-    int option; +
-    cout << "Enter option (1-2): "; +
-    cin >> option; +
-    BaseException bex(-2); +
-    DerivedException dex(4,5); +
-    switch(option) { +
-      case 1: +
-        throw bex; +
-        break; +
-      case 2: +
-        throw dex; +
-        break; +
-    } +
-  } catch(BaseException ex) { +
-    cout << ex.what(); +
-  } catch(DerivedException ex) { +
-    cout << ex.what(); +
-  } +
-  return 0; +
-} +
-</code> +
- +
-O παραπάνω κώδικας παράγει το παρακάτω //warning// κατά τη μεταγλώττιση: +
-<code> +
-ExceptionUse.cpp:22:5: warning: exception of type ‘DerivedException’ will be caught +
-   } catch(DerivedException &ex) { +
-     ^ +
-ExceptionUse.cpp:20:5: warning:    by earlier handler for ‘BaseException’ +
-   } catch(BaseException &ex) { +
-     ^ +
-</code> +
- +
-το οποίο εν συντομία λέει ότι ένα exception τύπου //DerivedException// θα "πιαστεί" από το 1ο //catch block// και το 2ο //catch block// δεν θα λειτουργήσει ποτέ. Το παραπάνω είναι λογικό διότι ένα αντικείμενο της κλάσης //DerivedException// είναι και //BaseException// με βάση τις αρχές της κληρονομικότητας. +
- +
-Εκτελέστε όμως τον παραπάνω κώδικα (παρά το warning) δίνοντας ορίσμα τους αριθμούς 1 και 2. Το αποτέλεσμα είναι το εξής: +
-<code> +
-gthanos@gthanos-DESKTOP:~/Downloads/C++$ ./ExceptionUse  +
-Enter option (1-2): 1 +
-BaseException, a: -2 +
-gthanos@gthanos-DESKTOP:~/Downloads/C++$ ./ExceptionUse  +
-Enter option (1-2): 2 +
-BaseException, a: 4 +
-</code> +
- +
-Παρατηρήστε ότι ενώ στην 2η περίπτωση παράγεται ένα //DerivedException// το αντικείμενο που τελικά λαμβάνουμε είναι τύπου //BaseException//. Εδώ θα πρέπει να τονίσουμε ότι η συνάρτηση //what()// είναι //virtual// πράγμα που σημαίνει ότι θα πρέπει να καλείται η κατάλληλη έκδοση της συνάρτησης με βάση τον τύπο του αντικειμένου για το οποίο καλείται, ανεξάρτητα από τον τύπο της η οποία δείχνει στο αντικείμενο (δες [[cpp:polymorphism|δυναμικό πολυμορφισμό]]). +
- +
-Η απάντηση στο παραπάνω ερώτημα είναι ότι αν και παράγεται ένα αντικείμενο τύπου //DerivedException// αυτό γίνεται //catch// από το πρώτο //catch block//. Μέσα στο //catch block// το αρχικό αντικείμενο αντιγράφεται σε ένα άλλο αντικείμενο τύπου //BaseException//, διότι έχουμε κλήση με τιμή στο //catch block//. Πρακτικά αυτό σημαίνει ότι από το αρχικό αντικείμενο κρατάμε οτιδήποτε ανήκει στην κλάση //BaseException// και απορρίπτουμε το υπόλοιπο. +
- +
-Ο τρόπος για να δουλέψει σωστά ο παραπάνω κώδικας είναι μέσα στο //catch block// να μην περάσουμε το αντικείμενο γιατί δημιουργείται αντίγραφο, αλλά να περάσουμε μία αναφορά σε αυτό, όπως παρακάτω: +
- +
-<code cpp ExceptionUse.cpp> +
-#include <iostream> +
-#include "DerivedException.h" +
-using namespace std; +
- +
-int main() { +
-  try { +
-    int option; +
-    cout << "Enter option (1-2): "; +
-    cin >> option; +
-    BaseException bex(-2); +
-    DerivedException dex(4,5); +
-    switch(option) { +
-      case 1: +
-        throw bex; +
-        break; +
-      case 2: +
-        throw dex; +
-        break; +
-    } +
-  } catch(BaseException &ex) { +
-    cout << ex.what(); +
-  } catch(DerivedException &ex) { +
-    cout << ex.what(); +
-  } +
-  return 0; +
-} +
-</code> +
- +
-Πλέον το αποτέλεσμα της εκτέλεσης είναι το αναμενόμενο +
-<code> +
-gthanos@gthanos-DESKTOP:~/Downloads/C++$ ./ExceptionUse  +
-Enter option (1-2): 1 +
-BaseException, a: -2 +
-gthanos@gthanos-DESKTOP:~/Downloads/C++$ ./ExceptionUse  +
-Enter option (1-2): 2 +
-DerivedException, a: 4, b: 5 +
-</code> +
- +
-<WRAP tip 80% center round> +
-Το πιάσιμο μιας εξαίρεσης με χρήση αναφοράς για αντικείμενα σύνθετους τύπου (όχ char, int, long, double κλπ), διότι //α)// αποφεύγουμε την αντιγραφή του αντικειμένου μέσα στο //catch block// (πιο γρήγορος κώδικας) και //β)// αποφεύγουμε την "αποκοπή" μέρους του αντικειμένου που γίνεται //throw// λόγω του "πιασίματος" της εξαίρεσης από ένα //catch block// βασικότερου τύπου από τον τύπο που γίνεται //throw//. +
-</WRAP> +
- +
-<WRAP tip 80% center round> +
-Είναι προφανές ότι η σειρά των //catch blocks// θα έπρεπε να είναι η αντίστροφη (πρώτα το //catch block// για την αναφορά τύπου //DerivedException// και στη συνέχεια το //catch block// για την αναφορά τύπου //BasedException//. Ο λόγος είναι ότι εάν παραμείνει η σειρά των //catch blocks// ως έχει το 2o catch block δεν εκτελείται ποτέ. +
-</WRAP> +
-===== Stack Unwinding ===== +
- +
-Κατά την δημιουργία ενός //exception// μέσα σε μία συνάρτηση ή σε ένα κατασκευαστή δεν είναι απαραίτητο ότι η διαχείριση του //exception// θα πρέπει να γίνει στην ίδια τη συνάρτηση ή τον καστασκευαστή. Η διαδικασία όνομάζεται //stack unwinding// και το παράδειγμα που ακολουθεί είναι εξαρειτικά διαφωτιστικό για το πως διαμορφώνεται το stack μετά από την διαχείριση μίας εξαίρεσης σε υψηλότερο επίπεδο. +
- +
-<code cpp StackUnwinding.cpp> +
-#include <iostream> +
-// called by FFF() +
-void FFFF() { +
-  std::cout << "Start FFFF\n"; +
-  std::cout << "FFFF throwing int literal exception\n"; +
-  throw 100; +
-  std::cout << "End FFFF\n"; +
-  +
-} +
-// called by FF()  +
-void FFF() { +
-  std::cout << "Start FFF\n"; +
-  FFFF(); +
-  std::cout << "End FFF\n"; +
-} +
-// called by F() +
-void FF() { +
-  std::cout << "Start FF\n"; +
-  try { +
-    FFF(); +
-  } catch(char) {  +
-    std::cerr << "FF caught double exception\n"; +
-  } +
-  std::cout << "End FF\n"; +
-} +
-// called by main() +
-void F() { +
-  std::cout << "Start F\n"; +
-  try { +
-    FF(); +
-  } catch (int) { +
-     std::cerr << "F caught int exception\n"; +
-  } catch (char) { +
-     std::cerr << "F caught double exception\n"; +
-  } +
-  std::cout << "End F\n"; +
-} +
-  +
-int main() { +
-  std::cout << "Start main\n"; +
-  try { +
-    F(); +
-  } catch (int) { +
-    std::cerr << "main caught int exception\n"; +
-  } +
-  std::cout << "End main\n";  +
-  return 0; +
-} +
-</code> +
- +
-Το αποτέλεσμα που εκτυπώνεται στην οθόνη είναι το εξής: +
-<code> +
-Start main +
-Start F +
-Start FF +
-Start FFF +
-Start FFFF +
-FFFF throwing int literal exception +
-F caught int exception +
-End F +
-End main +
-</code> +
- +
-H εξέλιξη του //program stack// στο παρακάτω πρόγραμμα δίνεται στο παρακάτω διάγραμμα. Παρατηρήστε ότι το exception παράγεται στη συνάρτηση **FFFF()**, αλλά "πιάνεται" στην **F()** πράγμα που συνεπάγεται την αυτόματη συρρίκνωση του //stack// στο επίπεδο της συνάρτησης **F()**. Μετά το "πιάσιμο" του //exception//, τα περιεχόμενα του //stack// για τις συναρτήσεις **FFF()** και **FFFF()** έχουν χαθεί. +
- +
-{{ :cpp:stack_unwinding.png |}} +
- +
-===== Διαχείριση μίας εξαίρεσης και παραγωγή μίας νέας εξαίρεσης κατά την διαχείριση =====+
  
 Κάποιες φορές είναι επιθυμητό να διαχειριστούμε μία εξαίρεση προκειμένου να κλείσουμε κάποιο //resource//, αλλά στη συνέχεια θέλουμε να παράγουμε ξανά την ίδια εξαίρεση προκειμένου η τελική διαχείριση να γίνει παρακάτω. Δείτε το επόμενο απόσπασμα κώδικα από την κλάση PPMImage. Εάν το αρχείο που διαβάζουμε περιέχει κατά λάθος μία αρνητική τιμή θα παραχθεί ένα //std::bad_alloc exception//. Δεν θέλουμε να το διαχειριστούμε μέσα στον κατασκευαστή, διότι σε αυτή την περίπτωση ο κατασκευαστής θα επιστρέψει κανονικά και ο χρήστης δεν θα έιναι σε θέση να γνωρίζει ότι συνέβη σφάλμα. Παρόλα αυτά, θα θέλαμε να διαχειριστούμε εν μέρη την εξαίρεση στον κατασκευαστή, ώστε να κλείσουμε το ανοιχτό //ifstream//, αλλά στη συνέχεια να παράγουμε την ίδια εξαίρεση την οποία θα κληθεί η διαχειριστεί η μέθοδος που δημιουργεί το αντικείμενο. Κάποιες φορές είναι επιθυμητό να διαχειριστούμε μία εξαίρεση προκειμένου να κλείσουμε κάποιο //resource//, αλλά στη συνέχεια θέλουμε να παράγουμε ξανά την ίδια εξαίρεση προκειμένου η τελική διαχείριση να γίνει παρακάτω. Δείτε το επόμενο απόσπασμα κώδικα από την κλάση PPMImage. Εάν το αρχείο που διαβάζουμε περιέχει κατά λάθος μία αρνητική τιμή θα παραχθεί ένα //std::bad_alloc exception//. Δεν θέλουμε να το διαχειριστούμε μέσα στον κατασκευαστή, διότι σε αυτή την περίπτωση ο κατασκευαστής θα επιστρέψει κανονικά και ο χρήστης δεν θα έιναι σε θέση να γνωρίζει ότι συνέβη σφάλμα. Παρόλα αυτά, θα θέλαμε να διαχειριστούμε εν μέρη την εξαίρεση στον κατασκευαστή, ώστε να κλείσουμε το ανοιχτό //ifstream//, αλλά στη συνέχεια να παράγουμε την ίδια εξαίρεση την οποία θα κληθεί η διαχειριστεί η μέθοδος που δημιουργεί το αντικείμενο.
Line 551: Line 341:
       cerr << "std::exception occured!\n";       cerr << "std::exception occured!\n";
       in.close();       in.close();
-      throw ex;       // rethrows the same exception object+      throw;       // rethrows the same exception object
     }     }
 </code> </code>
Line 563: Line 353:
 Τους παραπάνω ορισμούς είναι δυνατόν να τους συναντήσετε στις //standard// βιβλιοθήκες της C++. Δεν είναι όμως ευρέως χρησιμοποιούμενοι και η υποστήριξη τους από τους C++ //compilers// είναι συχνά ελλειπής. Δεν συνιστάται η χρήση τους σε κώδικα που γράφετε εσείς, λόγω της ελλειπούς υποστήριξης από την κοινότητα της C++. Τους παραπάνω ορισμούς είναι δυνατόν να τους συναντήσετε στις //standard// βιβλιοθήκες της C++. Δεν είναι όμως ευρέως χρησιμοποιούμενοι και η υποστήριξη τους από τους C++ //compilers// είναι συχνά ελλειπής. Δεν συνιστάται η χρήση τους σε κώδικα που γράφετε εσείς, λόγω της ελλειπούς υποστήριξης από την κοινότητα της C++.
  
 +/*
 ===== Function try blocks ===== ===== Function try blocks =====
- +*/
-===== Η κλάση std::exception =====+
  
  
cpp/exception.txt · Last modified: 2023/05/15 14:01 by gthanos