在C ++中从父析构函数调用子方法

Question

class A {
public:
  ~A() { release(); }
  virtual release() { cout << "~A"; } 
}

class B : public A {
  release() { cout << "~B"; }
}

When I delete B, only A class release() method is called.

What I want to achieve is for every child object, when it is deleted, I want to call release method which is overriden in each child class, without manually specifying destructor for each child with call to release (I'm lazy). Is this actually not possible to achieve in this or any other way?

Answer 1

Destructors are executed in the reverse order of constructors , so when the A in a B is destroyed its B component has already been destroyed and no longer exists. Calling a method on a destroyed object yields undefined behavior , and that's why calls to virtual methods always resolve to the current class type within a constructor or destructor .

So basically no, you cannot do it. You will have to write them all.

Answer 2

Don't call virtual methods from destructors or constructors - they won't do what you expect them to do.

Quit being lazy and write destructors.

Answer 3

A solution to this kind of problem is a pre-destroy phase, where you can manually control how destruction happens.

Implement your object with the pImpl pattern. When the wrapping object is destroyed, inform the pImpl that it is going to be destroyed before destroying it.

pImpl can have a base virtual PreDestroyable class that allows child methods to register a PreDestruction callback, which you call during this pre destruction phase.

class Destroyable {
protected:
  Destroyable() {}; // must be empty
  virtual ~Destroyable() { Assert(PreDestroyers.empty()); };
  void RegisterPreDestroy( std::function<void()> const& func ) { PreDestroyers.push_back(func) );
private:
  std::vector<std::function<void()>> PreDestroyers;
public:
  // reverse order, reentrant:
  void PrepareToDie() {
    while (!PreDestroyers.empty()) {
      auto f = PreDestroyers.back();
      PreDestroyers.pop_back();
      f();
    }        
  }
};

// handles registration:
template<typename T>
class HasPreDestroyCode: public virtual Destroyable {
  // TODO: usual CRTP static or dynamic checks:
  T* self() { return static_cast<T*>(this); }
  T const* self() const { return static_cast<T*>(this); }
  HasPreDestroyCode() {
    RegisterPreDestroy( [&]() { self()->PreDestroy(); } );
  }
  HasPreDestroyCode( HasPreDestroyCode const& other ) {
    RegisterPreDestroy( [&]() { self()->PreDestroy(); } );
  }
  HasPreDestroyCode( HasPreDestroyCode const& other ) {
    RegisterPreDestroy( [&]() { self()->PreDestroy(); } );
  }
private:
  HasPreDestroyCode& operator=( HasPreDestroyCode const& other ) = delete;
};

class Test: HasPreDestroyCode<Test> {
public:
  void PreDestroy() {}
};

I last wrote this stuff prior to C++11, so I haven't worked out how to handle move constructing it. And it is all done at runtime, while it is probably possible to do something like the above with less runtime data. Something like a list of types in the hierarchy that contain pre-destroy code or something?