AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++入门到精通】C++入门 —— 多态（抽象类和虚函数的魅力)

2024-03-22 79
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 多态是面向对象编程中的一个重要概念，指的是同一个消息被不同类型的对象接收时产生不同的行为。通俗来说，**就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态**。

前言

前面我们讲了C语言的基础知识，也了解了一些数据结构，并且讲了有关C++的命名空间的一些知识点以及关于C++的缺省参数、函数重载，引用 和 内联函数也认识了什么是类和对象以及怎么去new一个 ‘对象’ ，也了解了C++中的模版，以及学习了几个STL的结构也相信大家都掌握的不错，接下来博主将会带领大家继续学习有关C++比较重要的知识点—— 多态（抽象类和虚函数的魅力）。下面话不多说坐稳扶好咱们要开车了😍

一、多态的概念

1. 概念

多态是面向对象编程中的一个重要概念，指的是同一个消息被不同类型的对象接收时产生不同的行为。通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

⭕多态的核心思想是通过基类指针或引用来调用派生类的方法，在运行时确定实际调用的方法。这种动态绑定的特性使得代码更加灵活，能够适应不同的对象和场景。

2. 多态的特点

  1. 多态性通过继承和虚函数的机制来实现。
  2. 多态性在运行时动态地确定调用的函数，而不是在编译时静态地确定。
  3. 多态性可以让相同的代码适用于不同类型的对象，提高代码的可重用性和扩展性。
  4. 多态性能够进行方法重写，不同的派生类可以根据自身的需求提供不同的方法实现。

二、多态的定义及实现

1. 多态的构成条件

实现多态性的关键是满足以下两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

🚨虚函数：通过在基类中使用 virtual 关键字声明函数为虚函数，可以实现动态绑定，使得在运行时选择调用实际对象的方法。（下面会有概念及定义）

虚函数允许通过基类指针或引用调用派生类的方法，而在运行时动态地确定实际调用的函数。当通过基类指针或引用调用虚函数时，编译器会根据实际对象的类型来调用相应的派生类函数。

以下是实现多态性的典型代码结构：

class Base {
public:
    virtual void polymorphicFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    virtual void polymorphicFunction() {
        // 派生类重写基类虚函数的实现
    }
};

基类 Base 声明了一个虚函数 polymorphicFunction()，派生类 Derived 重写了这个虚函数。通过基类指针或引用来调用该虚函数时，实际执行的是派生类中的函数实现。

总结起来，多态的构成条件是基于继承关系和虚函数的使用。满足这两个条件后，就可以通过基类的指针或引用调用派生类的函数，实现多态性的效果。

下面这个图片模拟了一个简单的多态的定义以及实现的过程，实现了“不同人群，买了不同的票”

2. 虚函数

⭕虚函数：即被virtual修饰的类成员函数称为虚函数。例如：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

3. 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Derived : public Base {
public:
    virtual void myFunction() {
        // 派生类重写基类虚函数的实现
    }
};

⭕虚函数重写的两个例外

1.协变(基类与派生类虚函数返回值类型不同)

🚩派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

协变的实现和使用需要满足以下条件:

  1. 继承关系：
    协变是基于继承关系的特性，需要存在基类和派生类。派生类继承了基类的属性和方法。
  2. 虚函数：
    必须在基类中将要协变的虚函数声明为虚函数，并在派生类中重新定义（重写）该虚函数。基类中的虚函数返回类型应该是指向某种类型的指针或引用，而派生类中的重写函数的返回类型可以是指向派生类类型的指针或引用。

下面是一个示例来说明协变的使用方法：

class Base {
public:
    virtual Base* createInstance() {
        return new Base();
    }
};

class Derived : public Base {
public:
    Derived* createInstance() override {
        return new Derived();
    }
};

在上述示例中，Base 类声明了一个虚函数 createInstance()，该函数返回类型为 Base*，即指向 Base 类对象的指针。在派生类 Derived 中重写了这个函数，将返回类型修改为 Derived*，即指向 Derived 类对象的指针。

通过协变，派生类 Derived 可以返回比基类 Base 更具体的类型，即 Derived*。这样，在使用基类指针调用派生类的虚函数时，实际会返回派生类的对象指针。

🚨注意

  • 协变只适用于指针或引用类型的返回值，而不适用于值类型。
  • 派生类重写函数的返回类型必须在基类函数返回类型的派生类型层次结构中。

2.析构函数的重写(基类与派生类析构函数的名字不同)

🍪如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor

以下是一个示例演示如何在派生类中重写基类的析构函数：

class Base {
public:
    virtual ~Base() {
        // 基类析构函数的实现
    }
};

class Derived : public Base {
public:
    ~Derived() override {
        // 派生类析构函数的实现
    }
};

在上述示例中，基类 Base 声明了一个虚析构函数 ~Base()。派生类 Derived 重写了基类的虚析构函数，使用 ~Derived() 来重新定义析构函数的实现。

🚨注意：

  • 虚析构函数只需要在基类中声明，不需要在派生类中显式声明为虚函数。
  • 为了确保正确的析构顺序，派生类的析构函数可以在末尾隐式调用基类的析构函数，不需要显式调用。

⭕重写基类的析构函数在处理继承关系和多态性时非常重要，它能够确保在销毁派生类对象时，正确地调用相应的析构函数，避免资源泄漏和未定义行为。

4. override 和 final（C++11 ）

override 和 final 都是 C++11 中引入的关键字，用于标识和修饰虚函数的行为。

override

override 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

示例：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() override {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，派生类 Derived 使用 override 关键字表明它重写了基类 Base 的虚函数 myFunction()。如果在派生类中意外地使用了错误的函数签名（参数列表或返回类型不匹配），编译器会发出错误提示。

final

final 用于标识类、成员函数或虚函数，表示它们被声明为最终版本，禁止在派生类中进一步继承或重写。

示例：

class Base final {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() /* override 不可使用 */ {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，基类 Base 使用 final 关键字标识它是最终类，不允许被继续派生。同时，派生类 Derived 中的 myFunction() 不能使用 override 关键字进行标识，因为基类已经被声明为最终类。

5. 重载、覆盖(重写)、隐藏(重定义)的对比

1. 重载

重载是指在同一个作用域内，根据函数的参数列表的不同，可以定义多个具有相同名称但参数不同的函数。重载函数可以有不同的返回类型，但不能仅仅通过返回类型的不同来进行重载。

示例：

void myFunction(int x) {
    // 函数实现
}

void myFunction(double x) {
    // 函数实现
}

在上述示例中，myFunction 函数被重载了，分别接受一个 int 类型和一个 double 类型的参数。

2. 覆盖（也称为重写）

覆盖是指派生类中重新定义（重写）基类的虚函数，以实现多态性。派生类中的虚函数必须与基类的虚函数具有相同的函数签名（包括参数列表和返回类型），并使用 override 关键字进行标识。

示例：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() override {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，派生类 Derived 重写了基类 Base 的虚函数 myFunction()，并使用 override 关键字进行标识。

3. 隐藏（也称为重定义）

隐藏是指派生类中定义了与基类中同名的非虚函数或静态函数，从而隐藏了基类中的同名函数。隐藏函数不具有多态性，调用时会根据对象的静态类型来确定调用的函数。

示例：

class Base {
public:
    void myFunction() {
        // 基类函数的实现
    }
};

class Derived : public Base {
public:
    void myFunction() {
        // 派生类函数的实现
    }
};

在上述示例中，派生类 Derived 定义了与基类 Base 同名的函数 myFunction()，从而隐藏了基类的同名函数。

总结：

  • 重载是指在同一个作用域内定义多个具有相同名称但参数列表不同的函数。
  • 覆盖是指派生类中重新定义（重写）基类的虚函数，以实现多态性。
  • 隐藏是指派生类中定义了与基类中同名的非虚函数或静态函数，从而隐藏了基类中的同名函数。

三、抽象类

1. 抽象类的概念

抽象类是一种特殊的类，它不能实例化对象，只能作为其他类的基类。抽象类用于定义一组相关的类的共同接口，它包含纯虚函数和非纯虚函数。

可以通过在类中声明纯虚函数来创建抽象类。纯虚函数是一个在基类中声明但没有具体实现的虚函数，它通过在函数声明后添加 "= 0" 来指示。

抽象类的主要目的是定义一组规范和约束，要求派生类实现纯虚函数，以便在派生类中实现具体的功能。

以下是一个抽象类的示例：

class AbstractClass {
public:
    virtual void pureVirtualFunction() const = 0;
    virtual void virtualFunction() const {
        // 可选的虚函数实现
    }
    void regularFunction() const {
        // 非虚函数的实现
    }
};

在上述示例中，AbstractClass 是一个抽象类。它包含了纯虚函数 pureVirtualFunction()，该函数没有具体实现，需要在派生类中进行实现。同时，它还包含了一个可选的虚函数 virtualFunction() 和一个非虚函数 regularFunction()。

抽象类具有以下特点：

  • 不能创建抽象类的对象，只能通过派生出的非抽象子类来创建对象。
  • 子类必须实现抽象类中的纯虚函数，否则子类也成为抽象类。
  • 抽象类可以包含非纯虚函数和数据成员。
  • 抽象类的指针可以用于引用或指向派生类的对象。

抽象类提供了一个接口的定义和封装，强制要求派生类实现接口中的方法。这种设计方式有助于实现多态性和代码的可扩展性，提高代码的模块化和重用性。

2. 接口继承和实现继承

-- 接口继承

  • 接口继承关注的是类与类之间的协议或合约。一个类可以通过继承一个或多个接口来表明它具有实现这些接口所定义的方法和行为。
  • 接口（Interface）定义了一组纯虚函数（只有声明没有实现），表示了一种约定或契约，派生类必须实现这些纯虚函数。
  • 接口继承使得类之间的关系更加松耦合，可以实现更好的代码复用和扩展性。

-- 实现继承

  • 实现继承关注的是类与类之间的具体的实现关系。一个类可以通过继承的方式获取另一个类的属性和方法的实现。
  • 在实现继承中，子类（派生类）继承父类（基类）的成员变量和成员方法，并可以通过继承的方式进行扩展或修改。
  • 实现继承可以扩展基类的功能，实现代码重用，但也可能导致类之间的紧密耦合。

-- 适用类型

  • 当关注类之间的协议和约定，希望实现一种行为的一致性时，可以选择接口继承。
  • 当一个类希望获取另一个类的具体实现，并在此基础上进行扩展时，可以选择实现继承。

四、多态的原理

1. 虚函数表

我们首先来看一道题目：sizeof(Base)是多少？

class Base
{
public:
    virtual void Func1()
    {
        cout << "Func1()" << endl;
    }
private:
    int _b = 1;
};

通过观察测试我们发现Base对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

针对上面的代码我们做出以下改造

  1. 我们增加一个派生类Derive去继承Base
  2. Derive中重写Func1
  3. Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()" << endl;
    }

    virtual void Func2()
    {
        cout << "Base::Func2()" << endl;
    }

    void Func3()
    {
        cout << "Base::Func3()" << endl;
    }

private:
    int _b = 1;
};

class Derive : public Base
{
public:
    virtual void Func1()
    {
        cout << "Derive::Func1()" << endl;
    }
private:
    int _d = 2;
};

int main()
{
    Base b;
    Derive d;
    return 0;
}

通过观察和测试，我们发现了以下几点问题：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
  5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
  6. 虚函数存在哪的？

答：虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。（虚表存的是虚函数指针，不是虚函数，另外对象中存的不是虚表，存的是虚表指针）

2. 动态绑定与静态绑定

动态绑定

  • 动态绑定是在运行时确定函数、方法或操作要与调用者绑定的过程。
  • 动态绑定适用于虚函数和纯虚函数，通过基类的指针或引用来调用派生类的虚函数。
  • 在动态绑定中，根据对象的实际类型（而不是引用或指针的类型）来确定要调用的函数。这意味着在运行时才能确定函数的具体绑定。
  • 动态绑定通过虚函数表和虚函数指针来实现。编译器会查找虚函数表，并根据对象的实际类型找到对应的虚函数进行调用。

⭕动态绑定实现了多态性，使得通过基类的指针或引用调用派生类的虚函数时，能够在运行时根据对象的实际类型决定要调用的函数，从而实现了多态行为。

静态绑定

  • 静态绑定是在编译时确定函数、方法或操作要与调用者绑定的过程。
  • 在静态绑定中，根据引用或指针的声明类型来确定要调用的函数、方法或操作。
  • 静态绑定适用于非虚函数、静态函数和全局函数。编译器在编译阶段就能够确定调用哪个函数。
  • 静态绑定通常比动态绑定更快，因为在编译时已经决定了函数调用的路径。

🚨注意：静态绑定和动态绑定是相对的概念，多态性是建立在动态绑定的基础上的。在面向对象编程中，静态绑定主要用于非虚函数或静态函数，而动态绑定主要用于虚函数。

3. 多态的原理

🔴多态的原理主要基于两个关键的机制：虚函数和动态绑定。

🚩多态的实现步骤

  1. 定义一个基类，并在其中声明一个或多个虚函数。
  2. 派生类继承基类，并可以选择重写基类中的虚函数。
  3. 创建基类的指针或引用，并指向派生类的对象。
  4. 通过基类的指针或引用调用虚函数。
  5. 运行时系统根据对象的实际类型确定要调用的虚函数，实现动态绑定，即根据对象的真正类型来调用正确的函数。

需要注意的是，多态性只适用于通过指针或引用调用虚函数的情况。当直接通过对象调用函数时，编译器在编译时就能够确定调用哪个函数，不会发生动态绑定。

⭕多态通过虚函数和动态绑定实现，允许我们以统一的方式处理不同类型的对象，并在运行时根据对象的实际类型调用适当的虚函数，从而实现了面向对象编程中的多态性。

五、单继承和多继承关系中的虚函数表

1. 单继承中的虚函数表

✅在单继承关系中，每个类只有一个直接基类，因此虚函数表的实现相对简单。每个类的虚函数表存储了该类及其直接基类中的所有虚函数的地址。当通过对象的指针或引用调用虚函数时，编译器会使用对象的虚函数指针（vptr）来查找虚函数表，并根据对象的实际类型确定要调用的具体虚函数。

2. 多继承中的虚函数表

我们首先来看一段代码

class Base1 {
public:
    virtual void func1() {cout << "Base1::func1" << endl;}
    virtual void func2() {cout << "Base1::func2" << endl;}
private:
    int b1;
};

class Base2 {
public:
    virtual void func1() {cout << "Base2::func1" << endl;}
    virtual void func2() {cout << "Base2::func2" << endl;}
private:
    int b2;
};

class Derive : public Base1, public Base2 {
public:
    virtual void func1() {cout << "Derive::func1" << endl;}
    virtual void func3() {cout << "Derive::func3" << endl;}
private:
    int d1;
};

typedef void (*VFPTR)(); // 定义函数指针类型 VFPTR，用于表示虚函数的地址

void PrintVTable(VFPTR vTable[])
{
    cout << "虚表地址>" << vTable << endl; // 输出虚函数表的地址

    // 循环遍历虚函数表，直到遇到空指针为止
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        printf("第%d个虚函数地址: 0x%x, ->", i, vTable[i]); // 输出虚函数在虚函数表中的索引位置和地址（以十六进制格式表示）

        VFPTR f = vTable[i]; // 将当前虚函数的地址赋值给函数指针变量 f

        f(); // 通过调用函数指针 f 执行对应的虚函数
    }

    cout << endl; // 输出换行符表示当前虚函数的输出结束
}

int main()
{
    Derive d;
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb1);
    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
    PrintVTable(vTableb2);
    return 0;
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

这里有两篇文章推荐大家看一下
C++ 虚函数表解析
C++ 对象的内存布局

六、多态总结

  1. 多态性通过虚函数和动态绑定实现。虚函数是在基类中声明的带有关键字 virtual 的函数，它可以在派生类中重写（覆盖）。动态绑定是根据对象的实际类型来确定要调用的虚函数。
  2. 多态允许通过基类的指针或引用操作不同类型的对象，而无需关心对象的具体类型。这提高了代码的可扩展性和可维护性。
  3. 多态遵循面向对象编程的封装和抽象原则，能够隐藏对象的具体实现细节，将关注点放在接口和行为上。
  4. 在单继承关系中，每个类只有一个直接基类，虚函数表的实现相对简单，直接存储类及其直接基类的虚函数地址。通过对象的指针或引用调用虚函数时，根据对象的虚函数指针和虚函数表确定要调用的函数。
  5. 在多继承关系中，一个类可以有多个直接基类，可能涉及虚基类表和虚函数表指针数组的实现。虚基类表用于存储虚基类的相关信息，虚函数表指针数组在派生类的虚函数表中包含指向每个基类虚函数表的指针。
  6. 多态性只适用于通过指针或引用调用虚函数的情况。直接通过对象调用函数时，编译器在编译时就能够确定调用哪个函数，不会发生动态绑定。

温馨提示

感谢您对博主文章的关注与支持！另外，我计划在未来的更新中持续探讨与本文相关的内容，会为您带来更多关于C++以及编程技术问题的深入解析、应用案例和趣味玩法等。请继续关注博主的更新，不要错过任何精彩内容！

再次感谢您的支持和关注。期待与您建立更紧密的互动，共同探索C++、算法和编程的奥秘。祝您生活愉快，排便顺畅！

文章标签：
C++
编译器
存储
C语言
算法
关键词：
C++多态
C++入门
C++入门多态
C++虚函数
C++抽象类
Yawesh
目录
相关文章
chian-ocean
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++】多态
多态是面向对象编程中的重要特性，允许通过基类引用调用派生类的具体方法，实现代码的灵活性和扩展性。其核心机制包括虚函数、动态绑定及继承。通过声明虚函数并让派生类重写这些函数，可以在运行时决定具体调用哪个版本的方法。此外，多态还涉及虚函数表（vtable）的使用，其中存储了虚函数的指针，确保调用正确的实现。为了防止资源泄露，基类的析构函数应声明为虚函数。多态的底层实现涉及对象内部的虚函数表指针，指向特定于类的虚函数表，支持动态方法解析。
chian-ocean
33 1
徐霞客320
|
2月前
|
编译器 C++
C++入门12——详解多态1
C++入门12——详解多态1
徐霞客320
48 2
C++入门12——详解多态1
徐霞客320
|
2月前
|
C++
C++入门13——详解多态2
C++入门13——详解多态2
徐霞客320
89 1
白子寰
|
2月前
|
存储 安全 编译器
【C++打怪之路Lv1】-- 入门二级
【C++打怪之路Lv1】-- 入门二级
白子寰
32 0
白子寰
|
2月前
|
自然语言处理 编译器 C语言
【C++打怪之路Lv1】-- C++开篇(入门)
【C++打怪之路Lv1】-- C++开篇(入门)
白子寰
39 0
努力学习的小廉
|
2月前
|
分布式计算 Java 编译器
【C++入门（下）】—— 我与C++的不解之缘（二）
【C++入门（下）】—— 我与C++的不解之缘（二）
努力学习的小廉
79 0
努力学习的小廉
|
2月前
|
编译器 Linux C语言
【C++入门（上）】—— 我与C++的不解之缘（一）
【C++入门（上）】—— 我与C++的不解之缘（一）
努力学习的小廉
81 0
ephemerals__
|
1月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
53 2
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
109 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
103 4