提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
前言
在本篇文章中，主要是对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. 运算符重载
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
标签：封装,函数,int,成员,C++,Person,对象,面向对象编程,构造函数 From： https://blog.csdn.net/2401_82458959/article/details/140569982