Kivételek

A laborokhoz

A laborok mellé minden héten lesz kiírva egy beadandó az admin portálon. Ide óra végén töltsd fel a forráskódokat (*.cpp, *.h)! A feladatokat ezért külön projektben oldd majd meg, ne írd felül a megoldásokat.

Labor otthoni munkában

A labor teljesítéséhez legalább az első két feladatot meg kell oldani.

1. Rejtett komplexitás: a megoldásokat kommentben írd a kód mellé, magyarázatokkal.
2. Kivételek a veremben: a kódot ne add be teszteletlenül! Figyelj arra, hogy a sablon kódnak csak a használt része példányosodik; hívd meg a tesztben mindegyik függvényt! Előbb dolgozatsz egész számokkal, de később próbáld ki a vermet úgy is, hogy „igazi” munkát is végez a beszúrás és a törlés; konstruktorral, destruktorral rendelkező osztállyal példányosítsd a vermet! Lehet ez std::string, vagy az extrák alatt elérhető SuperNoisy.
3. Bináris fa: tesztelj is, mint az előzőnél!

Adott az alábbi kódrészlet. Minden további információ nélkül (csak ezt a részét ismerjük a programnak), a kérdés: a végrehajtása hány különböző vezérlési utat eredményezhet?

String EvaluateSalaryAndReturnName(Employee e) {
    if (e.Title() == "CEO" || e.Salary() > 100000) {
        cout << e.First() << " " << e.Last()
             << " is overpaid" << endl;
    }
    return e.First() + " " + e.Last();
}

A legszembetűnőbb természetesen az if() utasítás: vagy végrehajtódik a kiírás, vagy nem – ez az elágazás eleve két lehetséges végrehajtási utat ad. Hol van a többi lehetséges út, ha nem keletkezik kivétel, és akkor, ha igen?

Adott az alábbi törzzsel rendelkező verem osztály, amelynek teljes kódját töltsd le a feladat megoldásához: stack.cpp!

template <typename T>
class Stack {
  public:
    explicit Stack(size_t max_size);
    Stack(Stack const &orig);
    Stack & operator=(Stack const &orig) = delete;
    ~Stack();
    void push(T const &what);
    T pop();
    bool empty() const;
  private:
    size_t size_;
    size_t max_size_;
    T *pData_;
};

Ez egy régebbi laborfeladat megoldása; egy egyszerű vermet valósít meg, placement new-s memóriakezeléssel, konstruktorban megadott méretű tömbbel.

Figyeld meg kivételkezelés szempontjából a kódot! Haladj sorban a függvényeken, és javítsd ki úgy őket, hogy a hibajelzésre kivételeket használjanak, és kivételek esetén pedig minél erősebb garanciát adjanak a helyes működésre! Vajon mit kell változtatni a...

• Konstruktoron?
  Megoldás

  A mostani változat nem kezeli a memóriafoglalási hibát (malloc() null pointert ad). Ezt kezelni kell a visszaadott érték ellenőrzésével, vagy ::operator new(size_t) használatával. Az utóbbi esetben az összes helyen át kell térni a malloc()/free() párosról az ::operator new()/::operator delete() párosra!

• Másoló konstruktoron?
  Megoldás

  A malloc() mint az előző esetben. Ezen felül, bármelyik T konstruktor kivételt dobhat. A másoló konstruktor megoldható konstruktor delegálással is, a mintamegoldásban egy ilyen verzió is van.

• Destruktoron?
  Megoldás

  Remélhetőleg semmit. A T-k destruktora ne dobjon kivételt.

• A push() függvényen?
  Megoldás

  Először is, ha megtelt a verem, dobjon kivételt, ahelyett, hogy túlírná a foglalt memóriaterületet. Másodszor, a size_ tagváltozót csak azután növeljük meg, miután már sikerült a kapott elemet bemásolni a verembe! Így automatikusan változatlan marad majd a számláló (és ezzel együtt a verem is), ha a T másolása nem sikerült.

• A pop() függvényen? Vigyázat, ez kemény dió.
  Megoldás

  Első körben megcsinálhatjuk ugyanazokat a változtatásokat, mint a push() függvényen. A saved változóba akár mozgathatjuk is az adatot, mivel a következő sorban úgyis a destruktort hívjuk, egy garantáltan sikeres függvényt.

  template <typename T>
  T Stack<T>::pop() {
      if (size_ == 0)
          throw std::length_error("stack ures");
      T saved(std::move(pData_[size_-1]));
      pData_[size_-1].~T();
      size_--;
      return saved;
  }

  Ez nem rossz, de ilyen formán ez csak alap garanciát (basic guarantee) tud adni a hívónak. Miután a tömbből már kitörlődött az adat (a pData_-n belüli példány destruktora lefutott), kezelt elemről még egy másolatot (vagy mozgatott példányt) kell készíteni. Ez lesz a visszatérési érték. Ha ennek a létrehozása nem sikerül a return saved sorban, akkor kivétel fog keletkezni. A verem ilyenkor ugyan konzisztens állapotban van, de a kivett elemet a hívó nem kapja meg.

  Ezt a problémát sajnos lehetetlen megoldani. Nem lehetséges az, hogy a függvény ki is veszi az elemet a veremből, vissza és adja, és közben még erős garanciát is ad a művelet elvégzésére. Úgy lehetséges csak erős garanciát adni, ha két külön függvényt írunk: a top() visszaadja a legfölső elemet (akár referencia szerint), de nem szedi ki a veremből; a pop() eldobja a legfölső elemet, de nem tér vissza vele. Nem véletlen, hogy az std::stack top() és pop() függvénye is ilyen.

• Az empty() függvényen?
  Megoldás

  Semmit, nincs benne kritikus művelet, csak egy int vizsgálata és egy bool visszatérési érték másolása.

• A főprogramon?
  Megoldás

  Kapjuk el a kivételt.

• Mit kell ahhoz csinálni, hogy legyen másoló értékadó operátor?
  Megoldás

  Legegyszerűbb copy-and-swap-et használni, az jól kezeli a kivételeket is.

Adott egy bináris fát megvalósító osztály, az alábbi kódrészlettel:

template <typename T>
class Node {
  private:
    T data;
    Node* left = nullptr;
    Node* right = nullptr;
  public:
    Node(Node const& original) : data(original.data) {
        left = new Node(*original.left);
        right = new Node(*original.right);
    }
};

Mi a probléma ezzel a másoló konstruktorral? Javítsd meg! Írd meg a mozgató konstruktort is, továbbá a kétféle értékadó operátort és a destruktort! Figyelj arra, mikor, milyen kivételek keletkezhetnek!

Node::Node(Node const& original) : data(original.data) {
    if (original.left)
        left = new Node(*original.left);
    try {
        if (original.right)
            right = new Node(*original.right);
    } catch (...) {
        delete left;
        throw;
    }
}

template <typename T>
class Node {
  private:
    T data;
    std::unique_ptr<Node> left, right;
  public:
    Node(Node const& original) : data(original.data) {
        if (original.left)
            left = std::make_unique<Node>(*original.left);
        if (original.right)
            right = std::make_unique<Node>(*original.right);
    }
};

Node::Node(Node && original)
    : data(std::move(original.data))
    , left(std::move(original.left))
    , right(std::move(original.right))
{
}

Node::Node(Node && original) = default;

Lásd a feladatgyűjteményt.

1. GotW #20 – Guru of the Week, #20, Code Complexity - Part I.
2. GotW #66 – Guru of the Week, #66, Constructor Failures
3. GotW #08 – Guru of the Week, #08, Exception Safety