【C++核心篇】—— C++面向对象编程：封装相关语法使用和注意事项详解（全网最详细！！！）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、封装（类）
- 1.封装的使用（类和对象）
- 2. 对象的初始化和清理
- - 2.1 构造函数
  - 2.2 析构函数
  - 2.3 构造函数的分类及调用
- 3. 深拷贝与浅拷贝
- 4. C++对象模型和this指针
- 5. 友元
- 6. 运算符重载

前言

在本篇文章中，主要是对C++的基础语法进行回顾学习，回顾学习C++的基本语法规则、数据类型、控制结构以及面向对象编程的基本思想。

一、封装（类）

封装的概述：
将属性和行为作为一个整体，将属性和行为加以权限控制，表现生活中的事物

1.封装的使用（类和对象）

(1). 在设计类的时候，属性和行为写在一起，表现事物。
语法：

class 类名{ 访问权限：属性/行为 }；

示例：设计一个圆类，求圆的周长

constdoublePI=3.14;   //圆周率
class Circle{
public:
	int m_r; //属性,半径
	doublecalculateZC(){     //行为,获取到圆的周长
		return 2*PI*m_r;
	}
};
int main(){
	Circle c1;//通过圆类，创建圆的对象
	c1.m_r=10;//给圆对象的半径进行赋值操作
	cout << "圆的周长为：" << c1.calculateZC() << endl;
	system("pause");
	return 0;
}

(2). 类属性和行为权限控制
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
a. public 公共权限类内可以访问类外可以访问

b.protected 保护权限类内可以访问类外不可以访问

c.private 私有权限类内可以访问类外不可以访问
注意：protected 和 private权限的区别（在类的继承里面会体现出来）
protected ：子类可以访问父类的保护权限的属性
private ：子类不可以访问父类的私有权限的属性，只有自己才能访问

(3). 成员属性设置为私有的好处
好处1：将所有成员属性设置为私有，可以自己控制读写权限
好处2：对于写权限，我们可以检测数据的有效性

示例：

class Person{
public:
	void setName(string name){    //姓名设置可读可写
		m_Name = name;
	}
	string getName(){
		returnm_Name;
	}
private：
	string m_Name;//可读可写
};
int main(){
	Person p;     
	p.setName("张三");  //姓名设置
	cout << "姓名：" << p.getName() << endl;   //读取姓名
	system("pause");
	return 0;
}

(4). 静态成员
静态成员就是在成员变量和成员函数前加关键字static，称为静态成员
静态成员分为：
1) 静态成员变量特点:
a. 所有对象共享同一份数据
b. 在编译阶段分配内存
c. 类内声明，类外初始化

class Person{
public:
	static int m_A;   //静态成员变量
private:
	static int m_B;      //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

2) 静态成员函数特点:
a. 所有对象共享同一个函数
b. 静态成员函数只能访问静态成员变量

(5). struct和class区别
区别：在C++中 struct和class唯一的区别就在于默认的访问权限不同
struct ：默认权限为公有
class ：默认权限为私有

(6). 成员函数的类内申明，类外实现用法

class Person{
public:
    //类内声明：
    Person(string Name,int Age);
	void show();
public:
	string m_Name;
	int m_Age;
};
//类外实现（类外定义）：成员函数类外实现
Person::Person(string Name,int Age){
	    this->m_Name = Name;
	    this->m_Age = Age;
    }
void Person::show(){    //姓名设置可读可写
		cout << "姓名为：" << this->m_Name << "年龄为：" << this->m_Age <<endl;
	}

总结：在类外定义的时候加个作用域即可

2. 对象的初始化和清理

对象的初始化和清理也是两个非常重要的安全问题
a. 一个对象或者变量没有初始状态，对其使用后果是未知
b. 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

2.1 构造函数

作用：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

使用语法：类名(){}

结构：
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

2.2 析构函数

作用：主要作用在于对象销毁前系统自动调用，执行一些清理工作。（一般自己new出来的堆区的数据，使用完需要释放时用）
使用语法：~类名(){}
结构：
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号 ~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

示例：
class Person{
public:
   Person(){     //无参构造函数
		cout << "Person的构造函数调用" << endl;
	}
	~Person(){     //析构函数
		cout << "Person的析构函数调用" << endl;
	}
}；

注意：c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

2.3 构造函数的分类及调用

(1) 两种分类方式：
a. 按参数分为：有参构造和无参构造
b. 按类型分为：普通构造和拷贝构造
(2) 三种调用方式：
a. 括号法 b. 显示法 c. 隐式转换法
示例：

class Person{
public:
   Person(){
		cout << "Person的构造函数调用" << endl;
		}
   Person(int a){
        age = a;
		cout << "Person的构造函数调用" << endl;
		}
	Person(const Person & p){
		age = p.age;
		cout << "拷贝构造函数!" << endl; 
		}
	~Person(){
	 cout << "Person的析构函数调用" << endl; 
	 }
public:
	int age;
}；
int main(){
	//括号法，常用：
	Person p1;              	Person p2(10);  // 调用有参构造函数
	//显式法
	Person p3 = Person(10);   Person p4 = Person(p2);  //调用拷贝构造
	//隐式转换法
    Person p5 = 10;            Person p6 = p5; //Person p6 = Person(p5);
	system("pause");
	return 0;
}

注意：
a. Person(10)单独写就是匿名对象，当执行完当前行后，会被编译器立即释放
b. 不能利用拷贝构造函数初始化匿名对象，编译器认为是对象声明 :

Person p4 = Person(p2)
Person (p4);   //会出现重定义的报错，这行代码等于：Person p4

c. 调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明Person p1()
(3) 拷贝构造函数调用时机

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

Person man(100);             //man对象已经创建完毕
Person newman(man);         //调用拷贝构造函数
Person newman2 = man;      //拷贝构造

b. 值传递的方式给函数参数传值
c. 以值方式返回局部对象（要注意，this指针时会提到）

Person doWork2(){}
Person p = doWork2();

(4) 构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
a. 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
b. 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

(5) 构造函数初始化列表
作用：C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）…{}

示例：

class Person{
public:
    //传统方式初始化
	Person(int a, int b, int c){
	m_A = a;   
	m_B = b;   
	m_C = c;
	}
	//初始化列表方式初始化
	Person(int a, int b, int c): m_A(a), m_B(b), m_C(c){}
private:
	int m_A;  
	int m_B;    
	int m_C;
};

3. 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑，两者的区别主要如下：
浅拷贝：简单的赋值拷贝操作（编译器默认提供的拷贝构造就是浅拷贝）
深拷贝：在堆区重新申请空间，进行拷贝操作（可以避免重复释放堆区内存的问题）
示例：

class Person{
public:
	Person(){}
	Person(int age, int height){
		m_age = age;
		m_height = newint(height);
	}
	~Person(){
		delete m_height;
	}
public：
	int m_age;
	int * m_height;
}；
void test(){
	Personp1(18,180);
	Personp2(p1);
}
int main(){
	test();
	system("pause");
	return 0;
}

上述的示例中，只使用浅拷贝，会带来如下的问题：重复释放堆区内存的问题
在这里插入图片描述

解决：自己实现拷贝构造函数，利用深拷贝解决浅拷贝带来的问题。
在这里插入图片描述
拷贝构造函数如下：

Person(const Person & p){
	m_age = p.m_age;
	m_height = new int( *p.m_height);
}；

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

4. C++对象模型和this指针

(1) 成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上
如何验证：
分别创建空对象，具有非静态成员变量的对象，和具有其他的类型的对象（静态、非静态成员函数，静态成员变量），然后分别打印出对象的所占用的字节的空间的大小即可。

1）空对象占用内存空间为:1
C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，每个空对象也应该有一个独一无二的内存地址
2）其他的非空对象的内存大小
按非静态成员变量的大小来计算，比如，一个int 类型的非静态成员的对象为：4，具有两个的为：8；
疑问：
既然非静态成员函数的也不属于类的对象上，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，那么这一块代码是如何区分那个对象调用自己的呢？（this指针来解决这个问题）

(2) this指针概念与使用

c++通过提供特殊的对象指针，this指针，解决区分不同对象调用自己的成员函数的问题。this指针指向被调用的成员函数所属的对象
作用：
a.当形参和成员变量同名时，可用this指针来区分

b.在类的非静态成员函数中返回对象本身，可使用return *this

示例：

class Person{
public:
	Person(int age){
		//age = age;	//形参和成员变量同名时,此时编译器会认为Person(int age)中的age和形参的age是一个东西，因此无法将形参传入的数值赋予成员变量的age
		this->age=age;   //1、当形参和成员变量同名时，可用this指针来区分
	}
	Person & PersonAddPerson(Person p){
		this->age += p.age;
		return *this;//返回对象本身
	}
public：
	int age;    //一般成员变量命名为m_age，可以避免这个问题
}；
void test(){
	Person p1(10);   Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);  //链式编程的思想
	cout << "p1.age=" << p1.age << "p2.age=" << p2.age << endl;	
}
int main(){
	test();
	system("pause");
	return 0;
}

注意：返回本体要使用引用的方式(Person & PersonAddPerson(Person p){})
如果返回的是值得形式，思考一下这行代码返回得p2.age值是多少？

p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);

提醒一下：返回的是值的形式，上述的代码中的会调用默认的拷贝构造函数，相当于P2只执行一次相加的操作，这里返回的p2的年龄

(3) 空指针访问成员函数
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针，如果用到this指针，需要加以判断保证代码的健壮性
例如：

void ShowPerson(){
	if(this == NULL){return;}
	cout << mAge << endl;
	}
//使用的时候：
Person*p=NULL;       
p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了

解释：再调用空指针的成员函数的ShowPerson时，里面使用了成员属性mAge ，编译器会默认调用this指针，this->mAge，故需要对this进行判断是否为空。

(4) const修饰成员函数

1) 常函数：
a. 成员函数后加const后我们称为这个函数为常函数

void ShowPerson() const {}

b. 常函数内不可以修改成员属性

c. 成员属性声明时加关键字mutable后，在常函数中依然可以修改

mutable int m_A;//可修改可变的

2) 常对象：
a.声明对象前加const称该对象为常对象

const Person person;//常量对象

b.常对象只能调用常函数

5. 友元

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。
作用：友元的目的就是让一个函数或者类访问另一个类中私有成员
使用：友元的关键字为 friend，友元有三种实现：全局函数做友元、类做友元
、成员函数做友元

(1) 全局函数作友元
想让某个全局函数访问某个类的私有属性，只需在类中使用friend关键字+该函数的申明即可，如：

class Building {
	friend void goodPerson(Building * building);
	private:
		string m_BedRoom;
}
//全局函数
void goodPerson(Building * building){
	cout << building->m_BedRoom << endl;
}

(2) 类作友元

class Building {
	//告诉编译器以访问到Building类中私有内容
	friend class goodPerson;
}；
void goodPerson::visit(){
	cout << building->m_SittingRoom <<endl;   //goodPerson类的构造函数，访问了Building类building对象中的私有的属性
}

(3) 成员函数做友元

class Building {
	//告诉编译器goodPerson类中的visit成员函数以访问到Building类中私有内容
	friend void goodPerson::visit();
}；

总结一句就是，==你想使用A（可以是普通的函数、类、成员函数）去访问B类中的私有属性，只需在B类中定义中，使用关键字friend再申明一次A即可，==这就是友元的用法。

6. 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型