C++构造函数 析构函数 虚函数 纯虚函数

C++面向对象编程中，构造函数和析构函数是两个非常重要的概念。

构造函数是一种特殊的函数，它在对象被创建时自动调用，用于初始化对象的数据成员。构造函数的名称与类名相同，没有返回值类型，可以有参数，可以有多个构造函数，以便在创建对象时进行不同的初始化操作。

析构函数是一种特殊的函数，它在对象被销毁时自动调用，用于清理对象的资源。析构函数的名称与类名相同，前面加上一个波浪号(~)，没有返回值类型，不接受任何参数。

构造函数和析构函数是C++面向对象编程中的两个重要概念，它们的作用是初始化对象和清理对象的资源，是面向对象编程的基础。

相关问题

C++ 构造函数 析构函数 纯虚函数

C++中的构造函数和析构函数是类的两个重要成员函数，它们在对象的创建和销毁过程中起到了关键作用。

构造函数通常用于初始化对象的成员变量，它的名称与类名相同，可以有多个重载版本。在对象创建时，系统会自动调用构造函数。如果没有显式定义构造函数，则系统会生成一个默认的构造函数。

析构函数通常用于释放对象占用的资源，它的名称与类名相同，但前面加上一个波浪号(~)。在对象销毁时，系统会自动调用析构函数。如果没有显式定义析构函数，则系统会生成一个默认的析构函数。

纯虚函数是指在基类中没有实现的虚函数，它只有函数原型，没有函数体。纯虚函数可以用来定义接口，强制派生类实现该函数。类中含有纯虚函数时，该类成为抽象类，不能直接创建该类的对象，只能通过派生类来创建对象。

定义纯虚函数的方式是在函数原型后面加上=0，例如：virtual void func()=0;。需要注意的是，含有纯虚函数的类是不能够被实例化的，只能通过派生类来实现纯虚函数并创建对象。

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

下面是一个示例程序，展示了C++中类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性的使用。请注意，这只是一个简单的示例，可能不涵盖所有情况，但可以帮助你理解这些特性的基本概念。

#include <iostream>

using namespace std;

// 基类A
class A {
public:
    A() {
        cout << "Constructing A" << endl;
    }
    virtual ~A() {
        cout << "Destructing A" << endl;
    }
    virtual void foo() {
        cout << "A::foo()" << endl;
    }
};

// 基类B
class B {
public:
    B() {
        cout << "Constructing B" << endl;
    }
    virtual ~B() {
        cout << "Destructing B" << endl;
    }
    virtual void bar() {
        cout << "B::bar()" << endl;
    }
};

// 派生类C，多重继承自A和B
class C : public A, public B {
public:
    C() {
        cout << "Constructing C" << endl;
    }
    ~C() {
        cout << "Destructing C" << endl;
    }
    void foo() override {
        cout << "C::foo()" << endl;
    }
    void bar() override {
        cout << "C::bar()" << endl;
    }
};

// 派生类D，多级继承自C
class D : public C {
public:
    D() {
        cout << "Constructing D" << endl;
    }
    ~D() {
        cout << "Destructing D" << endl;
    }
    void foo() override {
        cout << "D::foo()" << endl;
    }
};

// 派生类E，虚继承自A
class E : virtual public A {
public:
    E() {
        cout << "Constructing E" << endl;
    }
    ~E() {
        cout << "Destructing E" << endl;
    }
};

// 派生类F，公共继承自A
class F : public A {
public:
    F() {
        cout << "Constructing F" << endl;
    }
    ~F() {
        cout << "Destructing F" << endl;
    }
};

// 派生类G，保护继承自A
class G : protected A {
public:
    G() {
        cout << "Constructing G" << endl;
    }
    ~G() {
        cout << "Destructing G" << endl;
    }
};

// 派生类H，私有继承自A
class H : private A {
public:
    H() {
        cout << "Constructing H" << endl;
    }
    ~H() {
        cout << "Destructing H" << endl;
    }
};

// 类的组合，使用A类的对象作为成员变量
class I {
private:
    A objA;
public:
    I() {
        cout << "Constructing I" << endl;
    }
    ~I() {
        cout << "Destructing I" << endl;
    }
};

// 虚函数和纯虚函数
class Base {
public:
    virtual void foo() {
        cout << "Base::foo()" << endl;
    }
    virtual void pureVirtual() = 0;
};

class Derived : public Base {
public:
    void foo() override {
        cout << "Derived::foo()" << endl;
    }
    void pureVirtual() override {
        cout << "Derived::pureVirtual()" << endl;
    }
};

int main() {
    // 多重继承示例
    C c;
    c.foo();  // 调用C::foo()
    c.bar();  // 调用C::bar()
    
    cout << endl;
    
    // 多级继承示例
    D d;
    d.foo();  // 调用D::foo()
    d.bar();  // 调用C::bar()
    
    cout << endl;
    
    // 虚继承示例
    E e;
    e.foo();  // 调用A::foo()
    
    cout << endl;
    
    // 公共继承示例
    F f;
    f.foo();  // 调用A::foo()
    
    cout << endl;
    
    // 保护继承示例
    G g;
    // g.foo();  // 编译错误，无法访问A类的公有成员函数
    
    cout << endl;
    
    // 私有继承示例
    H h;
    // h.foo();  // 编译错误，无法访问A类的公有成员函数
    
    cout << endl;
    
    // 子对象示例
    I i;
    
    cout << endl;
    
    // 虚函数和纯虚函数示例
    Base* base = new Derived();
    base->foo();           // 调用Derived::foo()
    base->pureVirtual();   // 调用Derived::pureVirtual()
    delete base;
    
    return 0;
}

这个程序展示了类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数和纯虚函数等特性的使用。通过运行程序，你可以看到各个类的构造函数和析构函数的调用顺序，以及不同类的成员函数的调用结果。