最全面的c++中类的构造函数高级使用方法及禁忌
cpp加油站 143 4

说明一下,我用的是gcc7.1.0编译器,标准库源代码也是这个版本的。

本篇文章讲解c++中,构造函数的高级用法以及特殊使用情况。

1. 拷贝构造和移动构造区别

对于拷贝构造和移动构造,还是看一下这段代码:

#include <iostream>
#include <string.h>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        //without param constructors
        CPtr()
        {
            m_iSize = 1024;
            m_pData = new char[m_iSize];
        }
        ~CPtr()
        {
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
        //with param constructors
        CPtr(const int p_iSize)
        {
            m_iSize = p_iSize;
            m_pData = new char[p_iSize];
        }
        //copy constructors
        CPtr(const CPtr& ptr)
        {
            if (ptr.m_pData != nullptr)
            {
                m_iSize = strlen(ptr.m_pData)+1;
                m_pData = new char[m_iSize];
                strncpy(m_pData, ptr.m_pData, m_iSize-1);
            }
        }
        //move constructors
        CPtr(CPtr&& ptr)
        {
            m_pData = ptr.m_pData;
            m_iSize = ptr.m_iSize;
            ptr.m_pData = nullptr;
            ptr.m_iSize = 0;
        }
        //赋值函数
        CPtr& operator=(const CPtr& ptr)
        {
            //注意,这里delete一下是非常重要的,否则如果一个CPtr对象多次调用赋值函数的话就会发生内存泄露
            //这个地方我原来也没有注意,后来是一位知友指出来了,这里要感谢这位知友的指出
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
            if (ptr.m_pData != nullptr)
            {
                m_iSize = strlen(ptr.m_pData)+1;
                m_pData = new char[m_iSize];
                strncpy(m_pData, ptr.m_pData, m_iSize-1);
            }
            return *this;
        }    
        //移动赋值函数
        CPtr& operator=(CPtr&& ptr)
        {
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
            m_pData = ptr.m_pData;
            m_iSize = ptr.m_iSize;
            ptr.m_pData = nullptr;
            ptr.m_iSize = 0;
            return *this;
        }
        void setData(const char* str)
        {
            if (  str == nullptr)
            {
                cout << "str is nullptr" << endl;
                return;
            }
            if ( m_iSize == 0)
            {
                cout << "the memory is nothing" << endl;
                return;
            }
            int iSize = strlen(str);
            if ( iSize < m_iSize )
            {
                strncpy(m_pData, str, iSize);
            }
            else
            {
                strncpy(m_pData, str, m_iSize-1);
            }
        }
        void print(const char* object)
        {
            cout << object << "'s data is " << m_pData << endl;
        }
};

int main()
{
    CPtr p1(1024);
    p1.setData("lilei and hanmeimei");
    p1.print("p1");
    CPtr p2(p1);
    p2.print("p2");
    CPtr p3 = p1;
    p3.print("p3");
    CPtr p4(move(p1));
    p4.print("p4");
    CPtr p5 = move(p2);
    p5.print("p5");
    return 0;
}

根据以上代码,我们可以总结出如下两点:

  • 拷贝构造从拷贝类型上讲,是属于深拷贝,它会重新申请一块新的内存,并把另外一个对象的内容完全复制过来,且不会破坏另外一个对象的内容;
  • 移动构造从拷贝类型上讲,是属于浅拷贝,按照字面意思,它就是把另外一个对象的内容移动到当前对象来,至于之前的对象,我们不确保它还是可用的,移动构造一般用于对象数据需要保存,而对象则需要丢弃的情况;

2. 构造函数是否可以为虚函数

答案是不可以,看如下代码:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        virtual CPtr()
        {
            m_iSize = 1024;
            m_pData = new char[m_iSize];
        }
        ~CPtr()
        {
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
};

int main()
{
    return 0;
}

编译后报错:错误:constructors cannot be declared ‘virtual’,可见构造函数是不能声明为virtual的,这与虚函数的机制有关,虚函数是存放在虚表的,而虚表是在构造函数执行完成以后才建立的,构造函数声明为virtual就会陷入到是先有鸡还是先有蛋的尴尬境地,所以编译器做了限制。

3. 构造函数是否可以抛出异常

答案是可以,看如下代码:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call constructors" << endl;
            m_iSize = 1024;
            m_pData = new char[m_iSize];
            if ( m_iSize > 0)
            {
                throw 1024;
            }
        }
        ~CPtr()
        {
            cout << "call Destructor" << endl;
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
};

int main()
{
    try
    {
        CPtr p1;
    }
    catch(...)
    {
        cout << "throw something" << endl;
    }
    return 0;
}

编译可以通过,说明构造函数允许抛出异常,但是这里有个隐含的问题,我们执行一下程序,结果如下:

call constructors
throw something

可以看到没有执行析构函数,那如果构造函数在申请动态内存以后抛出异常,就会出现内存泄露的问题,那么为什么没有执行析构函数呢,因为构造函数没有执行完成,相当于对象都还没有建立,何谈执行虚构函数呢,我们应该在构造函数抛出异常前,把所有动态内存先释放掉。

代码改为如下:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call constructors" << endl;
            m_iSize = 1024;
            m_pData = new char[m_iSize];
            if ( m_iSize > 0)
            {
                delete []m_pData;
                m_pData = nullptr;
                throw 1024;
            }
        }
        ~CPtr()
        {
            cout << "call Destructor" << endl;
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
};

int main()
{
    try
    {
        CPtr p1;
    }
    catch(...)
    {
        cout << "throw something" << endl;
    }
    return 0;
}

总结:构造函数可以抛出异常,若有动态分配内存,则要在抛异常之前手动释放。

4. c++11增加的=default和=delete用法

还是先看一段代码:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call constructors" << endl;
            m_iSize = 1024;
            m_pData = new char[m_iSize];
        }
        ~CPtr()
        {
            cout << "call Destructor" << endl;
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
        CPtr(CPtr &) =delete;
        CPtr(CPtr &&) = default;
};

int main()
{
    CPtr p1;
    CPtr p2(p1);
    CPtr p3(move(p1));
    return 0;
}

编译时报错如下:

test.cpp: 在函数‘int main()’中:
test.cpp:32:12: 错误:使用了被删除的函数‘CPtr::CPtr(CPtr&)’
  CPtr p2(p1);

说明声明为=delete以后不再允许调用,去掉p2的定义,则编译通过,但此时执行的话,还是会报double free的问题,因为p3调用一次析构,p1调用一次析构,就double free啦。

实际上,=delete就相当于以前在private里面声明,即声明为=delete以后则不再允许调用,而声明为=default以后,则告诉编译器,你帮我自动生成一下吧,我懒得去实现它了,但结合上面的问题,在存在动态内存的class里面使用移动构造就要小心了,一不小心就会出现问题哦,具体移动构造怎么实现可以参考上面第一点中的代码。

5. 继承时构造函数执行顺序

代码为先,如下:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        char *m_pData;
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call base constructors" << endl;
            m_iSize = 1024;
            m_pData = new char[m_iSize];
        }
        ~CPtr()
        {
            if ( m_pData != nullptr )
            {
                delete []m_pData;
                m_pData = nullptr;
            }
        }
};

class CSon:public CPtr
{
    public:
        CSon()
        {
            cout << "call son constructors" << endl;
        }
};

int main()
{
    CSon son;
    return 0;
}

编译后执行结果如下:

call base constructors
call son constructors

所以对于子类对象而言,是先执行父类构造函数,再执行子类构造函数,那这里再思考一下上面第二点,如果构造函数可以为虚函数,那根据多态规则,父类的构造函数将不会被执行,这也是不成立的。

6. 什么情况下必须使用构造函数初始化列表而不能赋值

有这样一段代码:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        const int m_iSize;
    public:
        CPtr()
        {
            m_iSize = 2;
        }
};

int main()
{
    return 0;
}

我们猜猜看编译这段代码会报错吗,答案是会报错,报错信息如下:

test.cpp: 在构造函数‘CPtr::CPtr()’中:
test.cpp:9:3: 错误:uninitialized const member in ‘const int’ [-fpermissive]
   CPtr()
   ^~~~
test.cpp:7:13: 附注:‘const int CPtr::m_iSize’ should be initialized
   const int m_iSize;
             ^~~~~~~
test.cpp:11:14: 错误:向只读成员‘CPtr::m_iSize’赋值
    m_iSize = 2;
              ^

有两个报错,一个是未初始化常量成员,二个是向只读成员赋值。

实际上,我们这里首先应该思考一下初始化列表和赋值有什么区别,初始化列表其实相当于调用一次构造函数,而赋值呢,是首先调用一次构造函数,然后再调用赋值函数,相当于先声明,然后又定义一次,但我们初次接触c++的时候就应该知道有些类型是必须要声明的时候就有初值的,这里我想到的有以下类型:

  • const声明的变量,必须要有初值;
  • reference引用声明的变量,必须要有初值;
  • 没有默认构造函数但存在有参构造函数的类,它必须初始化的时候给一个入参。

以上三种情况都必须使用初始化列表而不能在构造函数中进行赋值。

7. 什么构造函数会在main函数之前执行

想当年面试的时候我想破头都想不出来这个问题,因为main函数是程序入口嘛,但其实这个问题很简单,根据程序的执行规则,在main函数之前,会先处理全局变量和局部静态变量,那就很清晰了,在main函数执行以前,全局变量和静态变量的构造函数会先执行。

还是用一段代码来佐证:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call CPtr constructors" << endl;
            m_iSize = 2;
        }
};

CPtr ptr;
int main()
{
    static CPtr ptr1;
    cout << "exec main() " << endl;
    return 0;
}

执行后,输出如下:

call CPtr constructors
call CPtr constructors
exec main()

所以答案是全局变量和静态变量的构造函数会在main函数之前执行。

同理,如果发现程序崩溃,而调试的时候发现还没开始main函数的执行,那么就要检查一下是否有全局变量或者静态变量的构造函数崩溃了。

8. 怎么防止类对象被拷贝和赋值

防止类对象被拷贝和赋值,换句话说,就是不能调用类的拷贝函数和赋值运算符重载函数,我们首先能想到的就是把这两个函数声明为private的,或者私有继承一个基类,而到了c++11,又多了一种办法,就是把构造函数加=delete,这里就不给代码了,具体的可以参考上面第4点。

9. 是否可以在构造函数中调用虚函数

答案是可以,首先看这段代码:

#include <iostream>
using namespace std;

class CPtr
{
    private:
        int m_iSize;
    public:
        CPtr()
        {
            cout << "call CPtr constructors" << endl;
            m_iSize = 2;
            print();
        }
        virtual void print()
        {
            cout << "call virtual function" << endl;
        }
};

int main()
{
    CPtr ptr1;
    return 0;
}

编译执行结果如下:

call CPtr constructors
call virtual function

对于这个类本身而言,其实是否虚函数没有区别,下面看看如果是继承,子类构造函数中调用虚函数会发生什么:

#include <iostream>
using namespace std;

class CPtr
{
    public:
        CPtr()
        {
            cout << "call CPtr constructors" << endl;
        }
        virtual void print()
        {
            cout << "call virtual function" << endl;
        }
};

class CSon:public CPtr
{
    public:
        CSon()
        {
            cout << "call CSon constructors" << endl; 
            print();
        }
        virtual void print()
        {
            cout << "call son virtual function" << endl;
        }
};

int main()
{
    CPtr* son = new CSon;
    delete son;
    return 0;
}

编译执行后结果如下:

call CPtr constructors
call CSon constructors
call son virtual function

再把子类的print函数注释掉,再次执行,结果如下:

call CPtr constructors
call CSon constructors
call virtual function

也就是说,对于子类而言,在构造函数中调用虚函数也是调用的它自身的函数,而当子类没有实现的时候才调用父类的虚函数,这一幕是不是很熟悉,实际上就是发生了多态的效果,通过gdb跟踪CSon的构造函数,输出当前对象的数据,如下:

(gdb) p *this
$2 = (CSon) {<CPtr> = {_vptr.CPtr = 0x400dd0 <vtable for CSon+16>}, <No data fields>}

实际上构造函数执行的同时虚表已经建立了,那虚表既然建立了,必然就会发生多态呀。

综上,不论是基类还是继承类,他们的构造函数中都可以直接调用虚函数。

评论区

索引目录