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

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/19 04:00] – [Stack Unwinding] gthanoscpp:exception [2018/05/21 01:49] – [Διαχείριση μίας εξαίρεσης και παραγωγή μίας νέας εξαίρεσης κατά την διαχείριση] gthanos
Line 133: Line 133:
 ===== Δημιουργία και διαχείριση της εξαίρεσης ===== ===== Δημιουργία και διαχείριση της εξαίρεσης =====
  
-Όπως σε όλες τις γλώσσες αντικειμενοστραφούς προγραμματισμού η παραγωγή μιας εξαίρεσης θα πρέπει να γίνει μέσα σε ένα //try block// και η διαχείριση της μέσα σε ένα //catch block// που ακολουθεί το //try block//. Δείτε το παρακάτω ενδεικτικό παράδειγμα.+Όπως σε όλες τις γλώσσες αντικειμενοστραφούς προγραμματισμού η παραγωγή μιας εξαίρεσης θα πρέπει να γίνει μέσα σε ένα //try block// και η διαχείριση της μέσα σε ένα //catch block// που ακολουθεί το //try block//. Δείτε το παρακάτω ενδεικτικό παράδειγμα, όπου ανάλογα με την είσοδο που βάζει ο χρήστης παράγεται διαφορετικού τύπου //exception//. 
  
 <code cpp ExceptionHandling.cpp> <code cpp ExceptionHandling.cpp>
Line 183: Line 183:
   } catch(const MyException &ex) {   } catch(const MyException &ex) {
     cout << "Got '"<< ex.what() <<"'!\n";     cout << "Got '"<< ex.what() <<"'!\n";
-  } catch(...) {+  } catch(...) {    // catch any exception not caught above!
     cout << "Got an exception of unknown type!\n";     cout << "Got an exception of unknown type!\n";
   }   }
Line 189: Line 189:
 } }
 </code> </code>
 +
 +<WRAP info 80% center round>
 +Στον παραπάνω κώδικα το //catch block//
 +<code cpp>
 +  } catch(...) {     // catch any exception not caught above!
 +    cout << "Got an exception of unknown type!\n";
 +  }
 +</code>
 +πιάνει όλους τους τύπους //exception// που δεν πιάστηκαν στα προηγούμενα //catch blocks//. Τοποθετώντας ένα //catch block// αυτής της μορφής είναι δυνατόν να εφαρμόσετε ένα τελικό έλεγχο για τύπους εξαιρέσεων που δεν έχετε προβλέψει ότι μπορούν να παραχθούν παραπάνω στον κώδικα σας.
 +</WRAP>
  
 <WRAP tip 80% center round> <WRAP tip 80% center round>
Line 196: Line 206:
 ===== Κληρονομικότητα ===== ===== Κληρονομικότητα =====
  
-Ας υποθέσουμε ότι έχουμε τη σχέση κληρονομικότητας μεταξύ των κλάσεων **IDException** και **CountedIDException**, όπως παρακάτω:+Ας υποθέσουμε ότι έχουμε τη σχέση κληρονομικότητας μεταξύ των κλάσεων **BaseException** και **DerivedException**, όπως παρακάτω:
  
 <code cpp BaseException.h> <code cpp BaseException.h>
Line 331: Line 341:
 </WRAP> </WRAP>
  
 +<WRAP tip 80% center round>
 +Είναι προφανές ότι η σειρά των //catch blocks// θα έπρεπε να είναι η αντίστροφη (πρώτα το //catch block// για την αναφορά τύπου //DerivedException// και στη συνέχεια το //catch block// για την αναφορά τύπου //BasedException//. Ο λόγος είναι ότι εάν παραμείνει η σειρά των //catch blocks// ως έχει το 2o catch block δεν εκτελείται ποτέ.
 +</WRAP>
 ===== Stack Unwinding ===== ===== Stack Unwinding =====
  
Line 399: Line 412:
 </code> </code>
  
-H εξέλιξη του //program stack// στο παρακάτω πρόγραμμα δίνεται στο παρακάτω διάγραμμα. Παρατηρήστε ότι το exception παράγεται στη συνάρτηση **FFFF()**, αλλά πιάνεται στην **F()** πράγμα που συνεπάγεται την αυτόματη συρρίκνωση του //stack// στο επίπεδο της συνάρτησης **F()**. Τα περιεχόμενα του //stack// για τις συναρτήσεις **FFF()** και **FFFF()** έχουν χαθεί.+H εξέλιξη του //program stack// στο παρακάτω πρόγραμμα δίνεται στο παρακάτω διάγραμμα. Παρατηρήστε ότι το exception παράγεται στη συνάρτηση **FFFF()**, αλλά "πιάνεται" στην **F()** πράγμα που συνεπάγεται την αυτόματη συρρίκνωση του //stack// στο επίπεδο της συνάρτησης **F()**. Μετά το "πιάσιμο" του //exception//, τα περιεχόμενα του //stack// για τις συναρτήσεις **FFF()** και **FFFF()** έχουν χαθεί.
  
 {{ :cpp:stack_unwinding.png |}} {{ :cpp:stack_unwinding.png |}}
 +
 +===== Διαχείριση μίας εξαίρεσης και παραγωγή μίας νέας εξαίρεσης κατά την διαχείριση =====
 +
 +Κάποιες φορές είναι επιθυμητό να διαχειριστούμε μία εξαίρεση προκειμένου να κλείσουμε κάποιο //resource//, αλλά στη συνέχεια θέλουμε να παράγουμε ξανά την ίδια εξαίρεση προκειμένου η τελική διαχείριση να γίνει παρακάτω. Δείτε το επόμενο απόσπασμα κώδικα από την κλάση PPMImage. Εάν το αρχείο που διαβάζουμε περιέχει κατά λάθος μία αρνητική τιμή θα παραχθεί ένα //std::bad_alloc exception//. Δεν θέλουμε να το διαχειριστούμε μέσα στον κατασκευαστή, διότι σε αυτή την περίπτωση ο κατασκευαστής θα επιστρέψει κανονικά και ο χρήστης δεν θα έιναι σε θέση να γνωρίζει ότι συνέβη σφάλμα. Παρόλα αυτά, θα θέλαμε να διαχειριστούμε εν μέρη την εξαίρεση στον κατασκευαστή, ώστε να κλείσουμε το ανοιχτό //ifstream//, αλλά στη συνέχεια να παράγουμε την ίδια εξαίρεση την οποία θα κληθεί η διαχειριστεί η μέθοδος που δημιουργεί το αντικείμενο.
 +
 +<code cpp PPMImageSample.cpp>
 +#include <iostream>
 +#include <fstream>
 +#include <ios>
 +#include <cstdlib>
 +
 +using namespace std;
 +
 +class PPMImage {
 +  int width, height, colordepth;
 +  int **raster;
 +public:
 +  PPMImage(char *filename) {
 +    string str;
 +    unsigned char red, green, blue;
 +    ifstream in(filename);
 +    if(!in.is_open()) {
 +      std::ios_base::failure fex("File not found!");
 +      throw fex;
 +    }
 +    try {
 +      in >> str;
 +      in >> str;
 +      width = atoi(str.c_str());
 +      in >> str;
 +      height = atoi(str.c_str());
 +      in >> str;
 +      colordepth = atoi(str.c_str());
 +      raster = new int*[height];
 +      for(int row=0; row<height; row++)
 +        raster[row] = new int[width];
 +      for(int row=0; row<height; row++) {
 +        for(int col=0; col<width; col++) {
 +          cin >> str;
 +          red = (unsigned char) atoi(str.c_str());
 +          cin >> str;
 +          green = (unsigned char) atoi(str.c_str());
 +          cin >> str;
 +          blue = (unsigned char) atoi(str.c_str());
 +          raster[row][col] = 0;
 +          raster[row][col] = (red << 16) | (green << 8) | blue;
 +        }
 +      }
 +    }
 +    catch(std::bad_alloc &ex) {
 +      cerr << "std::bad_alloc occured!\n";
 +      in.close();
 +      throw ex;
 +    }
 +  }
 +  
 +  ~PPMImage() {
 +    for(int row=0; row<height; row++)
 +      delete raster[row];
 +    delete raster;
 +  }
 +  
 +  int **getRaster() { return raster; }
 +  
 +};
 +
 +int main(int argc, char *argv[]) {
 +  PPMImage *imgptr=nullptr;
 +  try{
 +    imgptr = new PPMImage(argv[1]);
 +  }
 +  catch(ios_base::failure &fex) {
 +    cerr << "File '" << argv[0] << "' was not found!\n";
 +  }
 +  catch(bad_alloc &ex) {
 +    cerr << "Memory allocation failure!\n";
 +    if (imgptr!=nullptr) {
 +      cerr << "imgptr != nullptr\n";
 +      if(imgptr->getRaster() != nullptr) {
 +        cerr << "imgptr->getRaster() != nullptr\n";
 +        delete imgptr->getRaster();
 +      }
 +      else {
 +        cerr << "imgptr->getRaster() == nullptr\n";
 +      }
 +      delete imgptr;
 +    }
 +    else {
 +      cerr << "imgptr == nullptr\n";
 +    }
 +  }
 +  delete imgptr;
 +  return 0;
 +}
 +</code>
 +
 +Το ενδεικτικό αρχείο εισόδου είναι το παρακάτω:
 +
 +<code cpp 3x2.ppm>
 +P3
 +3 -2 255
 +255 0 0 255 255 0 0 255 255
 +255 0 255 0 255 0 128 128 128
 +</code>
 +
 +Από τον παραπάνω κώδικα μπορούμε να συμπεράνουμε τα εξής:
 +  - Εφόσον παράγεται ένα //exception// o δείκτης //imgptr// μέσα στο //catch block// της συνάρτησης //main// έχει την αρχική του τιμή, δηλαδή **nullptr**. Αυτό είναι λογικό με βάση τις αρχές του //stack unwinding// που συζητήσαμε προηγούμενα.
 +  - Εάν εφαρμόσω τον τελεστή **delete** σε ένα δείκτη που έχει την τιμή **nullptr**, δεν παράγεται κάποιου είδους //exception//, αλλά ο κώδικας συνεχίζει κανονικά.
 +
 +==== Ένα 2ο παράδειγμα ====
 +
 +Στο προηγούμενο παράδειγμα κάντε την εξής αλλαγή. Αντικαταστήστε το //catch block// στον κατασκευαστή με το παρακάτω:
 +
 +<code cpp>
 +    catch(std::exception &ex) {
 +      cerr << "std::exception occured!\n";
 +      in.close();
 +      throw ex;
 +    }
 +</code>
 +
 +Το //exception std::bad_alloc// είναι απόγονος της κλάσης //std::exception// επομένως ο παραπάνω κώδικας θα πρέπει να δουλεύει σωστά και μετά την αλλαγή. Εν τούτοις παρατηρούμε ότι το πρόγραμμα αποτυγχάνει με ένα μήνυμα της μορφής
 +<code 
 +===== Δήλωση των εξαιρέσεων που παράγουν οι συναρτήσεις (exception specifiers) =====
 +
 +Κατά τη δήλωση μίας συνάρτησης είναι δυνατόν να ορίσετε εάν αυτή μπορεί να παράγει κάποιου είδους //exception//. Υπάρχουν 3 διαφορετικού τύποι ορισμών οι οποίοι δίνονται παρακάτω:
 +  - ''int functionName() throw()'': Ο συγκεκριμένος ορισμός δηλώνει ότι δεν παράγεται καμία εξαίρεση.
 +  - ''int functionName() throw(std::bad_alloc)'': Ο συγκεκριμένος ορισμός δηλώνει ότι μπορεί να παραχθεί μία εξαίρεση τύπου [[http://en.cppreference.com/w/cpp/memory/new/bad_alloc|std::bad_alloc]].
 +  - ''int functionName() throw(...)'': Ο συγκεκριμένος ορισμός δηλώνει ότι μπορεί να παραχθεί οποιουδήποτε τύπου εξαίρεση.
 +
 +Τους παραπάνω ορισμούς είναι δυνατόν να τους συναντήσετε στις //standard// βιβλιοθήκες της C++. Δεν είναι όμως ευρέως χρησιμοποιούμενοι και η υποστήριξη τους από τους C++ //compilers// είναι συχνά ελλειπής. Δεν συνιστάται η χρήση τους σε κώδικα που γράφετε εσείς, λόγω της ελλειπούς υποστήριξης από την κοινότητα της C++.
 +
 +===== Function try blocks =====
 +
 +===== Η κλάση std::exception =====
 +
 +
 +
 +
  
  
  
  
cpp/exception.txt · Last modified: 2023/05/15 14:01 by gthanos