GNU GCC (g ++): Tại sao nó tạo ra nhiều dtors?

Question 1

Môi trường đang phát triển: GNU GCC (g ++) 4.1.2

Trong khi tôi đang cố gắng điều tra cách tăng 'mức độ bao phủ mã - đặc biệt là mức độ bao phủ chức năng' trong kiểm thử đơn vị, tôi nhận thấy rằng một số lớp dtor dường như được tạo nhiều lần. Có ai trong số các bạn có ý kiến về lý do tại sao không?

Tôi đã thử và quan sát những gì tôi đã đề cập ở trên bằng cách sử dụng mã sau.

Trong "test.h"

class BaseClass
{
public:
    ~BaseClass();
    void someMethod();
};

class DerivedClass : public BaseClass
{
public:
    virtual ~DerivedClass();
    virtual void someMethod();
};

Trong "test.cpp"

#include <iostream>
#include "test.h"

BaseClass::~BaseClass()
{
    std::cout << "BaseClass dtor invoked" << std::endl;
}

void BaseClass::someMethod()
{
    std::cout << "Base class method" << std::endl;
}

DerivedClass::~DerivedClass()
{
    std::cout << "DerivedClass dtor invoked" << std::endl;
}

void DerivedClass::someMethod()
{
    std::cout << "Derived class method" << std::endl;
}

int main()
{
    BaseClass* b_ptr = new BaseClass;
    b_ptr->someMethod();
    delete b_ptr;
}

Khi tôi tạo mã ở trên (g ++ test.cpp -o test) và sau đó xem loại ký hiệu nào đã được tạo như sau,

nm - kiểm tra hình tam giác

Tôi có thể thấy kết quả sau.

==== following is partial output ====
08048816 T DerivedClass::someMethod()
08048922 T DerivedClass::~DerivedClass()
080489aa T DerivedClass::~DerivedClass()
08048a32 T DerivedClass::~DerivedClass()
08048842 T BaseClass::someMethod()
0804886e T BaseClass::~BaseClass()
080488f6 T BaseClass::~BaseClass()

Câu hỏi của tôi như sau.

1) Tại sao nhiều dtors đã được tạo ra (BaseClass - 2, DerivedClass - 3)?

2) Sự khác biệt giữa các dtors này là gì? Làm thế nào nhiều dtors đó sẽ được sử dụng có chọn lọc?

Bây giờ tôi có cảm giác rằng để đạt được mức bao phủ 100% hàm cho dự án C ++, chúng ta cần hiểu điều này để tôi có thể gọi tất cả các dtor đó trong các bài kiểm tra đơn vị của mình.

Tôi sẽ đánh giá rất cao nếu ai đó có thể cho tôi câu trả lời ở trên.

Question 2

Đầu tiên, mục đích của các hàm này được mô tả trong Itanium C ++ ABI ; xem định nghĩa trong "bộ hủy đối tượng cơ sở", "bộ hủy đối tượng hoàn chỉnh" và "bộ hủy xóa". Ánh xạ đến các tên bị xáo trộn được nêu trong 5.1.4.

Về cơ bản:

D2 là "bộ hủy đối tượng cơ sở". Nó tự hủy đối tượng, cũng như các thành viên dữ liệu và các lớp cơ sở không ảo.
D1 là "bộ hủy đối tượng hoàn chỉnh". Nó cũng phá hủy các lớp cơ sở ảo.
D0 là "trình hủy đối tượng xóa". Nó thực hiện mọi thứ mà trình hủy đối tượng hoàn chỉnh làm, cộng với nó gọi operator deleteđể thực sự giải phóng bộ nhớ.

Nếu bạn không có lớp cơ sở ảo, D2 và D1 giống hệt nhau; GCC, trên các mức tối ưu hóa đủ, sẽ thực sự đặt biệt danh các ký hiệu cho cùng một mã cho cả hai.

Question 3

Thường có hai biến thể của các nhà xây dựng ( không-phụ trách / phụ trách ) và ba trong số các destructor ( không-phụ trách / phụ trách / phụ trách xóa ).

Các không-phụ trách ctor và dtor được sử dụng khi xử lý một đối tượng của một lớp kế thừa từ một lớp khác bằng cách sử dụng virtualtừ khóa, khi đối tượng không phải là đối tượng đầy đủ (vì vậy các đối tượng hiện nay là "không chịu trách nhiệm" xây dựng hoặc huỷ đối tượng cơ sở ảo). Ctor này nhận một con trỏ đến đối tượng cơ sở ảo và lưu trữ nó.

Các chuyên trách ctor và dtors là dành cho tất cả các trường hợp khác, tức là nếu không có thừa kế ảo liên quan; nếu lớp có bộ hủy ảo, con trỏ dtor xóa phụ trách sẽ đi vào khe vtable, trong khi phạm vi biết kiểu động của đối tượng (tức là đối với các đối tượng có thời lượng lưu trữ tự động hoặc tĩnh) sẽ sử dụng dtor tích hợp (vì vùng nhớ này không được giải phóng).

Ví dụ về mã:

struct foo {
    foo(int);
    virtual ~foo(void);
    int bar;
};

struct baz : virtual foo {
    baz(void);
    virtual ~baz(void);
};

struct quux : baz {
    quux(void);
    virtual ~quux(void);
};

foo::foo(int i) { bar = i; }
foo::~foo(void) { return; }

baz::baz(void) : foo(1) { return; }
baz::~baz(void) { return; }

quux::quux(void) : foo(2), baz() { return; }
quux::~quux(void) { return; }

baz b1;
std::auto_ptr<foo> b2(new baz);
quux q1;
std::auto_ptr<foo> q2(new quux);

Các kết quả:

Mục dtor trong mỗi vtables cho foo, bazvà quuxđiểm tại tương ứng phụ trách xóa dtor.
b1và b2được xây dựng bởi baz() phụ trách , gọi foo(1) phụ trách
q1và q2được xây dựng bởi quux() phụ trách , foo(2) phụ trách và baz() không phụ trách bằng một con trỏ đến foođối tượng mà nó đã xây dựng trước đó
q2bị hủy bởi ~auto_ptr() in-charge , gọi là ~quux() xóa dtor in-charge ảo , gọi là ~baz() not-in-charge , ~foo() in-charge và operator delete.
q1bị hủy bởi ~quux() phụ trách , gọi là ~baz() không phụ trách và ~foo() phụ trách
b2bị hủy bởi ~auto_ptr() phụ trách , gọi là ~baz() xóa dtor phụ trách ảo , gọi ~foo() phụ trách vàoperator delete
b1bị hủy bởi ~baz() phụ trách , mà gọi ~foo() phụ trách

Bất kỳ ai đến từ quuxsẽ sử dụng ctor và dtor không phụ trách của nó và chịu trách nhiệm tạo foođối tượng.

Về nguyên tắc, biến thể không phụ trách không bao giờ cần thiết cho một lớp không có cơ sở ảo; trong trường hợp đó, biến thể phụ trách sau đó đôi khi được gọi là hợp nhất và / hoặc các ký hiệu cho cả người phụ trách và không phụ trách được đặt biệt danh cho một triển khai duy nhất.