C++（对象的构造-----第19课 （下））

1.特殊的构造函数

两个特殊的构造函数
无参构造函数：没有参数的构造函数
当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空
拷贝构造函数：参数为const class_name&的构造函数
当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制
 

2.拷贝构造函数

拷贝构造函数的意义
兼容C语言的初始化方式
初始化行为能够符合预期的逻辑
浅拷贝：拷贝后对象的物理状态相同—单纯赋值
深拷贝：拷贝后对象的逻辑状态相同
编译器提供的拷贝构造函数只进行浅拷贝

我们关注的是它有什么应用？

当我们拷贝类中的指针的时候，会发现copy的指针两个地址是一样的。这就会在释放地址空间的时候出现double free的问题。

所以我们才需要深拷贝，实例：

#include <stdio.h>
class Test
{
private:
    int i;
    int j;
    int* p;
public:
    int getI()
    {
        return i;
    }
    int getJ()
    {
        return j;
    }
    int* getP()
    {
        return p;
    }
    Test(const Test& t)
    {
        i = t.i;
        j = t.j;
        p = new int;
        
        *p = *t.p;
    }
    Test(int v)
    {
        i = 1;
        j = 2;
        p = new int;
        
        *p = v;
    }
    void free()
    {
        delete p;
    }
};
int main()
{
    Test t1(3);
    Test t2(t1);
    
    printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());
    printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}
运行结果
t1.i = 1, t1.j = 2, *t1.p = 3
t2.i = 1, t2.j = 2, *t2.p = 3

小结：以上是拷贝构造函数的一个应用哈！其实都是拷贝啦。

3.什么时候需要深拷贝

对象中有成员指代了系统中的资源
成员指向了动态内存空间
成员打开了外存中的文件
成员使用了系统中的网络端口

一般性原则
自定义拷贝构造函数，必然需要实现深拷贝
IntArray 数组类的改进

在上一节课中，对于数组安全性的问题中，在自己定义的构造函数中，申请了指针变量的数组。所以在copy的时候会有一定的问题。需要添加深拷贝。

实例：

.h文件

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int* m_pointer;
public:
    IntArray(int len);
    IntArray(const IntArray& obj);
    int length();
    bool get(int index, int& value);
    bool set(int index ,int value);
    void free();
};

#endif

.cpp文件

#include "IntArray.h"

IntArray::IntArray(int len)
{
    m_pointer = new int[len];
    
    for(int i=0; i<len; i++)
    {
        m_pointer[i] = 0;
    }
    
    m_length = len;
}

IntArray::IntArray(const IntArray& obj)
{
    m_length = obj.m_length;
    
    m_pointer = new int[obj.m_length];
    
    for(int i=0; i<obj.m_length; i++)
    {
        m_pointer[i] = obj.m_pointer[i];
    }
}

int IntArray::length()
{
    return m_length;
}

bool IntArray::get(int index, int& value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        value = m_pointer[index];
    }
    
    return ret;
}

bool IntArray::set(int index, int value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        m_pointer[index] = value;
    }
    
    return ret;
}

void IntArray::free()
{
    delete[]m_pointer;
}

main.cpp

#include <stdio.h>
#include "IntArray.h"

int main()
{
    IntArray a(5);    
    
    for(int i=0; i<a.length(); i++)
    {
        a.set(i, i + 1);
    }
    
    for(int i=0; i<a.length(); i++)
    {
        int value = 0;
        
        if( a.get(i, value) )
        {
            printf("a[%d] = %d\n", i, value);
        }
    }
    
    IntArray b = a;
    
    for(int i=0; i<b.length(); i++)
    {
        int value = 0;
        
        if( b.get(i, value) )
        {
            printf("b[%d] = %d\n", i, value);
        }
    }
    
    a.free();
    b.free();
    
    return 0;
}

小结：

C++编译器会默认提供构造函数
无参构造函数用于定义对象的默认初始状态
拷贝构造函数在创建对象时拷贝对象的状态
对象的拷贝有浅拷贝和深拷贝两种方式
浅拷贝使得对象的物理状态相同
深拷贝使得对象的逻辑状态相同