拷贝构造
特殊构造函数
类型转换构造
用从不同类型的对象来构造对象
Complex(double real); //用实数来构造复数类
拷贝构造
用相同类型的对象来构造对象
Complex(Complex const&that); //用另一个复数来构造复数
注意：如果一个类没有定义拷贝构造函数，那么编译器会提供一个默认拷贝构造函数，默认是public
类型转换构造和拷贝构造示例
定义一个复数类Complex
//Complex.h
#pragma once
#include<iostream>
using namespace std;
class Complex
{
double m_real; //实部
double m_vir; //虚部
public:
Complex(); //无参构造
/*explicit*/ Complex(double real);//类型转换构造 explicit 防止类型隐式转换
//不提供拷贝构造函数 编译器提供一个默认的拷贝构造函数
Complex(Complex const&that); //拷贝构造
void printf()const;
};
实现复数类Complex
//Complex.cpp
#include "Complex.h"
Complex::Complex()
{
m_real = 0;
m_vir = 0;
cout << "无参构造" << endl;
}
Complex::Complex(double real)
{
m_real = real;
m_vir = 0;
cout << "类型转换构造" << endl;
}
Complex::Complex(Complex const & that)
{
this->m_real = that.m_real;
this->m_vir = that.m_vir;
cout << "拷贝构造" << endl;
}
void Complex::printf() const
{
cout << m_real << "+" << m_vir << "i" << endl;
}
使用这个类
//main.c
#include"Complex.h"
int main()
{
/***无参构造***/
Complex var;
var.printf();
/***类型转换构造***/
Complex var_1 = 5; //隐式将int 换成 Complex 因为Complex提供了单参构造 加上 explicit 防止类型隐式转换
var_1.printf();
/***拷贝构造***/
Complex var_3(var_1);
Complex var_2 = var_1;
var_2.printf();
/***堆区拷贝构造***/
Complex* var_4 = new Complex(var_1);
delete var_4;
cin.get();
return 0;
}
//打印结果
无参构造
0+0i
类型转换构造
5+0i
拷贝构造
拷贝构造
5+0i
拷贝构造
explicit
防止类型隐式转换
深拷贝和浅拷贝
浅拷贝----复制地址
对内存地址的复制，让目标指针和源指针指向同块内存
通过其中一个指针去释放内存，其他指向改内存的指针会成为野指针
深拷贝----复制内存
对拷贝对象的内存进行复制l拷贝结束之后，两个对象存的值相同，内存地址不同
l两个对象互不影响，互不干涉
何时需要自定义拷贝构造函数
如果类带有指针变量，并有动态内存分配，则它必须自定义一个拷贝构造函数。
深浅拷贝示例程序
定义一个男朋友类和一个游戏结构体
//BoyFriend.h
#pragma once
#include<iostream>
#include<string>
using namespace std;
struct game //游戏类
{
char m_name[10]; //游戏昵称
int m_grade; //等级
game(char* name="",int grade=0)
{
strcpy(m_name, name);
m_grade = grade;
}
};
class BoyFriend
{
string m_name;
game* m_account; //一个game类型指针
public:
BoyFriend(string name);
BoyFriend(const BoyFriend& that);
void introduce() const;
~BoyFriend();
};
实现男朋友类
//BoyFriend.cpp
#include "BoyFriend.h"
BoyFriend::BoyFriend(string name)
{
m_name = name;
m_account = new game("马化腾",201);
}
BoyFriend::BoyFriend(const BoyFriend & that)
{
this->m_name = that.m_name;
#if 0
//浅拷贝 拷贝地址 系统默认的拷贝构造没有权限分配堆区内存 默认构造函数是浅拷贝
this->m_account = that.m_account;
#endif
#if 1
//深拷贝 拷贝内存 类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数
//1.分配新资源
this->m_account = new game;
//2.拷贝新资源
memcpy(this->m_account, //拷贝的目标内存首地址
that.m_account, //拷贝的源内存首地址
sizeof(game)); //拷贝字节大小
#endif
cout << "拷贝构造" << endl;
}
void BoyFriend::introduce() const
{
cout << "我叫" << m_name <<",游戏账号昵称是"<<m_account->m_name<< ",游戏账号等级是" << m_account->m_grade << endl;
}
BoyFriend::~BoyFriend()
{
if (m_account)
{
delete m_account;
m_account = NULL;
}
cout << "析构" << endl;
}
使用男朋友类
//main.c
#include"BoyFriend.h"
int main()
{
BoyFriend* boy = new BoyFriend("梦凡");
boy->introduce();
BoyFriend* boy2 = new BoyFriend(*boy); //拷贝构造
boy2->introduce();
delete boy;
boy = NULL;
delete boy2;
boy2 = NULL;
return 0;
}
//打印结果
我叫梦凡,游戏账号昵称是马化腾,游戏账号等级是201
拷贝构造
我叫梦凡,游戏账号昵称是马化腾,游戏账号等级是201
析构
析构
