🏆 个人主页：🎈 @太阳哥哥 🎈
🎁 本文收录专栏：🎈C++学习之路 🎈
🛒 其他专栏：🎈 ARM学习之路 🎈
📝 学习格言：路漫漫其修远兮，吾将上下而求索
💡 欢迎点赞、关注、收藏( •̀ ω •́ )✧ 一起努力，一起学习！
目录
1、类（class）
类：它是一个概念，是将现实世界中的事物进行描述的一个类，类是一个泛指（抽象）的概念，不特指某一个事物，可以理解为理解为没有存在于现实世界中，只是人脑海里面的一个概念。类可以理解为一个男孩；这个男孩的特征有那些，行为有那些。
这个类为：男孩
特征：姓名、年龄、性别、肤色、身高、体重（这些可以理解为成员变量）
行为：吃饭、睡觉、走路、跑步、看书（理解为成员函数）
类的格式：
class 类名（标识符名称）
{
//特征---成员变量
//行为---成员函数
}；
示例程序：
#include <iostream>
#include <string>
using namespace std;
//定义了一个类
class Boy
{
public:
/******成员变量(特征)******/
char name[20] = "小明";
char sex[5] = "男";
int age = 20;
int length = 175;
void show()
{
cout << "boy 的特征：" << endl;
cout << name << " " << sex << " " << age << " " << length <<"\n" << endl;
}
/**********成员函数（行为）***********/
void eat()
{
cout << "吃饭" << endl;
}
void sleep()
{
cout << "睡觉" << endl;
}
void walk()
{
cout << "走路" << endl;
}
void run()
{
cout << "跑步" << endl;
}
void read()
{
cout << "读书" << endl;
}
};
int main()
{
Boy boy;
boy.show();
boy.eat();
boy.sleep();
boy.walk();
boy.run();
boy.read();
}执行程序结果：
boy 的特征： 小明 男 20 175 吃饭 睡觉 走路 跑步 读书
2、对象
对象是类的实例化，是特指的概念。
例如：人（泛指的概念），对人实例化为小明（特指的概念），就是相当于起名字的概念，实例化后利于操作。
（1）栈区实例化对象：不需要用户手动去释放资源，编译器会自动释放其资源。
格式：类名 对象名（标识符名称）；
访问成员格式：对象名（标识符名称）. 成员；
示例程序：
#include <iostream>
#include <string>
using namespace std;
//定义了一个类
class Boy//类名 boy
{
public:
int a;
void show()
{
cout << a << endl;
}
};
int main()
{
Boy boy;//格式：类名 对象名（标识符名称) /栈区实例化 boy1
boy.show();//访问成员格式：对象名（标识符名称）. 成员；
}（2）堆区实例化对象：需要用户手动的去释放内存，如果不释放，很容易造成内存泄露。
格式：类名 * 对象名（标识符名称）= new 类名；
访问成员格式：对象名（标识符名称）-> 成员;
示例程序：
#include <iostream>
#include <string>
using namespace std;
//定义了一个类
class Boy//类名 boy
{
public:
int a;
void show()
{
cout << a <<endl;
}
};
int main()
{
Boy * boy1 = new boy;//格式：类名 * 对象名 = new 类名 /堆区实例化 boy1
boy1->show();// 访问成员格式：对象名（标识符名称）-> 成员;
}示例程序：定义一个算法类（加、减、乘、除功能），调用相应的加、减、乘、除的函数，实现相应的功能
#include<iostream>
using namespace std;
class jishuan
{
public:
void sum(int a, int b)
{
int sum = a + b;
cout << "a+b=" << sum << endl;
}
void sub(int a, int b)
{
int sub = a - b;
cout << "a-b=" << sub << endl;
}
void mul(int a, int b)
{
int mul = a * b;
cout << "a*b=" << mul << endl;
}
void div(int a, int b)
{
int div = a / b;
cout << "a/b=" << div << endl;
}
};
int main()
{
jishuan* shuan = new jishuan;
int a, b;
cout << "输入第一位算数：" << endl;
cin >> a;
cout << "输入第二位算数：" << endl;
cin >> b;
shuan->sum(a, b);
shuan->sub(a, b);
shuan->mul(a, b);
shuan->div(a, b);
return 0;
}
执行程序结果：
输入第一位算数：
5
输入第二位算数：
5
a+b=10
a-b=0
a*b=25
a/b=13、类的成员访问属性
public（公有）：用户把变量或者是函数放置在类的public下，那么这些变量和函数就具有公共的属性。
private（私有）：用户把变量或者是函数放置在类的private下，那么这些变量和函数就具有私有属性。
protected（受保护）：用户把变量或者是函数放置在类的protected下，那么这些变量和函数就具有保护属性。
权限对于类、类体外、友元函数、派生类的可见与不可见：
在public下的成员，对于整个类、类体外、友元函数、派生类（子类）是可见的。
在private、protected下的成员，对于整个类和友元函数是可见的，对于类体外、派生类（子类）是不可见的。
注： 如果在类里面没有写任何的类的成员访问修饰符，那么该类下的成员都是归于private属性下。
4、类函数
4.1、构造函数
构造函数处理对象的初始化，构造函数是一种特殊的成员函数,与其他函数不同,不需要用户调用它,而是创建对象的时候自动调用。构造函数是一种特殊的函数，它实质还是称为函数，如果用户没有显示的写构造函数，编译器会自动的生成 了一个默认的构造函数。
格式：
类名 （参数列表）；成员变量1（初始值1），成员变量2（初始值2）.....
{
//代码块---用于初始化类的成员变量
}
显示调用格式：类名 对象名（构造函数参数列表）；
隐式调用格式：类名 （构造函数参数列表）；
class Test
{
public:
int age;
char sex;
const char* name;
Test():age(20),sex('男'),name("小明")//此处初始化，前面没有返回值
{
}
};构造函数与普通函数的区别
不同点： 普通函数前有返回值类型，而构造函数前没有返回值 普通函数后面没有初始化列表，而构造函数后有初始化列表 普通函数调用的时候以显式调用的方式，而构造函数不仅可以显示的调用还可以隐式的调用
相同点：都可以带参数或者是不带参数，都可以发生重载。
4.2、析构函数
C++中的类可以定义一个特殊的成员函数清理对象,这个特殊的函数是析构函数，析构函数是对象不再使用的时候,需要清理资源的时候调用。如果用户没有显示的书写析构函数，那么编译器会自动帮用户生成一个默认的隐藏的析构函数（作用是释放空间）。
格式：
~类名 （）
{
//代码块
}
~Test1()//析构函数
{
cout << "析构函数" << endl;
}
析构函数的调用：
析构函数没有参数和没有任何返回类型（析构函数不能重载）。
析构函数在对象销毁的时候自动调用。
析构函数调用机制， C++编译器自动调用。
4.3、拷贝构造函数
用户需要用一个对象去初始化另外一个对象的时候，就会用到拷贝构造函数，其实质就是一个构造函数，如果用户没有显示的将拷贝构造函数写出来，那么编译器会自动的生成一个默认的隐藏的拷贝构造函数。
格式：
类名（const 类名 & obj）
{
//拷贝构造函数代码块
}
浅拷贝与深拷贝
浅拷贝：相当于是把一个对象里的成员变量和它的值拷贝了一份儿给另外一个对象。如果类里面有指针对象并且在堆区开辟了空间，而且在析构函数里对指针对象进行了释放，这时候如果使用浅拷贝，造成堆区空间重复释放，而引起程序崩溃。
深拷贝：相当于是把一个对象里的成员变量拷贝了一份儿，但是变量的地址又重新开辟了一个空间，解决的问题就是堆区重复释放造成程序崩溃的问题。
注：如果类里面没有指针对象在堆区开辟空间，那么浅拷贝和深拷贝的作用是一致的
5、this指针
this指针：它是一种特殊的指针，它是存在于类的普通成员函数里，C++提供this指针的目的是为了解决二义性问题，并且它是隐式的指针，它是指向当前类。 原型：成员函数（类名 * const register this）
使用格式：this->成员
this指针的使用:一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；另外一种情况是当参数与成员变量名相同时，如 this->a= a（不能写成a= a）。
注意：静态成员函数中没有this指针，友元函数中也没有this指针
6、static
static：用static声明函数或者是变量为静态的。
静态成员函数 格式：
static 返回值类型 函数名（参数列表）
{
//函数体
}
静态成员函数的访问格式
通过类的对象访问类的静态成员格式：（1）对象名.静态成员；（2）对象名->静态成员；
通过类访问类的静态成员格式：类名 ：：静态成员；
注意：
静态成员函数里没有this指针。
静态成员函数不能访问类的非静态成员。
类的非静态成员函数可以访问类的静态成员。
静态成员变量 格式：static 数据类型 变量名；
例如：static int a; 注：在类里面不能对类的静态成员变量进行初始化，需要在类外对静态成员变量进行初始化
类外初始化的格式：数据类型 类名 ：：静态成员变量名 = 初始值；
例如：int Test ：：a = 100;
static修饰情况：
修饰全局变量时，表明一个全局变量只对定义在同一文件中的函数可见。
修饰局部变量时，表明该变量的值不会因为函数终止而丢失。
修饰函数时，表明该函数只在同一文件中调用。
修饰类的数据成员，表明对该类所有对象这个数据成员都只有一个实例，即该实例归所有对象共有。
用static修饰不访问非静态数据成员的类成员函数。这意味着一个静态成员函数只能访问它的参数、类的静态数据成员和全局变量。
7、const
（1）const修饰成员变量 在类里声明的const成员变量可以不用声明的时候进行初始化，如果没有进行初始化就必须在构造函数的初始化列表中进行初始化的工作，const 可以在声明的时候不用进行初始化， 那么必须在构造函数初始化列表中进行初始化。
格式：const 类型 成员变量 = 值；
const int c = 1024；
（2）const修饰的成员函数 作用：用const修饰的成员函数中不能去更改类的成员变量的值（即const修饰的成员函数里对类的成员变量是一个只读的行为）。 格式：
返回值类型 函数名（参数列表）const
{
//函数体
}
例如：
void function（）const
{
//函数体
}
8、友元函数与友元类
8.1、友元函数
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保（protected）成员。 友元函数不是成员函数，在类中不占用资源。
声明格式（在类里声明）：friend 返回值类型 函数名（参数列表）； 定义（在类外定义）：
返回值类型 函数名（参数列表）
{
//函数体
}
示例程序：
#include <iostream>
#include <string>
using namespace std;
class A
{
public:
friend void show();//声明一个友元函数
private:
int b = 100;
};
void show()
{
A a; //实例化一个对象 a ，用来访问 A 类中的私有成员
a.b; // a.b / 使用 a 这个对象来访问 b。
cout << a.b << endl;
}
int main()
{
show();
return 0;
}程序执行结果：100
注：
友元函数虽然声明放置在类的内部，但是它不属于类的成员函数。
友元函数没有this指针。
给类的外部提供一个访问类的私有属性成员的接口。
8.2、友元类
C++提供了友元类就可以通过友元类访问类的私有成员，C++规定是友元类声明在一个其他类里，就表示该友元类是其他类的友元，那么就可以通过友元类访问其他类的私有成员，友元类的定义放置在其他类的外部。
友元是单向的，如将A类声明为B类的友元类，那么A类可以访问B类的所有成员 但是，B类不能访问A类的私有或保护成员 。
声明格式：friend class 类名；//声明了一个友元类
定义（在其他类外定义）：
class Test { //类体 }
示例程序：
#include <iostream>
#include <string>
using namespace std;
class A//声明一个类 A
{
public:
friend class B;//声明一个友元类
private:
int b = 100;//私有成员变量 b
};
class B//声明一个类 B；
{
public:
A a;//在 A 类中实例化一个对象 a ,用来访问 A 中的私有成员变量。
void show()
{
cout << "A类中私有成员变量 b= "<<a.b << endl;//访问A类中的私有成员变量 b。
}
};
int main()
{
B b;
b.show();
return 0;
}程序执行结果：
A类中私有成员变量 b= 100
总结：现在将c++学了一遍，对整个c++有了一个概括的认识，在这c++里面，类和对象是整个c++的重点，如果类与对象的认识不够，后续的其他c++知识恐怕也很难理解到位，所以掌握类和对象是很关键的。以上整理的知识，是对类和对象有一个最基础的认识。在今后的学习路上，希望与大家共勉。----加油！----
