第19课构造函数（下）

1. 两个特殊的构造函数
　　-无参构造函数
　　　　没有参数的构造函数
　　　　解释：无参构造函数看似非常简单，但是它就特别在它是必须存在的。因为我们要使用一个类的话，就必须创建对象。创建对象必然牵涉到构造函数的调用。
　　　　注意：当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且函数体为空。一定要特别注意，当类中没有构造函数时，编译器才会提供，否则不会提供。
　　-拷贝构造函数
　　　　参数为const class_name&的构造函数
　　　  （判断一个构造函数是不是拷贝构造函数的依据：1、const 2、当前类对象的引用）只要看到这样的参数出现在一个构造函数里面，它必然的就是一个拷贝构造函数了。

　　　　当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。

#include <stdio.h>

class Test
{
private:
    int i;
    int j;
public:
    int getI()
    {
        return i;
    }
    int getJ()
    {
        return j;
    }
    /*Test(const Test& t)
    {
        i = t.i;
        j = t.j;
    }
    Test()
    {
    }*/
};

int main()
{
    Test t1;
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d
", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d
", t2.getI(), t2.getJ());
    
    return 0;
}

在上面这个例子中，一旦定义了

Test(const Test& t)
{
       i = t.i;
       j = t.j;
}
那么Test t1;就会出错。为什么？
因为找不到一个Test()的构造函数。
问题：不是编译器会默认提供一个无参构造函数吗？
一定要注意，编译器提供默认构造函数的前提，就是类中没有构造函数，一旦拥有，编译器就不再提供。

呈现一个经典面试题，下面的这个类，它里面有什么东西？

class T

{

};

它里面至少有一个无参构造函数，是编译器提供的。

2. 拷贝构造函数的意义

-兼容C语言的初始化方式
　　　　例如：int i =2; int j = i;
　　　　　　   Test t1; Test t2 = t1;
-初始化行为能够符合预期的逻辑

-浅拷贝
　　拷贝后对象的物理状态相同
-深拷贝
　　拷贝后对象的逻辑状态相同

编译器提供的拷贝构造函数只进行浅拷贝。

#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;
    }30     Test(int v)
    {
        i = 1;
        j = 2;
        p = new int;
        
        *p = v;
    }42 };

int main()
{
    Test t1(3);
    Test t2(t1);
    
    printf("t1.i = %d, t1.j = %d, *t1.p = %p
", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, *t2.p = %p
", t2.getI(), t2.getJ(), t2.getP());54     
    return 0;
}

上面的这个程序，编译会顺利通过。并且你会看到一个现象，t1对象的p和t2对象的p指向了同一段堆空间。你是不是想，这是肯定的啊。因为我就是用t1初始化t2，这正是我想要的结果。但是根据经验，p是在堆上生成的，当我们不用的时候，需要将其释放掉。如下面的代码所示：

#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;
    }30     Test(int v)
    {
        i = 1;
        j = 2;
        p = new int;
        
        *p = v;
    }
    void free()
39     {
40         delete p;
41     }
};

int main()
{
    Test t1(3);
    Test t2(t1);
    
    printf("t1.i = %d, t1.j = %d, *t1.p = %p
", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, *t2.p = %p
", t2.getI(), t2.getJ(), t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

编译就会出错，因为我们释放了两次相同堆空间中的内存。t1中的p和t2中的p指向了同一段堆空间。

如何解决这个问题？

应该手工来提供一个拷贝构造函数

#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;  //p的值就不能直接复制了，需要重新到堆空间中申请。申请完之后，将t1对象中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 = %p
", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, *t2.p = %p
", t2.getI(), t2.getJ(), t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

什么时候需要进行深拷贝？
-对象中有成员指代了系统中的资源
　　成员指向了动态内存空间
　　成员打开了外存中的文件
　　成员使用了系统中的网络端口
　　...

一般性原则
自定义拷贝构造函数，必然需要实现深拷贝

数组类的改进：

IntArray.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

IntArray.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
", 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
", i, value);
        }
    }
    
    a.free();
    b.free();
    
    return 0;
}