c++学习笔记（9）

拷贝构造函数调用时机
1.使用一个已经创建完毕的对象来初始化一个新对象
2.值传递的方式给函数参数传值
3.以值方式返回局部对象

class person
{
public:
	person()
	{
	 	cout<<"start"<<end1;
	}
	~person()
	{
		cout<<"end"<<end1;
	}
	person(int age)
	{
		m_age = age;
	}
	person(const person &p)
	{
		m_age = p.m_age;
	}
}

void test1()
{
	person p1(20);
	person p2(p1);
}

void test2()
{
	person p;
	dowork(p);
	//相当于person p = p 调用了拷贝函数
}

void dowork(person p)
{
}

void test3()
{
	person p = dowork2();
}
person dowork2()
{
	person p1;
	return p1;
	//局部变量p1在函数运行结束后会被自动释放，但是需要有返回值，所以会拷贝一个变量p‘，用于给p赋值
}

构造函数调用规则
默认情况下，c++编译器至少给一个类添加三个函数
1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造函数，对属性进行值拷贝

规则如下：
如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不会再提供其他构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

class person
{
public:
	m_height = new int(height);
	int m_age;
	int * m_height;
	//析构函数可以将堆区开辟的数据释放干净
	if(m_height != NULL)
	{
		delete m_height;
		m_height = NULL;
		//防止野指针出现，指向null
	}
	person(const person&p)
	{
		m_age = p.m_age;
		m_height = new int(*p.m_height);
	}
}

void test1()
{
	person p1(18);
	person p2(p1);
	//编译器你自带的是浅拷贝
}
void test2()
{
	person p1(18,160);
	person p2(p1);
	//编译器自带的浅拷贝，会导致堆区的内存被重复释放
	//深拷贝就是拷贝时指针指向的内存地址不同，但是存放的数据相同
}
//函数内存释放时，先入后出原则

初始化列表
作用：
c++提供了初始化列表语法，用来初始化属性
语法：构造函数（）：属性1（值1），属性2（值2）…（）

class person
{
public:
	int m_a;
	int m_b;
	int m_c;
	//初始化列表
	person(int a,int b,int c):m_a(a),m_b(b),m_c(c)
	{
	//这样可以通过传参，灵活的赋值
	}
}
//这样构造时候不用传参，也会有初始值

类对象作为类成员
c++类中的成员可以是另一个类的对象，我们称该成员为对象成员
class a{}
class b
{
a a；
}
重点在于析构函数的先后

class phone
{
public:
	phone(string name)
	{
		p_name = name;
	}
	string p_name;
}

class person
{
public:
	person(string name,string pname):m_name(name),m_phone(pname)
	{
	//相当于phone m_phone = pname 隐式转换法
	//调用了有参构造函数
	}
	string m_name;
	phone m_phone;
}

当其他类对象作为本类成员，构造时候先构造类对象，再构造自身
析构的顺序与构造的顺序是相反的

静态成员
静态成员就是在成员变量和成员函数前加上关键字static，成为静态成员
静态成员分为：
静态成员变量
1.所有成员共享一份数据
2.在编译阶段分配内存
3.类内声明，类外初始化
静态成员函数：
1.所有成员共享一个函数
2.静态成员函数只能访问静态成员变量

class person
{
public:
	static int m_a;
}
int person::m_a = 100;
//类外初始化

void test()
{
	person p1;
	person p2;
	p2.m_a = 200;
	//p1的m_a也会变为200
}
cout<<person::m_a<<endl;
//也可以通过直接访问变量进行访问

静态成员变量不属于某一个对象，所有对象共享一个数据
静态成员变量处于私有时，也无法外部访问

class person
{
public:
	static void func()
	{
		m_a = 100;
		//静态函数不可以访问不同变量
		//因为静态成员函数是没有对象的，而普通变量是分对象的
	}
	static int m_a;
	int m_b;
}

void test1()
{
	person p;
	p.func();
	//两种访问方式
	person::func();
}

静态成员函数也是有访问权限的