GNU GCC (g ++): เหตุใดจึงสร้าง dtors หลายตัว

การพัฒนาสภาพแวดล้อม: GNU GCC (g ++) 4.1.2

ในขณะที่ฉันกำลังพยายามตรวจสอบวิธีเพิ่ม 'การครอบคลุมโค้ด - โดยเฉพาะการครอบคลุมฟังก์ชัน' ในการทดสอบหน่วยฉันพบว่า dtor บางคลาสดูเหมือนจะถูกสร้างขึ้นหลายครั้ง พวกคุณบางคนมีความคิดว่าทำไมโปรด?

ฉันพยายามและสังเกตสิ่งที่ฉันกล่าวถึงข้างต้นโดยใช้รหัสต่อไปนี้

ใน "test.h"

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

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

ใน "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;
}

เมื่อฉันสร้างโค้ดด้านบน (g ++ test.cpp -o test) จากนั้นดูว่ามีการสร้างสัญลักษณ์ประเภทใดดังนี้

นาโนเมตร - การทดสอบความผิดเพี้ยน

ฉันเห็นผลลัพธ์ต่อไปนี้

==== 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()

คำถามของฉันมีดังนี้

1) เหตุใดจึงสร้าง dtors หลายตัว (BaseClass - 2, DerivedClass - 3)

2) อะไรคือความแตกต่างระหว่าง dtors เหล่านี้? วิธีการเลือกใช้ dtors หลายตัวเหล่านี้?

ตอนนี้ฉันรู้สึกว่าเพื่อให้ได้ฟังก์ชันครอบคลุม 100% สำหรับโปรเจ็กต์ C ++ เราจำเป็นต้องเข้าใจสิ่งนี้เพื่อที่ฉันจะสามารถเรียกใช้ dtors เหล่านั้นทั้งหมดในการทดสอบหน่วยของฉันได้

ฉันจะขอบคุณเป็นอย่างยิ่งหากมีใครสามารถตอบกลับฉันด้านบนได้

ครั้งแรกวัตถุประสงค์ของฟังก์ชั่นเหล่านี้จะอธิบายไว้ในItanium c ++ ABI ; ดูคำจำกัดความภายใต้ "ตัวทำลายวัตถุพื้นฐาน" "ตัวทำลายวัตถุที่สมบูรณ์" และ "การลบตัวทำลาย" การแมปกับชื่อที่แหลกเหลวมีให้ใน 5.1.4

โดยทั่วไป:

• D2 คือ "ตัวทำลายวัตถุพื้นฐาน" มันทำลายออบเจ็กต์เองเช่นเดียวกับสมาชิกข้อมูลและคลาสพื้นฐานที่ไม่ใช่เสมือน
• D1 คือ "ตัวทำลายออบเจ็กต์ที่สมบูรณ์" นอกจากนี้ยังทำลายคลาสพื้นฐานเสมือน
• D0 คือ "การลบตัวทำลายวัตถุ" มันทำทุกอย่างที่ตัวทำลายออบเจ็กต์ที่สมบูรณ์ทำแถมยังเรียกร้องoperator deleteให้ปลดปล่อยหน่วยความจำอีกด้วย

หากคุณไม่มีคลาสพื้นฐานเสมือน D2 และ D1 จะเหมือนกัน GCC จะในระดับการเพิ่มประสิทธิภาพที่เพียงพอจริง ๆ แล้วจะใช้สัญลักษณ์แทนรหัสเดียวกันสำหรับทั้งสองอย่าง

โดยปกติจะมีคอนสตรัคเตอร์สองแบบ ( ไม่คิดค่าใช้จ่าย / ในการชาร์จ ) และตัวทำลายสามตัว (การลบแบบไม่คิดค่าใช้จ่าย / ในค่าใช้จ่าย / ในการชาร์จ )

ไม่เสียค่าใช้จ่าย ctor และ dtor จะใช้เมื่อจัดการวัตถุของคลาสที่สืบทอดจากคลาสอื่นโดยใช้ที่virtualคำหลักเมื่อวัตถุไม่ได้เป็นวัตถุที่สมบูรณ์ (ดังนั้นวัตถุปัจจุบันคือ "ไม่ได้อยู่ในค่าใช้จ่าย" ในการสร้างหรือ destructing วัตถุฐานเสมือน) ctor นี้รับตัวชี้ไปยังวัตถุฐานเสมือนและเก็บไว้

ในค่าใช้จ่าย ctor และ dtors มีสำหรับทุกกรณีอื่น ๆ เช่นถ้าไม่มีมรดกเสมือนเกี่ยวข้อง หากคลาสมีตัวทำลายเสมือนตัวชี้การลบ dtor ที่คิดค่าบริการจะเข้าสู่สล็อต vtable ในขณะที่ขอบเขตที่ทราบประเภทไดนามิกของวัตถุ (เช่นสำหรับวัตถุที่มีระยะเวลาการจัดเก็บอัตโนมัติหรือคงที่) จะใช้dtor ที่มีประจุ (เพราะไม่ควรปล่อยความทรงจำนี้)

ตัวอย่างโค้ด:

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);

ผล:

• รายการ dtor ในแต่ละ vtables สำหรับfoo, bazและquuxจุดที่เกี่ยวข้องในค่าใช้จ่ายการลบ dtor
• b1และb2สร้างขึ้นโดยbaz() การเรียกเก็บเงินซึ่งเรียกfoo(1) เก็บเงิน
• q1และq2สร้างขึ้นโดยquux() ประจุไฟฟ้าซึ่งตกอยู่foo(2) ในประจุและbaz() ไม่อยู่ในประจุโดยมีตัวชี้ไปยังfooวัตถุที่สร้างขึ้นก่อนหน้านี้
• q2เป็น destructed โดย~auto_ptr() เสียค่าใช้จ่ายซึ่งเรียก dtor เสมือน~quux() การลบในค่าใช้จ่ายที่เรียก~baz() ไม่เสียค่าใช้จ่าย , ~foo() ในค่าใช้จ่ายoperator deleteและ
• q1ถูกทำลายโดย~quux() การเรียกเก็บเงินซึ่งเรียกว่า~baz() ไม่เรียกเก็บเงินและ~foo() ไม่มีค่าใช้จ่าย
• b2ถูกทำลายโดย~auto_ptr() การเรียกเก็บเงินซึ่งเรียกการ~baz() ลบค่าใช้จ่าย dtor เสมือนซึ่งเรียก~foo() ค่าใช้จ่ายและoperator delete
• b1ถูกทำลายโดย~baz() ผู้รับผิดชอบซึ่งเรียก~foo() เก็บเงิน

ใครก็ตามที่ได้มาจากquuxจะใช้ctor และ dtor ที่ไม่คิดค่าบริการและรับผิดชอบในการสร้างfooวัตถุ

โดยหลักการแล้วตัวแปรที่ไม่คิดค่าใช้จ่ายไม่จำเป็นสำหรับคลาสที่ไม่มีฐานเสมือน ในกรณีนั้นตัวแปรที่มีค่าใช้จ่ายบางครั้งเรียกว่าunifiedและ / หรือสัญลักษณ์สำหรับทั้งที่คิดค่าใช้จ่ายและไม่อยู่ในค่าใช้จ่ายจะถูกใช้นามแฝงเป็นการนำไปใช้งานเดียว