析构函数不会被继承但用父类指针指向子类对象是，删除子对象为什么会掉父类的析构函数

当使用父类指针指向子类对象时，如果使用 delete 关键字删除这个指针，会自动调用父类的析构函数，但这并不是因为父类的析构函数被继承了，而是因为在这种情况下，delete 操作符会先调用子类的析构函数，然后再调用父类的析构函数。

这是因为在 C++ 中，派生类的析构函数会自动调用它的基类的析构函数，因此当子类对象被删除时，父类的析构函数也会被自动调用。但是，这并不是继承的结果，而是由于派生类在定义时自动包含了基类的成分，因此在销毁派生类对象时，需要同时销毁基类对象，而这就需要调用基类的析构函数。

因此，无论是使用父类指针指向子类对象，还是直接使用子类对象，删除时都会自动调用子类和父类的析构函数。

相关问题

QT线程继承QThread，在 QThread 的子类中，重写析构函数，调用 quit() 函数来停止线程的运行，然后在析构函数中调用 wait() 函数，等待线程结束。请写一段代码

好的，下面是一个简单的示例代码，演示了如何在 QThread 的子类中重写析构函数，并调用 quit() 和 wait() 函数来停止线程的运行和等待线程结束：

class MyThread : public QThread {
public:
    ~MyThread() override {
        quit();
        wait();
    }

    void run() override {
        // 子线程运行的代码
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    // 创建子线程对象
    MyThread *thread = new MyThread();

    // 启动子线程
    thread->start();

    // 等待子线程结束
    thread->wait();

    // 删除子线程对象
    delete thread;

    // 进入事件循环
    return app.exec();
}

在这个示例代码中，我们先创建了一个 MyThread 类，继承自 QThread，重写了析构函数，在析构函数中调用 quit() 函数来停止线程的运行，并调用 wait() 函数等待线程结束。然后，在主函数中，我们创建了 MyThread 对象，并调用 start() 函数启动线程。接着，我们调用 wait() 函数等待线程结束，然后调用 delete 关键字删除线程对象。最后，我们进入事件循环，等待应用程序退出。

需要注意的是，在实际应用中，我们可能需要在子线程中做一些耗时的操作，这时候我们需要在子线程中做好线程安全，确保线程能够正常结束。另外，在删除线程对象之前，一定要确保线程已经结束，否则会出现意想不到的问题。

编写C++程序，程序中需要体现类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性，须完整各类的构造函数、析构函数。 逻辑自定

好的，我理解了你的问题。以下是一个简单的示例程序，其中包含了类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性。

#include <iostream>
using namespace std;

// 父类A
class A {
public:
    A() { cout << "A constructor" << endl; }
    virtual ~A() { cout << "A destructor" << endl; }
    virtual void func1() { cout << "A::func1()" << endl; }
    virtual void func2() { cout << "A::func2()" << endl; }
};

// 父类B
class B {
public:
    B() { cout << "B constructor" << endl; }
    virtual ~B() { cout << "B destructor" << endl; }
    virtual void func1() { cout << "B::func1()" << endl; }
    virtual void func2() { cout << "B::func2()" << endl; }
};

// 子类C，公共继承A和B，实现父类接口
class C : public A, public B {
public:
    C() { cout << "C constructor" << endl; }
    virtual ~C() { cout << "C destructor" << endl; }
    virtual void func1() { A::func1(); B::func1(); cout << "C::func1()" << endl; }
    virtual void func2() { A::func2(); B::func2(); cout << "C::func2()" << endl; }
};

// 子类D，保护继承A，实现父类接口
class D : protected A {
public:
    D() { cout << "D constructor" << endl; }
    virtual ~D() { cout << "D destructor" << endl; }
    virtual void func1() { A::func1(); cout << "D::func1()" << endl; }
    virtual void func2() { A::func2(); cout << "D::func2()" << endl; }
};

// 子类E，私有继承A，实现父类接口
class E : private A {
public:
    E() { cout << "E constructor" << endl; }
    virtual ~E() { cout << "E destructor" << endl; }
    virtual void func1() { A::func1(); cout << "E::func1()" << endl; }
    virtual void func2() { A::func2(); cout << "E::func2()" << endl; }
};

// 子类F，多级继承C和D，实现父类接口
class F : public C, public D {
public:
    F() { cout << "F constructor" << endl; }
    virtual ~F() { cout << "F destructor" << endl; }
    virtual void func1() { C::func1(); D::func1(); cout << "F::func1()" << endl; }
    virtual void func2() { C::func2(); D::func2(); cout << "F::func2()" << endl; }
};

// 子类G，虚继承A，实现父类接口
class G : virtual public A {
public:
    G() { cout << "G constructor" << endl; }
    virtual ~G() { cout << "G destructor" << endl; }
    virtual void func1() { A::func1(); cout << "G::func1()" << endl; }
    virtual void func2() { A::func2(); cout << "G::func2()" << endl; }
};

// 子类H，虚继承A和B，实现父类接口
class H : virtual public A, virtual public B {
public:
    H() { cout << "H constructor" << endl; }
    virtual ~H() { cout << "H destructor" << endl; }
    virtual void func1() { A::func1(); B::func1(); cout << "H::func1()" << endl; }
    virtual void func2() { A::func2(); B::func2(); cout << "H::func2()" << endl; }
};

// 子类I，组合A，实现父类接口
class I {
public:
    I() { cout << "I constructor" << endl; }
    ~I() { cout << "I destructor" << endl; }
    void func1() { a->func1(); cout << "I::func1()" << endl; }
    void func2() { a->func2(); cout << "I::func2()" << endl; }
private:
    A* a = new A();
};

// 子类J，组合A和B，实现父类接口
class J {
public:
    J() { cout << "J constructor" << endl; }
    ~J() { cout << "J destructor" << endl; }
    void func1() { a->func1(); b->func1(); cout << "J::func1()" << endl; }
    void func2() { a->func2(); b->func2(); cout << "J::func2()" << endl; }
private:
    A* a = new A();
    B* b = new B();
};

// 子类K，继承C和G，实现父类接口
class K : public C, public G {
public:
    K() { cout << "K constructor" << endl; }
    virtual ~K() { cout << "K destructor" << endl; }
    virtual void func1() { C::func1(); G::func1(); cout << "K::func1()" << endl; }
    virtual void func2() { C::func2(); G::func2(); cout << "K::func2()" << endl; }
};

// 子类L，继承H和I，实现父类接口
class L : public H, public I {
public:
    L() { cout << "L constructor" << endl; }
    virtual ~L() { cout << "L destructor" << endl; }
    virtual void func1() { H::func1(); I::func1(); cout << "L::func1()" << endl; }
    virtual void func2() { H::func2(); I::func2(); cout << "L::func2()" << endl; }
};

// 子类M，继承F和J，实现父类接口
class M : public F, public J {
public:
    M() { cout << "M constructor" << endl; }
    virtual ~M() { cout << "M destructor" << endl; }
    virtual void func1() { F::func1(); J::func1(); cout << "M::func1()" << endl; }
    virtual void func2() { F::func2(); J::func2(); cout << "M::func2()" << endl; }
};

int main() {
    cout << "Test C:" << endl;
    C* c = new C();
    cout << "Call C::func1():" << endl;
    c->func1();
    cout << "Call C::func2():" << endl;
    c->func2();
    delete c;

    cout << endl << "Test D:" << endl;
    D* d = new D();
    cout << "Call D::func1():" << endl;
    d->func1();
    cout << "Call D::func2():" << endl;
    d->func2();
    delete d;

    cout << endl << "Test E:" << endl;
    E* e = new E();
    cout << "Call E::func1():" << endl;
    e->func1();
    cout << "Call E::func2():" << endl;
    e->func2();
    delete e;

    cout << endl << "Test F:" << endl;
    F* f = new F();
    cout << "Call F::func1():" << endl;
    f->func1();
    cout << "Call F::func2():" << endl;
    f->func2();
    delete f;

    cout << endl << "Test G:" << endl;
    G* g = new G();
    cout << "Call G::func1():" << endl;
    g->func1();
    cout << "Call G::func2():" << endl;
    g->func2();
    delete g;

    cout << endl << "Test H:" << endl;
    H* h = new H();
    cout << "Call H::func1():" << endl;
    h->func1();
    cout << "Call H::func2():" << endl;
    h->func2();
    delete h;

    cout << endl << "Test I:" << endl;
    I* i = new I();
    cout << "Call I::func1():" << endl;
    i->func1();
    cout << "Call I::func2():" << endl;
    i->func2();
    delete i;

    cout << endl << "Test J:" << endl;
    J* j = new J();
    cout << "Call J::func1():" << endl;
    j->func1();
    cout << "Call J::func2():" << endl;
    j->func2();
    delete j;

    cout << endl << "Test K:" << endl;
    K* k = new K();
    cout << "Call K::func1():" << endl;
    k->func1();
    cout << "Call K::func2():" << endl;
    k->func2();
    delete k;

    cout << endl << "Test L:" << endl;
    L* l = new L();
    cout << "Call L::func1():" << endl;
    l->func1();
    cout << "Call L::func2():" << endl;
    l->func2();
    delete l;

    cout << endl << "Test M:" << endl;
    M* m = new M();
    cout << "Call M::func1():" << endl;
    m->func1();
    cout << "Call M::func2():" << endl;
    m->func2();
    delete m;

    return 0;
}

程序中定义了多个类，每个类都实现了一个父类的接口。其中：

- 类C公共继承了A和B，实现了父类接口，并重写了父类的虚函数。
- 类D保护继承了A，实现了父类接口，并重写了父类的虚函数。
- 类E私有继承了A，实现了父类接口，并重写了父类的虚函数。
- 类F多级继承了C和D，实现了父类接口，并重写了父类的虚函数。
- 类G虚继承了A，实现了父类接口，并重写了父类的虚函数。
- 类H虚继承了A和B，实现了父类接口，并重写了父类的虚函数。
- 类I组合了A，实现了父类接口，并调用了A的虚函数。
- 类J组合了A和B，实现了父类接口，并调用了A和B的虚函数。
- 类K继承了C和G，实现了父类接口，并重写了父类的虚函数。
- 类L继承了H和I，实现了父类接口，并重写了父类的虚函数。
- 类M继承了F和J，实现了父类接口，并重写了父类的虚函数。

在main函数中，分别创建每个类的对象，并调用其接口函数。输出结果可以看到，每个类都按照预期实现了父类的接口，并调用了正确的虚函数。

希望这个示例程序对你有所帮助，如果还有什么问题，请随时提出。