This is an old revision of the document!

Διαχείριση Εξαιρέσεων

Ας εξετάσουμε την κλάση Vector που είδαμε στην ενότητα της υπερφόρτωση τελεστών. Ο προσδιοριστής nothrow σε συνδυασμό με τον τελεστή new μας υποχρεώνει να ελέγξουμε την επιστρεφόμενη τιμή του τελεστή new για να δούμε έαν έχει αποτύχει η διαδικασία δέσμευσης μνήμης ή όχι και στην περίπτωση που έχουμε αποτυχία τερματίζουμε το πρόγραμμα.

Vector.cpp

#include <iostream>
#include <cstdlib>
 
using namespace std;
 
class Vector {
  int *array;
  int size;
 
public:
  Vector(int length=0);
  ~Vector();
  int &valueAt(int pos) const;  // returns a reference to element at position pos
};
 
Vector::Vector(int length) {
  size = length;
  array = new (nothrow) int[size];
  if(array==NULL) {
    cerr << "Memory allocation failure!" << endl;
    exit(-1);
  }
  for(int i=0; i<size; i++)
    array[i] = 0;
}
 
Vector::~Vector() {
  delete [] array;
}
 
int &Vector::valueAt(int pos) const {
  if(pos>=length()) {
     cerr << "Invalid access position!\n";
     return array[size-1];
  }
  return array[pos];
}

Αν και η παραπάνω διαδικασία δεν είναι λανθασμένη, έχει το βασικό μειονέκτημα ότι θα πρέπει να τερματίσουμε το πρόγραμμα, ακόμη και εάν ο λόγος αποτυχίας είναι ότι ο χρήστης της κλάσης επέτρεψε το πέρασμα αρνητικής τιμής ως όρισμα στον κατασκευαστή. Ο λόγος είναι ότι ακόμη και στην περίπτωση που αποτύχει η δέσμευση της μνήμης ο κατασκευαστής της κλάσης Vector επιστρέφει ένα αντικείμενο του οποίου η κατάσταση δεν είναι η αναμενόμενη.

Επειδή, ο χρήστης της κλάσης Vector δεν έχει τρόπο να ελέγξει το “εσωτερικό” του αντικειμένου, υποθέτει πάντα ότι το αντικείμενο που επιστρέφεται είναι σωστό. Σε διαφορετική περίπτωση, ο κατασκευαστής θα πρέπει να τερματίσει το πρόγραμμα.

VectorUse.cpp

#include "Vector.cpp"
 
int main() {
  int size;
  cout << "Enter verctor size: ";
  cin >> size;
  Vector v(size);
  for(int i=0; i<size; i++)
    v.valueAt(i) = 100-1;
}

Η παραγωγή ενός exception μπορεί να επιλύσει πιο αποτελεσματικά το παραπάνω πρόβλημα διότι επιτρέπει την διαχείριση γεγονότων που δεν επιτρέπουν την ομαλή ροή του προγράμματος. Στο παράδειγμα του κατασκευαστή της κλάσης Vector, η αποτυχία κλήσης του τελεστή new (χωρίς τον προσδιοριστή notrhow) παράγει ένα exception τύπου std::bad_alloc, το οποίο μπορούμε να διαχειριστούμε, όπως παρακάτω:

Vector.cpp

#include <iostream>
#include <cstdlib>
 
using namespace std;
 
class Vector {
  int *array;
  int size;
 
public:
  Vector(int length=0);
  ~Vector();
  int &valueAt(int pos) const;  // returns a reference to element at position pos
};
 
Vector::Vector(int length) {
  size = length;
  array = new int[size];
  for(int i=0; i<size; i++)
    array[i] = 0;
}
 
Vector::~Vector() {
  delete [] array;
}
 
int &Vector::valueAt(int pos) const {
  if(pos>=size) {
     cerr << "Invalid access position!\n";
     return array[size-1];
  }
  return array[pos];
}

VectorUse.cpp

#include "Vector.cpp"
 
int main() {
  int size;
  do {
    cout << "Enter verctor size: ";
    cin >> size;
    try {
      Vector v(size);
    } catch(std::bad_alloc ex) {
      cout << "Vector size should be a positive integer! Retry...\n";
      continue;
    }
    for(int i=0; i<size; i++)
    v.valueAt(i) = 100-1;
  } while(size<1);  
}

Αν και στο παραπάνω απλό παράδειγμα είναι προφανές ότι είναι πιο απλό να ελέγξει κανείς το μέγεθος της παραμέτρου size πριν καλέσει τον κατασκευαστή, κάτι τέτοιο είναι δύσκολο να εφαρμοστεί σε όλες τις περιπτώσεις, όπως για παράδειγμα το μέγεθος size παράγεται δυναμικά από το πρόγραμμα και ο κατασκευαστής καλείται σε αρκετά διαφορετικά σημεία του προγράμματος.

Τύποι παραγόμενων εξαιρέσεων

Στη C++ μπορείτε να δημιουργήσετε ένα Exception χρησιμοποιώντας οποιονδήποτε τύπο δεδομένων, δηλαδή δεν απαιτείται τα αντικείμενα που παράγονται να είναι απόγονοι συγκεκριμένης κλάσης. Δείτε μερικά παραδείγματα παραγωγής έγκυρων exceptions παρακάτω:

throw -1;                     // throw an integer value
throw ENUM_INVALID_INDEX;     // throw an enum value
throw "Invalid argument!";    // throw a literal C-style (const char*) string
double pi=3.14159; throw pi;  // throw a double variable that was previously defined
throw MyException("Fatal!");  // Throw an object of class MyException

Δημιουργία και διαχείριση της εξαίρεσης

Όπως σε όλες τις γλώσσες αντικειμενοστραφούς προγραμματισμού η παραγωγή μιας εξαίρεσης θα πρέπει να γίνει μέσα σε ένα try block και η διαχείριση της μέσα σε ένα catch block που ακολουθεί το try block. Δείτε το παρακάτω ενδεικτικό παράδειγμα, όπου ανάλογα με την είσοδο που βάζει ο χρήστης παράγεται διαφορετικού τύπου exception.

ExceptionHandling.cpp

#include <iostream>
using namespace std;
 
class MyException: public std::exception {
public:
  const char* what() const throw() {
    return "Just another std::exception";
  }
};
 
int main() {
  try {
    int option;
    cout << "Enter option (1-5): ";
    cin >> option;
    short int c;
    MyException ex;
    switch(option) {
      case 1:
        throw 10;  // throw an int literal
        break;
      case 2:
        throw 2.5;  //throw a double literal
        break;
      case 3:
        throw "C++"; //throw a char * literal
        break;
      case 4:
        throw string("C++"); //throw a string
        break;
      case 5:
        throw ex; //throw a MyException object
        break;
      default:
        c = -10; throw c;  // throw a character (default option)
        break;
    }
  } catch(int ex) {
    cout << "Got '"<< ex <<"'!\n";
  } catch(double ex) {
    cout << "Got '"<< ex <<"'!\n";
  } catch(const char *ex) {
    cout << "Got char* '"<< ex <<"'!\n";
  } catch(const string &ex) {
    cout << "Got string '"<< ex <<"'!\n";
  } catch(const MyException &ex) {
    cout << "Got '"<< ex.what() <<"'!\n";
  } catch(...) {    // catch any exception not caught above!
    cout << "Got an exception of unknown type!\n";
  }
  cout << "Successfully handled the created exception!\n";
}

Στον παραπάνω κώδικα το catch block

  } catch(...) {     // catch any exception not caught above!
    cout << "Got an exception of unknown type!\n";
  }

πιάνει όλους τους τύπους exception που δεν πιάστηκαν στα προηγούμενα catch blocks. Τοποθετώντας ένα catch block αυτής της μορφής είναι δυνατόν να εφαρμόσετε ένα τελικό έλεγχο για τύπους εξαιρέσεων που δεν έχετε προβλέψει ότι μπορούν να παραχθούν παραπάνω στον κώδικα σας.

Στον παραπάνω κώδικα μπορείτε να παρατηρήσετε τα διαφορετικά μηνύματα που παράγονται ανάλογα με τον τύπο της εξαίρεσης. Παρατηρήστε επίσης ότι αν και παράγεται ένα αντικείμενο τύπου short int, το οποίο χωράει σε ένα int δεν γίνεται κάποια αυτόματη μετατροπή τύπου, ώστε το catch block που πιάνει τύπους int να πιάσει και αντικείμενα τύπου short int.

Κληρονομικότητα εξαιρέσεων

Ας υποθέσουμε ότι έχουμε τη σχέση κληρονομικότητας μεταξύ των κλάσεων BaseException και DerivedException, όπως παρακάτω:

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;
  }
};

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;
  }
};

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;
}

O παραπάνω κώδικας παράγει το παρακάτω warning κατά τη μεταγλώττιση:

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) {
     ^

το οποίο εν συντομία λέει ότι ένα exception τύπου DerivedException θα “πιαστεί” από το 1ο catch block και το 2ο catch block δεν θα λειτουργήσει ποτέ. Το παραπάνω είναι λογικό διότι ένα αντικείμενο της κλάσης DerivedException είναι και BaseException με βάση τις αρχές της κληρονομικότητας.

Εκτελέστε όμως τον παραπάνω κώδικα (παρά το warning) δίνοντας ορίσμα τους αριθμούς 1 και 2. Το αποτέλεσμα είναι το εξής:

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

Παρατηρήστε ότι ενώ στην 2η περίπτωση παράγεται ένα DerivedException το αντικείμενο που τελικά λαμβάνουμε είναι τύπου BaseException. Εδώ θα πρέπει να τονίσουμε ότι η συνάρτηση what() είναι virtual πράγμα που σημαίνει ότι θα πρέπει να καλείται η κατάλληλη έκδοση της συνάρτησης με βάση τον τύπο του αντικειμένου για το οποίο καλείται, ανεξάρτητα από τον τύπο της η οποία δείχνει στο αντικείμενο (δες δυναμικό πολυμορφισμό).

Η απάντηση στο παραπάνω ερώτημα είναι ότι αν και παράγεται ένα αντικείμενο τύπου DerivedException αυτό γίνεται catch από το πρώτο catch block. Μέσα στο catch block το αρχικό αντικείμενο αντιγράφεται σε ένα άλλο αντικείμενο τύπου BaseException, διότι έχουμε κλήση με τιμή στο catch block. Πρακτικά αυτό σημαίνει ότι από το αρχικό αντικείμενο κρατάμε οτιδήποτε ανήκει στην κλάση BaseException και απορρίπτουμε το υπόλοιπο.

Ο τρόπος για να δουλέψει σωστά ο παραπάνω κώδικας είναι μέσα στο catch block να μην περάσουμε το αντικείμενο γιατί δημιουργείται αντίγραφο, αλλά να περάσουμε μία αναφορά σε αυτό, όπως παρακάτω:

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;
}

Πλέον το αποτέλεσμα της εκτέλεσης είναι το αναμενόμενο

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

Το πιάσιμο μιας εξαίρεσης με χρήση αναφοράς για αντικείμενα σύνθετου τύπου (όχι char, int, long, double κλπ), διότι α) αποφεύγουμε την αντιγραφή του αντικειμένου μέσα στο catch block (πιο γρήγορος κώδικας) και β) αποφεύγουμε την “αποκοπή” μέρους του αντικειμένου της εξαίρεσης λόγω του χειρισμού της από ένα catch block βασικότερου τύπου από τον τύπο του αντικειμένου της εξαίρεσης.

Είναι προφανές ότι η σειρά των catch blocks θα έπρεπε να είναι η αντίστροφη (πρώτα το catch block για την αναφορά τύπου DerivedException και στη συνέχεια το catch block για την αναφορά τύπου BasedException. Ο λόγος είναι ότι εάν παραμείνει η σειρά των catch blocks ως έχει το 2o catch block δεν εκτελείται ποτέ.

Stack Unwinding

Κατά την δημιουργία ενός exception μέσα σε μία συνάρτηση ή σε ένα κατασκευαστή δεν είναι απαραίτητο ότι η διαχείριση του exception θα πρέπει να γίνει στην ίδια τη συνάρτηση ή τον καστασκευαστή. Η διαδικασία όνομάζεται stack unwinding και το παράδειγμα που ακολουθεί είναι εξαρειτικά διαφωτιστικό για το πως διαμορφώνεται το stack μετά από την διαχείριση μίας εξαίρεσης σε υψηλότερο επίπεδο.

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;
}

Το αποτέλεσμα που εκτυπώνεται στην οθόνη είναι το εξής:

Start main
Start F
Start FF
Start FFF
Start FFFF
FFFF throwing int literal exception
F caught int exception
End F
End main

H εξέλιξη του program stack στο παρακάτω πρόγραμμα δίνεται στο παρακάτω διάγραμμα. Παρατηρήστε ότι το exception παράγεται στη συνάρτηση FFFF(), αλλά “πιάνεται” στην F() πράγμα που συνεπάγεται την αυτόματη συρρίκνωση του stack στο επίπεδο της συνάρτησης F(). Μετά το “πιάσιμο” του exception, τα περιεχόμενα του stack για τις συναρτήσεις FFF() και FFFF() έχουν χαθεί.

Διαχείριση μίας εξαίρεσης και παραγωγή νέας εξαίρεσης κατά την διαχείριση της

Κάποιες φορές είναι επιθυμητό να διαχειριστούμε μία εξαίρεση προκειμένου να κλείσουμε κάποιο resource, αλλά στη συνέχεια θέλουμε να παράγουμε ξανά την ίδια εξαίρεση προκειμένου η τελική διαχείριση να γίνει παρακάτω. Δείτε το επόμενο απόσπασμα κώδικα από την κλάση PPMImage. Εάν το αρχείο που διαβάζουμε περιέχει κατά λάθος μία αρνητική τιμή θα παραχθεί ένα std::bad_alloc exception. Δεν θέλουμε να το διαχειριστούμε μέσα στον κατασκευαστή, διότι σε αυτή την περίπτωση ο κατασκευαστής θα επιστρέψει κανονικά και ο χρήστης δεν θα έιναι σε θέση να γνωρίζει ότι συνέβη σφάλμα. Παρόλα αυτά, θα θέλαμε να διαχειριστούμε εν μέρη την εξαίρεση στον κατασκευαστή, ώστε να κλείσουμε το ανοιχτό ifstream, αλλά στη συνέχεια να παράγουμε την ίδια εξαίρεση την οποία θα κληθεί η διαχειριστεί η μέθοδος που δημιουργεί το αντικείμενο.

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;
}

Το ενδεικτικό αρχείο εισόδου είναι το παρακάτω:

3x2.ppm

P3
3 -2 255
255 0 0 255 255 0 0 255 255
255 0 255 0 255 0 128 128 128

Από τον παραπάνω κώδικα μπορούμε να συμπεράνουμε τα εξής:

Εφόσον παράγεται ένα exception o δείκτης imgptr μέσα στο catch block της συνάρτησης main έχει την αρχική του τιμή, δηλαδή nullptr. Αυτό είναι λογικό με βάση τις αρχές του stack unwinding που συζητήσαμε προηγούμενα.
Εάν εφαρμόσω τον τελεστή delete σε ένα δείκτη που έχει την τιμή nullptr, δεν παράγεται κάποιου είδους exception, αλλά ο κώδικας συνεχίζει κανονικά.

Ένα 2ο παράδειγμα

Στο προηγούμενο παράδειγμα κάντε την εξής αλλαγή. Αντικαταστήστε το catch block στον κατασκευαστή με το παρακάτω:

    catch(std::exception &ex) {
      cerr << "std::exception occured!\n";
      in.close();
      throw ex;
    }

Το exception std::bad_alloc είναι απόγονος της κλάσης std::exception επομένως ο παραπάνω κώδικας θα πρέπει να δουλεύει σωστά και μετά την αλλαγή. Εν τούτοις παρατηρούμε ότι το πρόγραμμα αποτυγχάνει με ένα μήνυμα της μορφής

$> ./PPMImageSample 3x2.ppm 
std::bad_alloc occured!
terminate called after throwing an instance of 'std::exception'
  what():  std::exception
Aborted (core dumped)

Ο λόγος που συμβαίνει το παραπάνω είναι ότι το όταν το catch block παράγει και πάλι το exception, παράγει ένα αντικείμενο της κλάσης std::exception αποκόπτοντας το τμήμα του αντικειμένου που αφορά την απόγονο κλάση std::bad_alloc. Στη συνέχεια ένα τέτοιο αντικείμενο δεν μπορεί να το “πιάσει” το catch block της συνάρτησης main. Εάν πρέπει να παράγεται το ίδιο exception πράγμα που ήταν αρχικά επιθυμητό ο κώδικας στο catch block του κατασκευαστή θα πρέπει να γραφεί όπως παρακάτω, ώστε να παράγει ως exception το ίδιο αντικείμενο που έγινε catch.

    catch(std::exception &ex) {
      cerr << "std::exception occured!\n";
      in.close();
      throw;       // rethrows the same exception object
    }

Δήλωση των εξαιρέσεων που παράγουν οι συναρτήσεις (exception specifiers)

Κατά τη δήλωση μίας συνάρτησης είναι δυνατόν να ορίσετε εάν αυτή μπορεί να παράγει κάποιου είδους exception. Υπάρχουν 3 διαφορετικού τύποι ορισμών οι οποίοι δίνονται παρακάτω:

int functionName() throw(): Ο συγκεκριμένος ορισμός δηλώνει ότι δεν παράγεται καμία εξαίρεση.
int functionName() throw(std::bad_alloc): Ο συγκεκριμένος ορισμός δηλώνει ότι μπορεί να παραχθεί μία εξαίρεση τύπου std::bad_alloc.
int functionName() throw(…): Ο συγκεκριμένος ορισμός δηλώνει ότι μπορεί να παραχθεί οποιουδήποτε τύπου εξαίρεση.

Τους παραπάνω ορισμούς είναι δυνατόν να τους συναντήσετε στις standard βιβλιοθήκες της C++. Δεν είναι όμως ευρέως χρησιμοποιούμενοι και η υποστήριξη τους από τους C++ compilers είναι συχνά ελλειπής. Δεν συνιστάται η χρήση τους σε κώδικα που γράφετε εσείς, λόγω της ελλειπούς υποστήριξης από την κοινότητα της C++.

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

Table of Contents