构造函数和析构函数

函数名和类名相同，有参数，构造函数创建对象时会自动调用且只调用一次，而析构函数在对象销毁前会自动调用一次，这两个函数是必需的，如果不手动设置，编译器会自动设置

1
2
3
4
5
6
7
8
9
10
11
//构造函数
class Person{
	public:
		Person(){
			std::cout<<"OK";
		}
		//析构函数 
		~Person(){
			std::cout<<"OK";
		}
};

构造函数的分类

默认无参构造函数，有参构造函数，拷贝构造函数

调用方法有括号法显示法和隐式转化法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Person{
	public:
		Person(){
			//无参 
		}
		Person(int a){
			//有参 
		}
		Person(const Person &p){
			//拷贝 
		}
};	
//调用 
void test1(){
	//括号法 
	//默认构造不要加括号()，编译器会误以为是函数的声明 
	Person p1;
	Person p2(10);
	Person p3(p2);
} 
void test2(){
	//显示法
	Person p1;
	Person p2=Person(10);
	Person p3=Person(p2);
	
	Person(10)//匿名对象，当前行执行完后自动回收
	//注意：不要用拷贝构造函数初始化匿名对象 
	//编译器会认为Person(p3)===Person p3，对象重定义 
}
void test3(){
	//隐式转化法 
	Person p4 =10;//相当于Person p4 =Perosn(10)
	Person p5 = p4;	//相当于拷贝 
}

拷贝函数的调用时机

使用一个已经创建完毕的对象来初始化一个新对象

值传递的方式给函数参数传值

值传递的方式返回局部对象

构造函数调用规则

C++至少给一个类添加三个函数

默认构造函数，默认析构函数，默认拷贝构造函数

若定义了有参构造函数，则不会默认添加无参构造函数，但有拷贝构造函数

若定义了拷贝构造函数，c++不会添加其他构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

初始化列表

构造函数（）：属性1（值1），属性2（值2）…… { … }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person{
	public:
		Person():m_a(10),m_b(20),m_c(30){
			
		}
		//另一种 
		Person(int a,int b,int c):m_a(a),m_b(b),m_c(c){
			
		}
		//普通的 
		Person(int a,int b, int c){
			ma=a;
			mb=b;
			mc=c;
		}
		int ma,mb,mc;
};
void test(){
	Person p;
	Person p(10,20,30); 
}

其他类对象作为本类的成员

其他类对象作为本类的成员时，先有其他类对象的构造函数，再有自身的构造函数

先有自身的析构，再有其他类对象的析构

静态成员

加上关键字static

静态成员变量

在编译阶段分配内存，程序还未运行就已经有内存，全局区的内存

需要在类内声明，然后在类外初始化

1
2
3
4
5
6
7
class Person{
	public:
		//类内声明 
		static A;
};
//类外初始化 
int Person::A=100;

所有对象共享一份数据

1
2
3
4
5
6
7
8
void test(){
	//静态成员变量不属于某个对象
	//可以通过对象或者类名访问
	Person p;
	std::cout<<p.A<<endl;
	
	std::cout<<Person::A<<endl; 
}

静态成员函数

所有对象共享一个函数（与成员变量访问方式一样）

通过静态成员函数只能访问静态成员变量