第19课

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

1. 特殊的构造函数

　　（1）无参构造函数

　　　　当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空。

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

2. 拷贝构造函数

2.1 拷贝构造函数的意义

　　（1）兼容 C 语言的初始化方式     int i = 1;    int j = i;

　　（2）初始化行为能够符合预期的逻辑

　　（3）深拷贝和浅拷贝

　　　　① 浅拷贝：拷贝后对象的物理状态相同  【编译器提供的拷贝构造函数只提供浅拷贝】

　　　　② 深拷贝：拷贝后对象的逻辑状态相同

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

    ~Test(){delete p;}
    
};

int main()
{
    Test t1(3);  //调用Test(int v);
    Test t2(t1); //调用Test(const Test& t)

    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());

    return 0;
}

2.2 什么时候需要进行深拷贝？

　　（1）对象中有成员指向了系统中的资源

• • 成员指向了动态内存空间
  • 成员打开了外存中的文件
  • 成员使用了系统中的网络端口
  • ......

　　（2）问题分析

　　

★★★一般性原则：自定义拷贝构造函数的时候，必须思考这个拷贝函数是否需要实现深拷贝？  如果不需要，为什么不使用编译器提供的拷贝构造函数？

【编程实验】数组类的改进

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int* m_pointer;

public:
    IntArray(int len);
    IntArray(const IntArray& obj);
    ~IntArray();

    int length();
    bool get(int index, int& value);
    bool set(int index, int value);
};

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

IntArray::~IntArray()
{
    if(m_pointer)
    {
        delete[] m_pointer;
    }
}

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

bool IntArray::get(int index, int& value)
{
   bool bRet = (0 <= index) && (index <m_length);

   if(bRet)
   {
        value = m_pointer[index];
   }

   return bRet;
}

bool IntArray::set(int index, int value)
{

   bool bRet = (0 <= index) && (index <m_length);

   if(bRet)
   {
        m_pointer[index] = value;
   }

   return bRet;
}

#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);
        }
    }
    return 0;
}

3. 小结

　　（1）C++ 编译器会默认提供构造函数

　　（2）无参构造函数用于定义对象的默认初始状态

　　（3）拷贝构造函数在创建对象时拷贝对象的状态

　　（4）对象的拷贝有浅拷贝和深拷贝两种方式。浅拷贝使得对象的物理状态相同；深拷贝使得对象的逻辑状态相同。