第19课 对象的构造（下）

特殊的构造函数：

示例如下：

#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;
}

17-24行就是编译器替我们提供的默认构造函数和拷贝构造函数。

运行结果如下：

 可以看到t1和t2中i和j的值是一样的。

当我们的类中没有编写任何的构造函数时，编译器才会给我们提供默认的构造函数，拷贝构造函数是构造函数的一种。

拷贝构造函数：

兼容C语言的方式类似于 Test t1 = t2这种初始化方式，就是用一个已存在的对象t2来初始化t1，这时候就会调用拷贝构造函数。

拷贝构造函数的玄机：

对象的初始化实验：

我们可以看到t1和t2对象中的p指向同一个内存地址。

 我们在构造函数中申请了内存，就应该释放，两个对象我们需要释放两次，因为两个对象的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;
    }
    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
", t1.getI(), t1.getJ(), *t1.getP());
    printf("t2.i = %d, t2.j = %d, *t2.p = %d
", t2.getI(), t2.getJ(), *t2.getP());
    
    t1.free();
    t2.free();
    
    return 0;
}

 22行的拷贝构造函数进行可深拷贝。第47行的初始化就会调用这个拷贝构造函数，我们也可以写成Test t2 = t1，意义是一样的，都会调用拷贝构造函数。

运行结果如下：

 t1和t2中的p指向的地址不一样，这称为它们的物理状态不一样，但是p指向的内存单元中的值是一样的，这称为逻辑状态相同。

深拷贝：

问题分析：这就是上面浅拷贝时程序崩溃的原因

一般性原则：

自定义拷贝构造函数时，必然需要实现深拷贝，要不然没有必要自定义拷贝构造函数。

数组类的改进：

#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

#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;
}

主程序如下：

#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;
}

上述程序中我们增加了拷贝构造函数，实现了深拷贝。

运行结果如下：

 小结：