C++虚函数拾遗

已于 2024-07-02 10:24:10 修改
阅读量593 收藏 14
点赞数 8
分类专栏： QT C++ 文章标签： c++ 开发语言
于 2024-06-29 09:14:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangguangzhi88/article/details/140058445
版权
QT 同时被 2 个专栏收录
41 篇文章 3 订阅
订阅专栏
C++
40 篇文章 1 订阅
订阅专栏

虚函数详解参考:

C++虚函数详解-CSDN博客

c++虚函数详解-CSDN博客

一文读懂C++虚函数的内存模型_gdp c++ 内存模型 虚函数表-CSDN博客

 上述这2篇文章即可.

  • 在C++中,基类是虚函数,子类对象指针赋值给基类对象指针, 编译器怎么知道当前指针是子类对象还是基类对象的指针?

在C++中，当基类包含虚函数时，编译器会在对象内存中创建一个虚函数表（vtable）。每个类（包括基类和子类）都有自己的虚函数表，表中存储了该类的虚函数的地址。当你将子类对象的指针赋值给基类对象的指针时，基类指针实际上指向的是子类对象的内存区域。由于对象内存中包含了虚函数表指针（vptr），编译器能够通过这个指针找到正确的虚函数表，并调用相应的函数。

详细解释

  1. 虚函数表（vtable）和虚函数指针（vptr）：

    • 当一个类声明了虚函数时，编译器会为该类生成一个虚函数表（vtable），虚函数表中存储了该类的所有虚函数的地址。
    • 每个对象在内存中会有一个隐藏的指针，指向它所属类的虚函数表，这个指针称为虚函数指针（vptr）。

  2. 子类对象的虚函数表：

    • 子类继承了基类的虚函数表，并且可以覆盖基类中的虚函数。当子类覆盖基类的虚函数时，子类的虚函数表中相应的位置会存储子类的虚函数的地址。

  3. 基类指针指向子类对象：

    • 当你将子类对象的指针赋值给基类对象的指针时，基类指针实际上指向的是子类对象的内存区域。
    • 由于子类对象的内存中包含了虚函数指针（vptr），这个指针指向子类的虚函数表。

  4. 调用虚函数：

    • 当通过基类指针调用虚函数时，编译器会通过虚函数指针（vptr）找到实际的虚函数表（vtable），并调用表中相应的函数。
    • 由于基类指针实际指向的是子类对象的内存区域，虚函数指针指向的是子类的虚函数表，因此会调用子类的虚函数。

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Base* basePtr;
    Derived derivedObj;

    basePtr = &derivedObj;

    // 调用虚函数
    basePtr->show();  // 输出: Derived class show function

    return 0;
}

解释

  1. **基类 Base**：
    class Base {
    public:
        virtual void show() {
            std::cout << "Base class show function" << std::endl;
        }
    };
  1. **子类 Derived**：
    class Derived : public Base {
    public:
        void show() override {
            std::cout << "Derived class show function" << std::endl;
        }
    };
  1. 在 main 函数中：
    Base* basePtr;
    Derived derivedObj;

    basePtr = &derivedObj;

    // 调用虚函数
    basePtr->show();  // 输出: Derived class show function

在这个示例中，basePtr 是一个基类指针，指向 derivedObj（一个子类对象）。当通过 basePtr 调用 show 函数时，编译器会通过 derivedObj 的虚函数指针找到 Derived 类的虚函数表，并调用 Derived 类的 show 函数。因此，输出结果是 "Derived class show function"。

  • 为什么子类对象指针可以转换为基类对象存储呢?

在C++中，子类对象指针可以转换为基类对象指针，这是因为子类对象包含基类对象的所有成员和行为。这种转换称为向上转换（upcasting），它是安全且隐式的。以下是详细的解释：

继承和对象模型

当一个类（子类）继承自另一个类（基类）时，子类不仅继承了基类的所有成员变量和成员函数，还可以添加自己的成员变量和成员函数。从内存布局的角度来看，子类对象在内存中包含了一个基类对象的内存布局，然后在此基础上添加子类特有的部分。

向上转换（Upcasting）

向上转换指的是将子类对象的指针或引用转换为基类对象的指针或引用。这种转换是隐式的，不需要显式的类型转换操作符。因为子类对象包含了基类对象的所有成员，所以编译器可以安全地进行这种转换。

为什么向上转换是安全的

  1. 内存布局：

    • 子类对象的内存布局包含基类对象的内存布局。因此，当你将子类对象的指针转换为基类对象的指针时，基类部分的内存布局是保持一致的，编译器可以正确地访问基类的成员。

  2. 多态性：

    • C++的多态性是通过虚函数实现的。当基类包含虚函数时，子类可以覆盖这些虚函数。通过基类指针调用虚函数时，实际调用的是子类的实现，这使得向上转换在多态性中非常有用。

示例代码

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function" << std::endl;
    }
    void derivedOnlyFunction() {
        std::cout << "Derived class specific function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 调用虚函数
    basePtr->show();  // 输出: Derived class show function

    // 尝试调用子类特有的函数（会导致编译错误）
    // basePtr->derivedOnlyFunction();  // 编译错误

    return 0;
}

在这个示例中，Derived 类继承自 Base 类，并覆盖了 show 函数。在 main 函数中，basePtr 是一个基类指针，指向 derivedObj（一个子类对象）。由于向上转换是隐式的，所以不需要显式的类型转换操作符。通过 basePtr 调用 show 函数时，实际调用的是 Derived 类的 show 函数，因为 show 是一个虚函数，支持多态性。

需要注意的是，通过基类指针不能访问子类特有的成员函数或成员变量。如果尝试调用 basePtr->derivedOnlyFunction()，会导致编译错误，因为 Base 类中没有定义 derivedOnlyFunction 函数。

总结

子类对象指针可以转换为基类对象指针是因为子类对象包含了基类对象的所有成员和行为。这种转换是安全的，并且在多态性中非常有用。向上转换允许通过基类指针调用子类的虚函数实现，从而实现运行时的多态性。

是不是可以理解为这种虚函数实际就是指针类型转换的一种高级表现?

可以这样理解，虚函数和指针类型转换之间确实存在紧密的联系，尤其是在多态性方面。虚函数机制使得指针类型转换在运行时能够表现出不同的行为，这种机制是C++实现多态性的重要手段。以下是更详细的解释：

虚函数和多态性

  1. 虚函数表（vtable）和虚函数指针（vptr）：

    • 当一个类包含虚函数时，编译器会为该类生成一个虚函数表（vtable），其中存储了该类的虚函数的地址。
    • 每个对象在内存中会有一个隐藏的指针（vptr），指向它所属类的虚函数表。

  2. 多态性：

    • 多态性是指通过基类指针或引用调用虚函数时，能够在运行时根据对象的实际类型调用相应的函数实现。这使得程序能够以统一的方式处理不同类型的对象。

指针类型转换

  1. 向上转换（Upcasting）：

    • 向上转换是将子类对象的指针或引用转换为基类对象的指针或引用。这种转换是隐式的，不需要显式的类型转换操作符。
    • 向上转换是安全的，因为子类对象包含基类对象的所有成员和行为。

  2. 向下转换（Downcasting）：

    • 向下转换是将基类对象的指针或引用转换为子类对象的指针或引用。这种转换需要显式的类型转换操作符（如dynamic_cast），并且在运行时可能失败。
    • 向下转换通常需要进行类型检查，以确保转换的安全性。

虚函数在指针类型转换中的作用

虚函数使得基类指针能够在运行时调用子类的实现，从而实现多态性。通过虚函数表和虚函数指针，编译器能够在运行时根据对象的实际类型找到正确的函数实现并进行调用。这种机制使得指针类型转换不仅仅是简单的类型转换，而是能够在运行时表现出不同的行为。

示例代码

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function" << std::endl;
    }
    void derivedOnlyFunction() {
        std::cout << "Derived class specific function" << std::endl;
    }
};

void display(Base* basePtr) {
    basePtr->show();  // 调用虚函数
}

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 调用虚函数
    display(basePtr);  // 输出: Derived class show function

    return 0;
}

在这个示例中，display 函数接受一个基类指针，并调用该指针的 show 函数。由于 basePtr 实际上指向的是 derivedObj（一个子类对象），通过虚函数机制，display 函数调用的是 Derived 类的 show 函数，从而输出 "Derived class show function"。

总结

虚函数和指针类型转换在C++中紧密结合，使得多态性成为可能。虚函数机制通过虚函数表和虚函数指针，在运行时根据对象的实际类型调用相应的函数实现。指针类型转换（特别是向上转换）使得基类指针能够指向子类对象，并通过虚函数实现多态性。这种机制使得虚函数不仅仅是指针类型转换的一种高级表现，更是C++实现运行时多态性的重要手段。

为什么在基类中定义了一个非虚函数, 在子类中也定义了一个相同名字的非虚函数后,将子类对象指针赋值给基类对象指针后, 调用的这个非虚函数执行的是基类对象所指的非虚函数?

在C++中，当基类和子类中定义了同名的非虚函数时，函数的调用解析是基于指针或引用的静态类型（编译时类型）进行的，而不是基于对象的动态类型（运行时类型）。这意味着如果通过基类指针调用一个非虚函数，编译器会直接调用基类的版本，而不会调用子类的版本。这种行为称为静态绑定或早期绑定。

详细解释

  1. 静态绑定（Static Binding）：

    • 静态绑定是指在编译时决定函数调用的解析。对于非虚函数，编译器根据指针或引用的静态类型（即声明类型）来确定调用哪个函数。
    • 由于基类指针的静态类型是基类类型，编译器会解析并调用基类的非虚函数，即使指针实际指向的是子类对象。

  2. 动态绑定（Dynamic Binding）：

    • 动态绑定是指在运行时决定函数调用的解析。虚函数使用动态绑定，这意味着通过基类指针调用虚函数时，实际调用的是子类的实现（如果子类覆盖了该虚函数）。
    • 动态绑定通过虚函数表（vtable）和虚函数指针（vptr）实现。

示例代码

#include <iostream>

class Base {
public:
    void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 调用非虚函数
    basePtr->show();  // 输出: Base class show function

    return 0;
}

在这个示例中，Derived 类和 Base 类都定义了一个名为 show 的非虚函数。在 main 函数中，basePtr 是一个基类指针，指向 derivedObj（一个子类对象）。当通过 basePtr 调用 show 函数时，编译器在编译时确定 basePtr 的类型是 Base*，因此调用的是 Base 类的 show 函数，而不是 Derived 类的 show 函数。这就是静态绑定的表现。

如何实现动态行为

如果希望通过基类指针调用子类的实现，可以将函数声明为虚函数：

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 调用虚函数
    basePtr->show();  // 输出: Derived class show function

    return 0;
}

这个示例中，将 Base 类的 show 函数声明为虚函数（virtual），并在 Derived 类中覆盖它（override）。这样，通过基类指针调用 show 函数时，会进行动态绑定，调用子类的实现。

总结

当基类和子类中定义了同名的非虚函数时，通过基类指针调用该函数时，编译器会进行静态绑定，调用基类的版本。这是因为非虚函数的调用解析是基于指针或引用的静态类型（编译时类型）进行的。如果希望通过基类指针调用子类的实现，需要将函数声明为虚函数，从而利用动态绑定机制。

能否通过基类指针调用子类中同名的非虚函数？ 

在C++中，通过基类指针直接调用子类中同名的非虚函数是不可能的，因为非虚函数的调用是基于静态绑定（编译时绑定）的。编译器在编译时根据指针的静态类型（即声明类型）来决定调用哪个函数。因此，如果基类和子类中有同名的非虚函数，通过基类指针调用时，编译器只会调用基类的版本。

然而，有几种方法可以在运行时通过基类指针调用子类的同名非虚函数：

方法一：使用类型转换

使用 dynamic_cast 或 static_cast 将基类指针转换为子类指针，然后调用子类的非虚函数。这种方法需要确保转换是安全的。

#include <iostream>

class Base {
public:
    void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 使用 dynamic_cast 进行类型转换
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->show();  // 输出: Derived class show function
    } else {
        std::cout << "Type conversion failed" << std::endl;
    }

    return 0;
}

方法二：在基类中定义虚函数

将基类中的函数声明为虚函数，这样可以通过基类指针调用子类的实现。这是实现多态性的标准方法。

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 调用虚函数
    basePtr->show();  // 输出: Derived class show function

    return 0;
}

方法三：通过类型标识和手动调用

在基类中添加一个标识函数，用于标识对象的实际类型，然后通过该标识函数和静态类型转换手动调用子类的非虚函数。

#include <iostream>

class Base {
public:
    virtual ~Base() = default;  // 虚析构函数
    virtual bool isDerived() const { return false; }
    void show() {
        std::cout << "Base class show function" << std::endl;
    }
};

class Derived : public Base {
public:
    bool isDerived() const override { return true; }
    void show() {
        std::cout << "Derived class show function" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;  // 隐式向上转换

    // 使用类型标识和手动调用
    if (basePtr->isDerived()) {
        static_cast<Derived*>(basePtr)->show();  // 输出: Derived class show function
    } else {
        basePtr->show();  // 输出: Base class show function
    }

    return 0;
}

总结

通过基类指针直接调用子类的同名非虚函数是不可能的，因为非虚函数的调用是基于静态绑定的。然而，可以通过类型转换、将函数声明为虚函数、或使用类型标识和手动调用等方法来实现这一点。每种方法都有其适用场景和限制，选择合适的方法取决于具体的需求和设计。

C++,析构时,父类和子类是什么时候析构 

在 C++ 中，析构函数的调用顺序是非常明确的：当一个对象被销毁时，首先调用子类的析构函数，然后调用父类的析构函数。这确保了子类在销毁时能够正确地释放其资源，而父类在子类之后销毁，以便子类在其析构函数中仍然可以访问和使用父类的资源。

析构顺序示例

以下是一个简单的示例，展示了析构函数的调用顺序：

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj;
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

解释

  1. 当 new Derived() 被调用时，首先调用父类 Base 的构造函数，然后调用子类 Derived 的构造函数。
  2. 当 delete obj 被调用时，首先调用子类 Derived 的析构函数，然后调用父类 Base 的析构函数。

注意事项

  1. 虚析构函数：在基类中应当将析构函数声明为 virtual，以确保在通过基类指针删除派生类对象时能够正确调用派生类的析构函数。如果基类的析构函数不是虚函数，那么通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数，可能导致资源泄漏。
    class Base {
    public:
        virtual ~Base() {
            std::cout << "Base destructor" << std::endl;
        }
    };

  1. 删除非虚基类指针：如果你通过基类指针删除一个派生类对象，而基类的析构函数不是虚函数，可能会导致未定义行为。这种情况下，只会调用基类的析构函数，而不会调用派生类的析构函数。
    Base* obj = new Derived();
    delete obj; // 如果Base的析构函数不是虚函数，这将导致未定义行为

总结

在 C++ 中，当一个对象被销毁时，析构函数的调用顺序是先调用子类的析构函数，然后调用父类的析构函数。为了确保通过基类指针删除派生类对象时能够正确调用析构函数，基类的析构函数应当声明为虚函数。这样可以确保资源的正确释放，避免资源泄漏和未定义行为。

为什么在父类中的构造函数不用定义为虚函数?

在 C++ 中，构造函数不能被声明为虚函数。这是因为构造函数的主要职责是初始化对象，而在对象被完全构造之前，虚函数机制还没有完全建立起来。因此，构造函数不能是虚的。

详细解释

  1. 虚函数机制的建立：

    • 虚函数机制依赖于虚函数表（vtable），而虚函数表是在对象构造过程中建立的。
    • 在构造函数运行时，虚函数表还没有完全建立，特别是在基类的构造函数中。因此，无法在构造函数中使用虚函数机制。

  2. 对象的构造顺序：

    • 当创建一个派生类对象时，首先调用基类的构造函数，然后调用派生类的构造函数。
    • 在基类的构造函数中，派生类的部分还没有被初始化，因此无法调用派生类的虚函数。

  3. 设计哲学：

    • 构造函数的主要目的是初始化对象，而不是用来实现多态行为。
    • 多态行为通常在对象的生命周期内通过虚函数来实现，而不是在对象的构造阶段。

示例

考虑以下代码：

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
        // 虚函数调用在这里是无效的，因为派生类部分还没有被构造
        this->print();
    }

    virtual void print() const {
        std::cout << "Base print" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    void print() const override {
        std::cout << "Derived print" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj;
    return 0;
}

输出结果

Base constructor
Base print
Derived constructor
Derived destructor
Base destructor

解释

  1. 在 Base 的构造函数中调用 print() 时，调用的是 Base 类的版本，而不是 Derived 类的版本。这是因为在 Base 的构造函数执行时，Derived 部分还没有被构造。
  2. 当 delete obj 被调用时，首先调用 Derived 的析构函数，然后调用 Base 的析构函数。这是因为析构函数是虚函数，可以正确地实现多态行为。

总结

构造函数不能是虚函数的原因在于虚函数机制依赖于虚函数表，而虚函数表在对象构造过程中还没有完全建立。构造函数的主要职责是初始化对象，而不是用来实现多态行为。多态行为通常在对象的生命周期内通过虚函数来实现，而不是在对象的构造阶段。

那析构函数为什么在通过基类指针删除子类对象时,不会自动调用子类的析构函数,必须通过将基类析构函数作为虚函数时,才能先子类的析构函数然后再基类的析构函数?

在 C++ 中，析构函数的调用顺序是一个关键的设计考虑，特别是在涉及继承和多态的情况下。为了理解为什么需要将基类的析构函数声明为虚函数，首先需要了解一些关于对象销毁和多态性的重要概念。

非虚析构函数的问题

当你通过基类指针删除一个派生类对象时，如果基类的析构函数不是虚函数，那么只会调用基类的析构函数，而不会调用派生类的析构函数。这会导致派生类的资源没有被正确释放，可能会引起资源泄漏和其他未定义行为。

示例
#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj;  // 只会调用 Base 的析构函数
    return 0;
}

输出结果

Base constructor
Derived constructor
Base destructor

可以看到，Derived 类的析构函数没有被调用，这会导致 Derived 类中分配的任何资源都不会被释放。

虚析构函数的解决方案

通过将基类的析构函数声明为虚函数，可以确保在通过基类指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数。这保证了所有资源都能被正确释放。

示例
#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj;  // 先调用 Derived 的析构函数，然后调用 Base 的析构函数
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

解释

  1. 虚函数机制：虚函数机制依赖于虚函数表（vtable）。当一个对象被销毁时，虚函数表确保调用的是实际对象类型的析构函数。
  2. 多态性：通过将基类的析构函数声明为虚函数，可以实现多态性。在运行时，虚函数表会确保调用派生类的析构函数，然后再调用基类的析构函数。
  3. 资源管理：这确保了派生类的资源能够被正确释放，然后基类的资源也能被正确释放，避免了资源泄漏和未定义行为。

总结

将基类的析构函数声明为虚函数是为了确保在通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，然后再调用基类的析构函数。这是实现多态性和正确资源管理的关键步骤，确保所有资源都能被正确释放，避免资源泄漏和其他未定义行为。

如果只是通过子类指针去调用析构函数,就不存在这个问题了?

是的，如果你通过子类指针来删除对象，那么即使基类的析构函数不是虚函数，也不会存在资源泄漏的问题，因为在这种情况下，编译器会直接调用子类的析构函数，然后再调用基类的析构函数。

示例

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Derived* obj = new Derived();
    delete obj;  // 调用 Derived 的析构函数，然后调用 Base 的析构函数
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

解释

在这个例子中，delete obj 通过子类 Derived 的指针删除对象，编译器知道 obj 是一个 Derived 类型的对象，因此会调用 Derived 的析构函数，然后调用 Base 的析构函数。这保证了所有资源都能被正确释放。

为什么需要虚析构函数

尽管通过子类指针删除对象可以避免资源泄漏的问题，但在实际编程中，我们常常使用基类指针来操作对象，特别是在涉及多态的时候。例如：

void deleteObject(Base* obj) {
    delete obj;  // 如果 Base 的析构函数不是虚函数，可能会导致资源泄漏
}

int main() {
    Base* obj = new Derived();
    deleteObject(obj);  // 通过基类指针删除对象
    return 0;
}

在这种情况下，如果 Base 的析构函数不是虚函数，delete obj 只会调用 Base 的析构函数，而不会调用 Derived 的析构函数，这会导致 Derived 类的资源没有被正确释放。

解决方案

为了确保在通过基类指针删除派生类对象时能够正确调用析构函数，基类的析构函数应当声明为虚函数：

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

void deleteObject(Base* obj) {
    delete obj;  // 现在可以正确调用 Derived 的析构函数，然后调用 Base 的析构函数
}

int main() {
    Base* obj = new Derived();
    deleteObject(obj);
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

总结

尽管通过子类指针删除对象不会导致资源泄漏的问题，但在实际编程中，我们经常使用基类指针来操作对象，特别是在涉及多态的情况下。为了确保在通过基类指针删除派生类对象时能够正确调用析构函数，基类的析构函数应当声明为虚函数。这是实现安全和正确资源管理的关键步骤。

为什么通过子类指针删除对象会直接调用子类的析构函数，然后再调用基类的析构函数？

通过子类指针删除对象时，编译器能够确定对象的实际类型是子类，因此它会直接调用子类的析构函数，然后再调用基类的析构函数。这是因为在对象的生命周期结束时，析构函数的调用顺序需要确保所有资源都能被正确释放。

构造和析构的顺序

  1. 构造顺序：

    • 当创建一个派生类对象时，首先调用基类的构造函数，然后调用派生类的构造函数。
    • 这种顺序确保基类部分在派生类部分之前被正确初始化。

  2. 析构顺序：

    • 当销毁一个派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数。
    • 这种顺序确保派生类部分的资源在基类部分之前被正确释放。

示例解释

考虑以下代码：

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Derived* obj = new Derived();
    delete obj;  // 调用 Derived 的析构函数，然后调用 Base 的析构函数
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

解释

  1. 构造过程：

    • 当创建 Derived 对象时，首先调用 Base 的构造函数，然后调用 Derived 的构造函数。
    • 输出结果显示先调用了 Base constructor，然后是 Derived constructor。

  2. 析构过程：

    • 当通过 delete obj 删除 Derived 对象时，编译器知道 obj 是一个 Derived 类型的对象。
    • 因此，它会首先调用 Derived 的析构函数，然后调用 Base 的析构函数。
    • 输出结果显示先调用了 Derived destructor，然后是 Base destructor。

原因

这种析构顺序是为了确保派生类的资源能够在基类资源之前被正确释放。例如，如果派生类中有一些资源依赖于基类的资源，那么在销毁这些资源时，必须保证派生类的资源先被释放，然后基类的资源再被释放。

内存管理和资源释放

考虑一个更复杂的例子，其中派生类和基类都分配了一些动态内存：

#include <iostream>

class Base {
public:
    Base() {
        data = new int[10];
        std::cout << "Base constructor" << std::endl;
    }

    ~Base() {
        delete[] data;
        std::cout << "Base destructor" << std::endl;
    }

private:
    int* data;
};

class Derived : public Base {
public:
    Derived() {
        moreData = new int[20];
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() {
        delete[] moreData;
        std::cout << "Derived destructor" << std::endl;
    }

private:
    int* moreData;
};

int main() {
    Derived* obj = new Derived();
    delete obj;  // 调用 Derived 的析构函数，然后调用 Base 的析构函数
    return 0;
}

输出结果

Base constructor
Derived constructor
Derived destructor
Base destructor

解释

  1. 构造过程：

    • Base 构造函数分配了一个 int 数组。
    • Derived 构造函数分配了另一个 int 数组。

  2. 析构过程：

    • 当删除 Derived 对象时，首先调用 Derived 的析构函数，释放 moreData 数组。
    • 然后调用 Base 的析构函数，释放 data 数组。

这种顺序确保了所有资源都能被正确释放，避免了资源泄漏和未定义行为。

总结

通过子类指针删除对象时，编译器能够确定对象的实际类型，因此会直接调用子类的析构函数，然后再调用基类的析构函数。这种析构顺序确保了派生类的资源在基类资源之前被正确释放，避免了资源泄漏和其他潜在问题。这也是为什么在多态情况下，基类的析构函数需要声明为虚函数，以确保通过基类指针删除对象时能够正确调用派生类的析构函数。

blueman8888
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++拾遗--虚函数表
CCPP Blog
02-25 1924
C++拾遗--虚函数原理 前言 C++的多态依赖虚函数来实现。若类存在虚函数，则每一个类的实例都维护了一个地址，这个地址指向虚函数表。虚函数表中存放的是类中所有虚函数的地址。下面我们找出虚函数表的地址，从而获得每个虚函数的地址，然后使用地址直接调用虚函数。 正文 1.空类的size
C++ 虚函数专题
12-17
C++的虚函数是面向对象编程中的一个重要特性，它允许我们使用父类的指针调用子类重写的函数，从而实现多态性。在C++中，虚函数的声明通常是在基类中使用`virtual`关键字来完成的。例如： ```cpp class Base { ...
【C++拾遗】 C++虚函数实现原理
xuchenhuics的专栏
03-08 417
转自：http://blog.csdn.net/Xiejingfa/article/details/50454819我们知道，与C语言相比，C++在布局和存取时间上的额外开销主要是由虚函数（virtual function）机制和虚继承（virtual base class）机制引起的。在前面一篇文章中，我们从内存布局的角度入手，分析了虚继承的实现原理，传送门：从内存布局看C++虚继承的实现原理。...
C++ 拾遗
Algo_x的博客
01-02 769
宏是在预处理阶段进行文本替换的，即在代码被编译之前。宏通常是简单的字符串替换，它将代码中的宏名称替换为宏定义的文本。宏的替换是简单的文本替换，不进行类型检查。这可能导致一些问题，因为宏不关心数据类型，可能引入潜在的错误。由于是文本替换，宏可能会生成较大的代码。每次使用宏时，都会复制宏的内容，可能导致代码膨胀。宏不涉及函数调用，因此不需要调用栈。宏只是简单地进行文本替换。inline。
c++拾遗
愿有人陪你颠沛流离！
03-13 666
c++11特性与一些c++八股文
C++ 沧海拾遗
莫彩的博客
04-21 113
Tricks emplace_back优于push_back some_str.find(“abccde”) != std::string::npos iter = some_set.erase(iter); 实践中提高vector性能的要点是尽量使用reserve（仅次于换编译器和STL实现）。运行期依然不能确定数组的个数，明智的选择是什么也不做，push_back/emplace_back就足够；运行期能确定个数，则应该用reserve，不建议用传递大小的数组构造函数或者调用resize。 vecto
C++之沧海拾遗
qq_36570733的博客
02-24 303
这篇博客纯粹是本人总结的一些细节问题，大佬们想必都了解，但想到还有千千万万和本人一样执着于细节的同志，我决定把这些知识点逐个记录下来。 本篇博客既然为拾遗，内容还是比较杂的，主要包括以下几方面：1)友元类和友...
虚函数表拾遗
u013447092的博客
12-21 379
析构的顺序与之相反，派生类析构函数运行完之后虚函数表指向基类的虚函数表， 基类的虚函数表运行完之后虚函数表彻底释放。如果在构造函数中调用虚函数，会先调用父类中的实现，也就失去了多态的性质。基类A的析构函数开始运行时，也就是说基类析构函数运行前派生类析构函数开始运行前，虚函数表发生改变。基类A的构造函数开始运行后（进入构造函数），也就是进入函数前已经把改类的虚函数表构建完成。派生类B的构造函数开始运行后，虚函数表指向了派生类虚函数地址。此时虚函数表的函数都指向基类的地址。
C++沙海拾遗（五）
weixin_38898944的博客
07-13 271
关于面向对象的一些概念和细节
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++ 虚函数的详解及简单实例
01-01
C++ 虚函数的详解 虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义...
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
C++虚函数的实现机制分析
01-01
本文针对C++的虚函数的实现机制进行较为深入的分析，具体如下： 1、简单地说，虚函数是通过虚函数表实现的。那么，什么是虚函数表呢？ 事实上，如果一个类中含有虚函数，则系统会为这个类分配一个指针成员指向一张虚...
const char* 和char* 之间的转换
热门推荐
BlueMan
04-15 1万+
const char* 和char* 之间的转换     const char*是指向常量的指针,而不是指针本身为常量,可以不被初始化.该指针可以指向常量也可以指向变量,只是从该指针的角度而言,它所指向的是常量，通过该指针不能修改它所指向的数据.  1.const char*是不能直接赋值到char*的,这样编译都不能通过,理由:假如可以的话,那么通过char*就可以修改const char指向的内容了,这是不允许的.所以char*要另外开...
c语言实现CRC校验和
BlueMan
01-20 5238
最近在摄像头采集的数据清晰度上需要加强，则在每一帧传输的数据包后边加了CRC校验和。CRC校验和有16位的，也有32位的。至于CRC校验和算法原理，我是在百度上学习的，其实网上有很多这种资料。简单的说就是CRC校验和就是将一段二进制数据进行加密（乘以一个多项式），然后得到一个校验码。将这个校验码添加在这段二进制数据后边就行了。然后接收方在接收到数据之后，再对这个校验码进行解码。 下面我就将今天的d.........
C++解方程组的库
最新发布
BlueMan
04-26 1282
请注意，Eigen的非线性优化模块并不包含真正的BFGS实现，而是提供了Levenberg-Marquardt算法，它更适合于非线性最小二乘问题。它支持多种类型的矩阵运算，包括求解线性方程组。对于更复杂的问题，你可能需要更高级的数值优化库，如Ceres Solver或NLopt，它们提供了更多的优化算法和更好的稳定性。这个示例中，我们定义了一个非线性方程组和它的雅可比矩阵，然后使用牛顿法进行迭代求解。请注意，这个模块是Eigen的一部分，但并不属于其稳定的官方API，因此在未来的版本中可能会有所变化。
16进制输出补齐
BlueMan
07-17 1259
int PrintVal = 9; /*按整型输出，默认右对齐*/ printf("%d\n",PrintVal); /*按整型输出，补齐4位的宽度，补齐位为空格，默认右对齐*/ printf("%4d\n",PrintVal); /*按整形输出，补齐4位的宽度，补齐位为0，默认右对齐*/ printf("%04d\n",PrintVal); /*按16进制输出，默认右对齐*/ printf("%x\n",PrintVal); ...
VS中设置dll文件加载路径
BlueMan
10-23 1245
当存在多个dll路径时，需按图示要求保证计算的值如图格式所示，计算的值：PATH=%PATH%;或者PATH=路径;由于qt路径为继承的值，所以将其“从父级或项目默认机床”√取消。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值