spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// dtor is virtual, deleten möglich
FooException* foo_ptr = new FooException (1, "1 error");
FooBaseException* foo_base_ptr = dynamic_cast<FooException*>(foo_ptr); // or boost::..._downcast
delete foo_base_ptr;

// dtor ist protected non-virtual, deleten nicht möglich
//Foo* foo_ptr = new FooException (1, "1 error");
//Master* master_ptr = static_cast<Master*>(foo_ptr);
//delete master_ptr;

C-/C++-Quelltext

// nicht abstract, nix virtuales
class Master {
    protected:
    // attrs

    // wird von anderen Klasse geerbt, dtor deklarieren
    ~Master() = default;

    public:
    Master();
    // Master(...);

    void dostuff();
};

class Foo : public Master {
    public:
    Foo();
    // kein dtor override notwendig
};


// abstract
class BasePrinter {
    // muss virtual sein bei abstract    
    //protected:    
    //~BasePrinter();
    
    // theoretisch könnte man doch alles protected machen ?
    public:
    BasePrinter();

    // warning: 'BasePrinter' has no out-of-line virtual method
    // definitions; its vtable will be emitted in every translation unit
    // [-Wweak-vtables]
    // in .cpp auslagern
    virtual ~BasePrinter();

    virtual void print(std::ostream& out) = 0;
};


class IntPrinter : public BasePrinter {
    public:
    IntPrinter();
    // kein dtor override notwendig ?
    // warning: 'IntWriter' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
    // virtual dtor in public, nicht non-virtual dtor in protected
    virtual ~IntPrinter() = default;


    // override virtual methode
    void print(std::ostream& out) override;
};



// std::runtime_error hat virtual dtor
class FooBaseException : public std::runtime_error {
    protected:
    // info error stuff
    int _errc;

    public:

    FooBaseException(int errc, std::string msg)
        : std::runtime_error(msg)
        , _errc(errc)
    {}

    
    // warning: 'FooBaseException' has no out-of-line virtual method
    // definitions; its vtable will be emitted in every translation unit
    // [-Wweak-vtables]
    // dtor auslagern nach .cpp
    // virtual ~FooBaseException() = default;
    virtual ~FooBaseException();

    int getErrc() const { return this->_errc; }
};


// warning: 'FooException' has no out-of-line virtual method
// definitions; its vtable will be emitted in every translation unit
// [-Wweak-vtables]
class FooException : public FooBaseException {
    public:
    FooException(int errc, std::string msg)
        : FooBaseException(errc, msg)
    {}

    // warning: 'FooBaseException' has no out-of-line virtual method
    // definitions; its vtable will be emitted in every translation unit
    // [-Wweak-vtables]
    // dtor auslagern nach .cpp
    ~FooException() override;

    // other ctors, methodes
};

C-/C++-Quelltext

warning: definition of implicit copy constructor for
      'FooException' is deprecated because it has a user-declared destructor
      [-Wdeprecated]
FooException::~FooException(){
              ^
 note: implicit copy constructor for 'FooException' first
      required here
    FooException new_foo_exc = foo_exc;  // or throw foo_exc;
                               ^
warning: definition of implicit copy constructor for
      'FooBaseException' is deprecated because it has a user-declared destructor
      [-Wdeprecated]
FooBaseException::~FooBaseException(){
                  ^
 note: implicit copy constructor for 'FooBaseException' first
      required here
class FooException : public FooBaseException {
      ^