同一个类的对象在内存中有完全相同的结构,如果作为一个整体进行复制(拷贝)是完全可行的。这个拷贝过程只需要拷贝数据成员,而函数成员是共用的(只有一份拷贝)。在建立对象时可用同一类的另一个对象来初始化该对象的存储空间,这时所用的构造函数称为拷贝构造函数。拷贝构造函数也是构造函数的一种,只是与构造函数的形参不同。
示例:
//拷贝构造函数
class Complex
{
private:
int real;
int image;
public:
Complex():real(0), image(0) //缺省的构造函数
{
cout << "Create Complex:()" << endl;
}
Complex(int r, int i) :real(r), image(i) //带参数的构造函数
{
cout << "Create Complex(int,int) " << endl;
}
~Complex()
{
cout << "Destroy Complex: " << endl;
}
//不加引用&,则会变为无穷递归的形式,设置成值类型,必须要构建对象,而设计成引用,只是当前对象的别名
Complex(const Complex& com) :real(com.real), image(com.image) //拷贝构造函数 形参必须是引用
{ //为了防止拷贝构造过程中改变cb对象 加const
//real = com.real;
//Complex cc(cb); -> Complex(&cc,cb);
cout << "Copy Create Complex(const Complex&)" << this << endl;
}
};
void fun(Complex cs)
{
}
int main()
{
Complex ca;
Complex cb(1,2);//用c1初始化c2
Complex cc(cb); //用一个对象初始化另一个对象时 调动拷贝构造
fun(ca);
return 0;
}
调试结果:
运行结果:
一般来说有以下三种情况:
class Person
{
public:
//无参(默认)构造函数
Person() {
cout << "Person的默认构造函数调用!" << endl;
}
Person(int age) {
cout << "Person有参构造函数调用!" << endl;
m_Age = age;
}
Person(const Person& p) {
cout << "Person拷贝构造函数调用!" << endl;
m_Age = p.m_Age;
}
~Person() {
cout << "Person的析构函数调用!" << endl;
}
public:
int m_Age;
};
//1 使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
Person p1(20); //创建一个新对象p1
Person p2(p1); //拷贝 把p1的全部拷贝过来
cout << "P2的年龄为: " <
练习1:写拷贝构造函数
//写拷贝构造函数
class CGoods
{
private:
enum { LEN=20 }; //枚举型是常量
char Name[LEN]; //20
int Amount;
float Price;
float Total_value; //32
public:
CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
{
}
CGoods(const char* name, int amount, float price)
{
strcpy_s(Name, LEN, name);
Amount = amount;
Price = price;
Total_value = Amount * Price;
}
};
int main()
{
CGoods book("C++", 10, 128.0f);
CGoods bx(book); //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
return 0;
}
运行结果:
写入拷贝构造函数:
//写拷贝构造函数
class CGoods
{
private:
enum { LEN=20 }; //枚举型是常量
char Name[LEN]; //20
int Amount;
float Price;
float Total_value; //32
public:
CGoods() :Name{}, Amount{}, Price{}, Total_value{} //无参构造函数
{
}
CGoods(const char* name, int amount, float price)
{
strcpy_s(Name, LEN, name);
Amount = amount;
Price = price;
Total_value = Amount * Price;
}
CGoods(const CGoods& c) //浅拷贝
{
strcpy_s(Name, LEN, c.Name);
Amount = c.Amount;
Price = c.Price;
Total_value = c.Total_value;
cout << "Copy CGoods(const CGoods&): " << this << endl;
}
};
int main()
{
CGoods book("C++", 10, 128.0f);
CGoods bx(book); //没有写 系统提供一个缺省的拷贝构造函数 按位拷贝
return 0;
}
练习2:写拷贝构造函数
当函数的返回值是类对象
当函数的返回值是类对象,函数执行完成返回调用者时使用。理由也是要建立一个临时对象中,再返回调用者。
因为局部对象在离开建立它的函数时就消亡了,不可能在返回调用函数后继续生存,所以在处理这种情况时,编译系统会在调用函数的表达式中创建一个无名临时对象,该临时对象的生存周期只在函数调用处的表达式中。
所谓return 对象,实际上是调用拷贝构造函数把该对象的值拷入临时对象空间。如果返回的是变量,处理过程类似,只是不调用构造函数。
先写一个普通构造函数,析构函数:
class Person {
public:
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age)
{
m_Age = age;
cout << "有参构造函数!" << endl;
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
}
int m_Age; //年龄
};
void test01()
{
Person p1(18);
cout << "p1的年龄: " << p1.m_Age<
运行结果:
#include
using namespace std;
class Person {
public:
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age, int height)
{
m_Age = age;
m_Height = new int(height);
cout << "有参构造函数!" << endl;
}
//自己实现拷贝构造函数,解决浅拷贝带来的问题
Person(const Person& p)
{
cout<< "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
m_Age = p.m_Age;
// m_height = new int(*p.m_height); 编译器默认实现就是这行代码
//深拷贝操作
m_Height=new int(*p.m_Height);
}
//析构函数
~Person()
{
//析构代码,将堆区开辟的数据做释放操作
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "析构函数!" << endl;
}
int m_Age; //年龄
int* m_Height; //身高 开辟到堆区
};
void test01()
{
Person p1(18,160);
cout << "p1的年龄: " << p1.m_Age<< " 身高: " << *p1.m_Height << endl;
Person p2(p1);//调用拷贝构造函数 编译器做了一个浅拷贝的工作
cout << "p2的年龄: " << p2.m_Age << " 身高: " << *p2.m_Height << endl;
}
int main()
{
test01();
}
运行结果: