C++基础学习笔记03——类与对象1

面向对象三大特性：封装，继承，多态

1. 封装

封装的意义：
将属性和行为作为一个整体
将属性和行为加以权限控制
语法：class {名访问权限：属性/行为}

class Student{
	public:
		void setName(string name){
			m_name=name;
		}
		void setID(int id){
			m_id=id;
		}
	public:
		string m_name;
		int m_id;
};

访问权限：
public：公共权限
protected：保护权限
private：私有权限

公共权限 public 类内可以访问 类外可以访问
保护权限 protected 类内可以访问 类外不可以访问
私有权限 private 类内可以访问 类外不可以访问

C++中struct默认权限为公共，class默认权限为私有

2. 对象的初始化和清理

2.1 构造函数和析构函数
构造函数：主要作用在创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名（）{}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候回自动调用构造，无需手动调用

析构函数语法：~类名（）{}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同，在名称前加上~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前调用析构函数，无需手动调用

2.2 构造函数的分类及调用
两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法

class Person{
	public:
		Person(){
			cout<<"Person的无参构造函数"<<endl; 
		}
		Person(int a){
			age=a;
			cout<<"Person的有参构造函数"<<endl; 
		}
		Person(const Person &p){
			age=p.age;
			cout<<"Person的拷贝构造函数"<<endl; 
		}
		~Person(){
			cout<<"Person的析构函数"<<endl;
		}
		int age;
};

	Person p1;		//普通构造函数 
	Person p2(10);	//有参构造函数 
	Person p3(p2);	//拷贝构造函数
	Person(10);		//匿名对象 特点：当前行执行结束后，系统立即回收掉匿名对象 
	Person p4=10; 	//相当于 Person p4=Person(10) 

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

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

class Person{
	public:
		Person(){
			cout<<"Person的默认构造函数调用"<<endl;
		}
		Person(int age,int height){
			cout<<"Person的有参构造函数调用"<<endl;
			m_age=age;
			m_height=new int(height);
		}
		~Person(){
			if(m_height!=NULL){
				delete m_height;
				m_height=NULL;
			}
			cout<<"Person的析构函数调用"<<endl;
		}
		int m_age;
		int *m_height;
}; 
int main(){
	Person p1(18,160);
	cout<<"p1的年龄为："<<p1.m_age<<" p1的身高为："<<*p1.m_height<<endl;	//18 160
	Person p2(p1);
	cout<<"p2的年龄为："<<p2.m_age<<" p2的身高为："<<*p2.m_height<<endl;	//18 160
} 

此时编译器会报错，p2拷贝p1是浅拷贝（编译器提供的拷贝构造函数）。当创建p1时，在堆区开辟了一块内存，这块内存存放的是p1的m_height。当执行析构函数时，p2首先执行析构函数代码，释放堆区内存；p1同样执行析构代码，再一次释放堆区内存。堆区内存重复释放，造成编译器报错。此时需要深拷贝解决，再在堆区开辟一块内存。

class Person{
	public:
		Person(){
			cout<<"Person的默认构造函数调用"<<endl;
		}
		Person(int age,int height){
			cout<<"Person的有参构造函数调用"<<endl;
			m_age=age;
			m_height=new int(height);
		}
		Person(const Person &p){
			cout<<"Person的拷贝构造函数调用"<<endl;
			m_age=p.m_age;
			m_height=new int(*p.m_height);	//深拷贝操作，再开辟一块内存空间 
		}
		~Person(){
			if(m_height!=NULL){
				delete m_height;
				m_height=NULL;
			}	//析构代码，将堆区开辟的数据做释放操作
			cout<<"Person的析构函数调用"<<endl;
		}
		int m_age;
		int *m_height;
}; 

如果有属性在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

2.5 初始化列表
语法：构造函数():属性1(值1)，属性2(值2)…{}

class Person{
	public:
		int m_age;
		int m_weight;
		int m_height;
		Person(int age,int weight,int height):m_age(age), m_weight(weight),m_height(height){
		}
}; 

2.6 类对象作为类成员

class A{
	public:
		A(){
			cout<<"A的构造函数"<<endl;
		}
		~A(){
			cout<<"A的析构函数"<<endl;
		} 
};
class B{
	public:
		B(){
			cout<<"B的构造函数"<<endl;
		}
		~B(){
			cout<<"B的析构函数"<<endl;
		}
		A a;
};

当创建B对象时，首先调用A的构造函数，再调用B的构造函数；当程序结束时，首先调用B的析构函数，再调用A的析构函数。
总结：
当类中成员是其他类对象时，我们称该成员为对象成员，构造的顺序是：先调用对象成员的构造，再调用本类的构造。析构顺序相反。

2.7 静态成员
静态成员变量：
所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化

class Person{
	public:
		static int m_a;	//类内声明 
};
int Person::m_a=100;	//类外初始化 

	cout<<p1.m_a<<endl;
	cout<<Person::m_a<<endl;	//访问静态成员变量两种方式 

总结：
访问静态成员变量
对象名.静态成员变量名
类名::静态成员变量名

静态成员函数：
所有对象共享同一个函数
静态成员函数只能访问静态成员变量

class Person{
	public:
		static void func(){
			cout<<"static void func调用"<<endl;
		}
};
int main(){
	Person p1; 
	p1.func(); 
	Person::func();	//访问静态成员函数两种方式 
} 

class Person{
	public:
		static void func(){
			m_a=100;	//正确 
			m_b=200; 	//错误
			//静态成员函数只能访问静态成员变量 
			cout<<"static void func调用"<<endl;
		}
		static int m_a;
		int m_b;
};

2.8 this指针
this指针指向被调用的成员函数所属的对象
this指针用途：
当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用*this

class Person{
	public:
		int age;
		Person(int age){
			this->age=age;
		} 
		Person &PersonAddAge(Person &p){
			this->age+=p.age;
			return *this;
		}
};
int main(){
	Person p1(10);
	Person p2(10);
	p2.PersonAddAge(p1).PersonAddAge(p1); 	//p2.age为30
	cout<<p2.age<<endl;
	return 0;
} 

2.8 const修饰成员函数

常函数：
成员函数后加const后我们称这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
声明对象前加const称该对象为常对象
常对象只能调用常函数

class Person{
	public:
		void func() const{
			//age=18;错误，常函数不可以修改成员属性的值 
			height=180; 	//正确，height用mutable修饰了可以修改 
		} 
		int age;
		mutable int height; 
		void func1(){
		}
};
int main(){
	 const Person p;	//在对象前加const，变为常对象
	//p.age=18；错误，常对象不可以修改成员属性的值
	p.height=180; 	//正确
	p.func(); 
	//p.func1();错误，常对象只能调用常函数 
	return 0;
}