1、深拷贝与浅拷贝
浅拷贝:默认拷贝构造函数,系统提供
深拷贝:手动定义拷贝构造函数,具体复制动作由自己完成(涉及地址时必须用)
2、拷贝构造函数的使用
拷贝构造函数与普通构造函数的唯一不同点在于参数不同
DEMO类的拷贝构造函数为:DEMO(const DEMO &a);
3、特殊情况:const
类成员中若有const修饰,必须在对象初始化时给const int m 赋值 :Student类中Student::Student():m(v1)
类的成员函数中有const修饰,同上。
#include <iostream>
#include <cstring>
using namespace std;
class Stu
{
private:
int m_bir;
char m_name[20];
int m_num;
int m_cla;
public:
Stu(int b,char *name);
void show();
};
Stu::Stu(int b,char *name):m_bir(b),m_num(15),m_cla(2)
{
strcpy(m_name,name);
}
void Stu::show()
{
cout << "name : " << m_name << " birthday : " << m_bir << endl;
cout << "number : " << m_num << " class : " << m_cla << endl;
}
int main()
{
Stu a(123,"wenwanwan");
a.show();
return 0;
}
#include <iostream>
using namespace std;
class Test
{
private:const int m_a;
public:Test(int a);
int GetA() const;
};
Test::Test(int a):m_a(a)
{
//m_a = a;
}
int Test::GetA() const
{
return m_a;
}
int main()
{
Test t(1);
cout << t.GetA() << endl;
return 0;
}
4、成员变量的初始化顺序与声明的顺序相关,与在初始化列表中的顺序无关
5、析构函数调用顺序与构造函数顺序相反
#include <iostream>
#include <cstring>
using namespace std;
class Test
{
private:
int m;
public:
Test(int n);
~Test();
};
Test::Test(int n)
{
cout << "Test Constructor !" << endl;
m = n;
}
Test::~Test()
{
cout << "Test Destruct !" << endl;
}
class Bir
{
private:
int year;
int mouth;
int day;
public:
Bir(int _year,int _mouth,int _day);
void print();
~Bir();
};
class Stu
{
private:
Test t;//此处调用不同类的顺序决定对应类构造函数调用的顺序
Bir m_bir;//若34,35互换,则调用顺序变化
char m_name[20];
int m_num;
int m_cla;
public:
// Stu(char *name);
Stu(int year,int mouth,int day,char *name);
void show();
~Stu();
};
Bir::Bir(int _year,int _mouth,int _day)
{
cout << "Birthday constructor !" << endl;
year = _year;
mouth = _mouth;
day = _day;
}
void Bir::print()
{
cout << "year : " << year << " mouth : " << mouth << " day : " << day << endl;
}
Bir::~Bir()
{
cout << "Birthday Destruct !" << endl;
}
//Stu::Stu(char *name):m_num(15),m_cla(2),m_bir(1997,5,27)
Stu::Stu(int year,int mouth,int day,char *name):m_num(15),m_cla(2),m_bir(year,mouth,day),t(2)
//此处初始化列表顺序与成员变量顺序无关
{
cout << "Sturdent Constructor !" << endl;
strcpy(m_name,name);
}
void Stu::show()
{
cout << "name : " << m_name << endl;
m_bir.print();
cout << "number : " << m_num << " class : " << m_cla << endl;
}
Stu::~Stu()
{
cout << "Student Destruct !" << endl;
}
//析构函数与对应的构造函数的调用顺序相反
int main()
{
//Stu a("wenwanwan");
Stu a(1997,5,27,"wenwanwan");
a.show();
return 0;
}
运行结果:
Test Constructor !
Birthday constructor !
Sturdent Constructor !
name : wenwanwan
year : 1997 mouth : 5 day : 27
number : 15 class : 2
Student Destruct !
Birthday Destruct !
Test Destruct !
6、匿名对象
匿名对象生命周期短,调用完构造函数后,立即调用析构函数,只存在匿名对象所在行有效
注意:手动调用构造函数时,会产生一个匿名对象,构造中调用构造是危险行为!
#include <iostream>
using namespace std;
class Test
{
private:int m_a;
public:Test(int a);
~Test();
};
Test::Test(int a)
{
cout << "Test Constructor !" << endl;
m_a = a;
}
Test::~Test()
{
cout << "Test Destruct !" << endl;
}
int main()
{
Test(2);//匿名对象,生命周期只存在此行,调用构造函数后立即调用析构函数
Test a(1);//有名对象,对象结束后调用析构函数
Test b(3);
return 0;
}
运行结果:
Test Constructor !
Test Destruct !
Test Constructor !
Test Constructor !
Test Destruct !
Test Destruct !
#include <iostream>
using namespace std;
class Test
{
private:int m_a;
int m_b;
int m_c;
public:Test(int a,int b,int c);
Test(int a,int b);
int Getc();
~Test();
};
Test::Test(int a,int b,int c)
{
cout << "Test Constructor_3 !" << endl;
m_a = a;
m_b = b;
m_c = c;
}
Test::Test(int a,int b)
{
cout << "Test Constructor_2 !" << endl;
m_a = a; m_b = b;
Test(a,b,3);
//在构造函数中调用构造函数是危险行为,会产生一个新的匿名对象
//即用即释放,故c为垃圾值
}
int Test::Getc()
{
cout << "c = " << m_c << endl;
}
Test::~Test()
{
cout << "Test Destruct !" << endl;
}
int main()
{
Test t(1,2);
t.Getc();
return 0;
}
运行结果:
Test Constructor_2 !
Test Constructor_3 !
Test Destruct !
c = 13963252
Test Destruct !