19_对象的构造（下）

关键词：无参构造、拷贝构造、浅拷贝、深拷贝

1. 特殊的构造函数

  • 两个特殊的构造函数

    1. 无参构造函数：没有参数的构造函数
    2. 拷贝构造函数：参数为 const class_name& 的构造函数

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

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

特殊的构造函数

#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;      // 将t1的值copy给t2，因此t1的datas与t2的datas相等，但t1和t2的address不相同，因为t1和t2是两个不同的object
    
    printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
    printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());

    return 0;
}

输出结果：

t1.i = -1217023036, t1.j = -1216757760
t2.i = -1217023036, t2.j = -1216757760

2. 拷贝构造函数

  • 拷贝构造函数的意义：
    1. 兼容C语言的初始化方式
    2. 初始化行为能够符合预期的逻辑

初始化：需要创建一个新的对象，其初值来源于另一个已存在的对象。初始化的时候调用拷贝构造函数。
赋值：在两个已存在的对象间进行。赋值时调用重载的赋值运算符。

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

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

编程说明：编译器提供的默认拷贝方式为浅拷贝

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



int main()
{   
    Test t1(3);      // 调用Test(int v)
    Test t2 = t1;    // 调用默认拷贝构造函数
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());

    t1.free();      // 释放对象中的指针p
    t2.free()；    // 由于t2中的指针p和t1中的指针p指向同一个堆空间，上一步中已经释放，因此这里会报错
    return 0;
}

输出结果：

t1.i = 1, t1.j = 2, t1.p = 0x9594008
t2.i = 1, t2.j = 2, t2.p = 0x9594008

总结： 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;
    }

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



int main()
{   
    Test t1(3);
    Test t2 = t1;
    
    printf("t1.i = %d, t1.j = %d, t1.p = %p， *t1.p = %d\n", t1.getI(), t1.getJ(), t1.getP(), *t1.getP());
    printf("t2.i = %d, t2.j = %d, t2.p = %p , *t2.p = %d\n", t2.getI(), t2.getJ(), t2.getP(), *t2.getP());

    return 0;
}

输出结果：

t1.i = 1, t1.j = 2, t1.p = 0x99f4008， *t1.p = 3
t2.i = 1, t2.j = 2, t2.p = 0x99f4018 , *t2.p = 3
  • 什么时候需要进行深拷贝？
    • 对象中有成员指代了系统中的资源，如（1）成员指向了动态内存空间；（2）成员中打开了外存中的文件（3）成员使用了系统中的网络端口等等

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

编程说明：数组类的改进——加入深拷贝构造函数
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 getLength();
    bool getArray(int index, int& value);
    bool setArray(int index, int value);
    void freeArray();
};

#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::getLength()
{
    return m_length;
}

bool IntArray::getArray(int index, int& value)
{
    bool ret = (0 <= index)&&(index < getLength());

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

    return ret;
}

bool IntArray::setArray(int index, int value)
{
    bool ret = (0 <= index)&&(index < getLength());

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

    return ret;
}

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

main.cpp

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

int main()
{
    IntArray a(5);
    
    for(int i=0; i<a.getLength(); i++)
    {
        a.setArray(i, i + 1);
    }
    
    for(int i=0; i<a.getLength(); i++)
    {
        int value = 0;
        
        if(a.getArray(i, value))
        {
            printf("a[%d] = %d\n", i, value);
        }
    }

    IntArray b = a;             // 另 b = a; 这样就使用了拷贝构造函数

    for(int i=0; i<b.getLength(); i++)
    {
        int value = 0;
        
        if(b.getArray(i, value))
        {
            printf("b[%d] = %d\n", i, value);
        }
    }
    
    a.freeArray();
    b.freeArray();

    return 0;
}

输出结果：

a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5
b[0] = 1
b[1] = 2
b[2] = 3
b[3] = 4
b[4] = 5

3. 小结

  • C++编译器会默认提供构造函数；
  • 无参构造函数用于定义对象的默认初始状态；
  • 拷贝构造函数在创建对象时拷贝对象的状态；
  • 对象的拷贝有浅拷贝和深拷贝两种方式；
  • 浅拷贝使得对象的物理状态相同；
  • 深拷贝使得对象的逻辑状态相同。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • javascript 中的函数和对象
    函数和对象 1、函数 1.1 函数概述 函数对于任何一门语言来说都是核心的概念。通过函数可以封装任意多条语句，而且...
    道无虚阅读 10,096评论 0赞 5
  • 2021 C++简答题及其答案（非原创）
    收集非原创文章，如遇原作者，请私聊我，我会表明出处！ 1--10 1. C++中什么数据分配在栈或堆，静态存储区以...
    Juinjonn阅读 10,366评论 0赞 30
  • c++学习笔记
    第一天 一.内联函数（inline） 函数调用的时候需要建立栈内存环境，进行参数传递，并产生程序执行转移，这些工作...
    陈果123阅读 4,798评论 0赞 1
  • 《C++ Primer》读书笔记
    前言 把《C++ Primer》[https://book.douban.com/subject/25708312...
    尤汐Yogy阅读 13,144评论 1赞 51
  • 你早该这样记读书笔记
    先说一个题外话，我们的公众号开始坚持原创后，不到两周，粉丝虽然不多，但能够聊在一起的粉丝朋友越来越多，刚开始时我们...
    清单控沙牛阅读 17,527评论 191赞 955