C++（虚构造与虚析构/类型信息运算符/强制类型转换）

最新推荐文章于 2024-09-13 17:43:09 发布

羊十一

最新推荐文章于 2024-09-13 17:43:09 发布

阅读量411

点赞数 4

文章标签： c++ 开发语言算法

本文链接：https://blog.csdn.net/weixin_65029285/article/details/142206930

版权

一、虚构造与虚析构

1、构造函数能否是虚函数，为什么？

对象有创建过程：

1、给对象分配内存

2、根据继承表顺序调用父类构造

3、根据成员对象的的定义顺序调用成员对象的构造函数

4、执行对象自己的构造函数

如果父类的构造函数函数设计成虚函数并且被子类覆盖（如果虚函数没有被覆盖就设计的没有意义），当创建子类对象时，先调用父类的虚构造，但此时实际对象是子类对象，根据多态的特性此时会转而执行子类的构造（调用虚函数表中覆盖后的版本），但执行子类构造函数前需要先执行父类构造，这样就形成了死循环，所以构造函数不能设计成虚函数。

#include <iostream>
using namespace std;

class Base
{
public:
    // error: constructors cannot be declared virtual [-fpermissive] virtual Base(void)
    virtual Base(void)
    {
        cout << "Base构造函数" << endl;
    }
};
class Test: public Base
{
public:
    Test(void)
    {
        cout << "Test构造函数" << endl;
    }
};

int main(int argc,const char* argv[])
{
    return 0;
}

2、析构函数能否是虚函数，为什么？

对象的释放过程：

1、执行对象自己的析构函数

2、根据成员对象的创建过程逆序执行成员对象的析构函数

3、根据继承表的顺序逆序执行父类的析构函数

4、释放对象的内存

假如父类的析构函数设计成虚函数并且被子类覆盖，当释放子类对象时，先执行子类对象的析构函数，然后执行父类对象的析构函数，此时子类对象已经被释放完毕，所以无法形成多态，只会执行父类的析构函数，不会产生任何错误，所以析构函数可以是虚函数。

3、什么情况需要设计虚析构

当使用类多态时，使用父类指针、引用去释放子类对象时，如果析构函数没有设计成虚函数(没有覆盖)，那么将只执行父类的析构函数（无法调用子类的析构函数），如果子类中有指针成员且指向堆内存，这种情况下就会造成内存泄漏。

注意：当使用类多态时，且子类成员中有指针指向堆内存，必须要把父类的析构函数设计成虚函数（或者子类的析构函数中有必须要完成的工作时）。

#include <iostream>
using namespace std;

class Base
{
public:
    Base(void)
    {
        cout << "Base的构造函数" << endl;
    }
    virtual ~Base(void)
    {
        cout << "Base的析构函数" << endl;
    }
    virtual void func(void)
    {
        cout << "我是Base类的func函数" << endl;
    }
};

class Test : public Base
{
    int* ptr;
public:
    Test(void)
    {
        ptr = new int;
        cout << "alloc" << ptr << endl;
    }
    ~Test(void)
    {
        delete ptr;
        cout << "free" << ptr << endl;
    }
    void func(void)
    {
        cout << "我是Test类的func函数" << endl;
    }
};

int main(int argc,const char* argv[])
{
    Base* x = new Test;
    x->func();
    delete x;
    return 0;
}

总结：构造函数不能是虚函数，否则会形成死循环，析构函数可以设计成虚函数，在使用类多态时，如果不把析构函数设计成虚函数，则子类的析构不会被调用，也就说在使用类多态时，子类的析构函数想要执行，则需要把父类的析构设计成虚函数。

二、类型信息运算符

1、什么类型信息运算符

C++中有这个typeid关键字，用于获取数据的类型信息。

2、类型信息运算符的作用。

当我们使用类多态时，我们很难通过肉眼识别出对象的真实类型（特别是在使用工厂模式时），如果父子类形成了多态，使用typeid就可以获取到对象的真实类型。

以及判断是否函数，还是函数指针，判断标识符是否指针变量、是否是二级指针。

3、使用方法

1、需要包含头文件 #include <typeinfo> 并且它设计在std名字空间内。

2、typeid(数据) 会返回一个记录数据类型信息的type_info类型的类对象。

3、type_info 有一个name成员函数，会以字符串形式返回类型的名字：

1、基本类型返回类型的缩写

2、指针类型以P开头

3、带const属性的，名字中会带K

4、复合类型的会返回长度+名字

5、如果父类引用指向了子类对象，只要父类中定义的虚函数，typeid就可以识别出真实的对象类型。

6、如果父类指针指向了子类对象，父类中定义的虚函数，typeid(*指针)才可以识别出真实的对象类型。

4、type_info 有一些成员函数和运算符函数：

判断一个标识符是否是指针变量，__is_pointer_p() 判断一个标识符是否是函数， __is_function_p()

#include <typeinfo>
using namespace std;

struct Student
{

};

class Base
{
public:
    virtual void func(void)
    {

    }
};

class Test : public Base
{
};

int main(int argc,const char* argv[])
{
    cout << typeid(char).name() << endl;
    cout << typeid(short).name() << endl;
    cout << typeid(int).name() << endl;

    Student s;
    cout << typeid(s).name() << endl;

    Test t;
    Base& b = t;
    cout << typeid(b).name() << endl;

    Base* p = new Test;
    cout << typeid(p).name() << endl;
    cout << typeid(*p).name() << endl;

    cout << typeid(main).__is_function_p() << endl;
    cout << typeid(p).__is_pointer_p() << endl;

    cout << (typeid(t) == typeid(b)) << endl;
    cout << (typeid(t) != typeid(b)) << endl;

    return 0;
}