Tôi có cần gọi rõ ràng trình phá hủy ảo cơ sở không?

Question

Khi ghi đè một lớp trong C++ (với một destructor ảo) Tôi đang thực hiện destructor một lần nữa như ảo trên lớp kế thừa, nhưng tôi cần phải gọi destructor cơ sở?

Nếu vậy tôi tưởng tượng nó là một cái gì đó như thế này ...

MyChildClass::~MyChildClass() // virtual in header 
{ 
    // Call to base destructor... 
    this->MyBaseClass::~MyBaseClass(); 

    // Some destructing specific to MyChildClass 
} 

Tôi có phải không?

Answer 1

Không, trình tự hủy được gọi tự động theo thứ tự xây dựng ngược lại. (Lớp cơ sở cuối cùng). Không gọi destructors lớp cơ sở.

Answer 2

Không, bạn không cần phải gọi trình phá hủy cơ sở, một trình phá hủy cơ sở luôn được gọi cho bạn bởi trình phá hủy có nguồn gốc. Please see my related answer here for order of destruction.

Để hiểu lý do tại sao bạn muốn có một destructor ảo trong lớp cơ sở, xin vui lòng xem mã bên dưới:

class B 
{ 
public: 
    virtual ~B() 
    { 
     cout<<"B destructor"<<endl; 
    } 
}; 


class D : public B 
{ 
public: 
    virtual ~D() 
    { 
     cout<<"D destructor"<<endl; 
    } 
}; 

Khi bạn làm:

B *pD = new D(); 
delete pD; 

Sau đó, nếu bạn không có một destructor ảo trong B, chỉ ~ B() sẽ được gọi. Nhưng vì bạn có một destructor ảo, đầu tiên ~ D() sẽ được gọi, sau đó ~ B().

Answer 3

No. Nó tự động được gọi.

Answer 4

Những gì người khác nói, nhưng cũng lưu ý rằng bạn không phải khai báo destructor ảo trong lớp dẫn xuất. Một khi bạn khai báo một destructor ảo, như bạn làm trong lớp cơ sở, tất cả các destructors có nguồn gốc sẽ là ảo cho dù bạn khai báo chúng có hay không. Nói cách khác:

struct A { 
    virtual ~A() {} 
}; 

struct B : public A { 
    virtual ~B() {} // this is virtual 
}; 

struct C : public A { 
    ~C() {}   // this is virtual too 
}; 

Answer 5

No. Không giống như các phương pháp ảo khác, nơi bạn gọi rõ ràng phương thức cơ sở từ Derived to 'chain' cuộc gọi, trình biên dịch tạo mã để gọi hàm hủy theo thứ tự ngược lại các nhà thầu của họ đã được gọi.

Answer 6

Không, bạn không bao giờ gọi lớp destructor bese, nó luôn luôn được gọi là tự động như những người khác đã chỉ ra nhưng đây là bằng chứng của khái niệm với kết quả:

class base { 
public: 
    base() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
    ~base() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
}; 

class derived : public base { 
public: 
    derived() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
    ~derived() 
    { 
     cout << __FUNCTION__ << endl; 
    } // adding call to base::~base() here results in double call to base destructor 
}; 


int main() 
{ 
    cout << "case 1, declared as local variable on stack" << endl << endl; 
    { 
     derived d1; 
    } 

    cout << endl << endl; 

    cout << "case 2, created using new, assigned to derive class" << endl << endl; 
    derived * d2 = new derived; 
    delete d2; 

    cout << endl << endl; 

    cout << "case 3, created with new, assigned to base class" << endl << endl; 
    base * d3 = new derived; 
    delete d3; 

    cout << endl; 

    return 0; 
} 

Đầu ra là:

case 1, declared as local variable on stack 

base::base 
derived::derived 
derived::~derived 
base::~base 


case 2, created using new, assigned to derive class 

base::base 
derived::derived 
derived::~derived 
base::~base 


case 3, created with new, assigned to base class 

base::base 
derived::derived 
base::~base 

Press any key to continue . . . 

Nếu bạn đặt trình phá hủy lớp cơ sở là ảo mà người dùng nên, thì kết quả giống như trường hợp 1 & 2.