关键词：无参构造、拷贝构造、浅拷贝、深拷贝
1. 特殊的构造函数
-
两个特殊的构造函数
- 无参构造函数：没有参数的构造函数
- 拷贝构造函数：参数为
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. 拷贝构造函数
- 拷贝构造函数的意义：
- 兼容C语言的初始化方式
- 初始化行为能够符合预期的逻辑
初始化：需要创建一个新的对象，其初值来源于另一个已存在的对象。初始化的时候调用拷贝构造函数。
赋值：在两个已存在的对象间进行。赋值时调用重载的赋值运算符。
浅拷贝： 拷贝后对象的物理状态相同
深拷贝：拷贝后对象的逻辑状态相同
编译器提供的拷贝构造函数只进行浅拷贝！！！
编程说明：编译器提供的默认拷贝方式为浅拷贝
#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++编译器会默认提供构造函数；
- 无参构造函数用于定义对象的默认初始状态；
- 拷贝构造函数在创建对象时拷贝对象的状态；
- 对象的拷贝有浅拷贝和深拷贝两种方式；
- 浅拷贝使得对象的物理状态相同；
- 深拷贝使得对象的逻辑状态相同。
