类就像一个集装箱，将同一种事务放在同一个地方。
相当于小明，小红等都属于人这个大类。而小明，小明在c++中又被称为对象。
拿小明来举例子：
小明有他自己的身高，体重，年龄，这些都是小明有的称为对象的属性。当小明在自我介绍的时候需要说出自己的相关信息，说这个动作称为行为，在程序中通过函数来实现。
所以类就由2个部分组成对象属性和对象行为（也称为成员属性和成员函数）。
大致的代码如下（忘记加public了）
通过在主函数中可以创造对象与结构体类似
class person student//class可以省
student.name="xiaoming"
student.weight=90.5;
student.age=18;说道结构体，会发现类（class）和struct用法十分相似，二者最本质的区别就是权限不一样。
类一共有3个权限：
public：公开 （类内外都可以访问到）
private：私有（类内可以访问但是类外不行）
protected：保护（类内可以访问类外不行）
（private与protected的区别是子类是否能继承父类）
struct是public而class默认是private。
所以也可以用struct来建类。
通常我们通过公开函数作为接口来改变我们保护或者隐私函数的值（也叫作封装），提高代码的安全性。
#include<iostream>
#include<string>
using namespace std;
class person{
public:
void input_weight();
void input_name();
private:
double weight;
string name;
};
void person::input_weight(){
int x;//临时存储
cout<<"输入体重: "<<endl;
cin>>x;
weight=x;
}
void person::input_name(){
string x;//临时存储
cout<<"输入名字: "<<endl;
cin>>x;
name=x;
}类内的函数可以在类外定义，不过要在类内声明该函数。
::是表面所属的类。在一个团队中难免会碰上变量名相同的情况，用::来表示是属于某个部分的内容。
2.对象的初始化和删除,以及拷贝
? ? ? ? ?构造函数和析构函数是负责对象初始化和释放前的清除。
? ? ? ? 只要创建对象就一定会存在析构函数，拷贝函数，构造函数.
? ? ? ? 构造函数(初始化函数)
class person(){
person()//在（）后面可以加上：来初始化对象属性
{
cout<<"初始化成功"<<endl;
}
};
/*person():weight(10),high(20)
{
}
10和20也可以用变量不过这样括号里面就要加上变量名称*/? ? ? ? 这是类内声明的函数并且要保持公开才能用你写的构造函数否则是系统默认的空函数（只有空壳没有内容）
? ? ? ? 析构函数（释放对象前）
class person(){
public:
~person(){
cout<<"删除成功";
}
}? ? ? ? 析构函数中的括号不能带参数。构造函数是可以带参数的而且可以发生重载（如果构造函数带参数则创建的对象也要相应有参数）
（主函数）
运行结果图
现在让我们详细说说析构函数(拷贝构造函数)的使用。
一般来说有3中使用方法：
1.括号表示法：
person a;//不存在person a();编译器会默认为创造一个函数
person a(int b);//存在一个参数的时候.
//拷贝构造函数
person b(a);//括号内也为对象2.显示法
person a;//和第一种一样
//带一个参数
person a=person(10)//拿10举个例子,但是这样会创造一个临时对象，临时对象在这行代码结束后就会消失，也会运行析构和构造函数
//拷贝函数
person b=person a;3.隐式表示法
person a=10;//等价于person a=person(10)
//拷贝函数
person a=b;接下来是拷贝构造函数
分为2大类：深拷贝和浅拷贝
浅拷贝：这是指直接的赋值，如果成员存在指针类型的拷贝后会指向同一个地方。
!!!!在程序中，由程序员控制的内存分配叫堆，在程序的后面要进行释放。所以在析构函数中一般会存在像这样的代码
? delete和free用法很像。但是浅拷贝会出现一个问题因为他是完全复制的所以在堆区同一个地址会被释放2次造成程序奔溃。而深拷贝解决了这样的问题。
深拷贝是在浅拷贝的基础上在堆区再申请一个区域,解决了二次释放的问题。
person(const person &a){
weight=new int(*a.weight);
}3.类的对象可以是其他类
? ? ? ? 这里记作为类的类为大类，作为对象的类为小类。
在用小类时与平常对象使用方法差不多，不过2个类的析构和构造顺序不一样，
小类先构造，大类先析构。
4.静态成员函数
? ? ? ? 以static开始的函数称为静态函数，在类中就称为静态成员函数，所有对象共用这个函数，所有静态成员函数只能调用静态成员变量。
！！！静态成员变量不算成员对象
5.this指针
? ? ? ? this是每个对象自带的指针，指向对象本身。在变量名特别多的时候很好用。
#include<iostream>
using namespace std;
class person {
public:
void glow(int age) {
this->age=age;
}
void add(person &a){
this->age+=a.age;
}
int age;
};
int main() {
person I;
I.glow(18);
cout<<"我的年龄是： "<<I.age <<endl;
person You;
You.glow(10);
cout<<"你的年龄是： "<<You.age<<endl;
You.add(I);
cout<<"你的年龄是： "<<You.age<<endl;
return 0;
}
//结果是18,10,28。不过通过this可以实现最有意思的就是无限累加
#include<iostream>
using namespace std;
class person {
public:
void glow(int age) {
this->age=age;
}
person& add(person &a){
this->age+=a.age;
return *this;
}
int age;
};
int main() {
person I;
I.glow(18);
cout<<"我的年龄是： "<<I.age <<endl;
person You;
You.glow(10);
cout<<"你的年龄是： "<<You.age<<endl;
You.add(I).add(I).add(I).add(I).add(I).add(I);
cout<<"你的年龄是： "<<You.age<<endl;
return 0;
}通过对add的函数进行修改，*this指对象本身，使add函数返回的是一个对象就可以在下头进行累加。
6.常函数只能调用常对象，常对象也只能使用常函数。
? ? ? ? 用const修饰的对象和函数我们称之为常对象和常函数。如果想在常函数中使用非常变量就需要在声明变量前使用mutable这个关键词。
7.友元
? ? ? ? 友元和朋友的意思差不多给别人多一点的权限，就是称为友元的东西可以访问类内的私有属性的东西
#include<iostream>
using namespace std;
class xiaoming {
public:
xiaoming() {
weight=80;
high=180;
}
int high;
private:
int weight;
};
void ask() {
xiaoming me;
cout<<"小明身高是: "<<me.high<<endl;
}
int main() {
ask();
return 0;
}上面这段可以访问公共属性没什么问题?但是这时候如果想让ask这函数访问weight就不能实现了这时候就出现了友元的作用。
#include<iostream>
using namespace std;
class xiaoming {
friend void ask();
public:
xiaoming() {
weight=80;
high=180;
}
int high;
private:
int weight;
};
void ask() {
xiaoming me;
cout<<"小明身高是: "<<me.high<<endl;
cout<<"小明体重是: "<<me.weight<<endl;
}
int main() {
ask();
return 0;
}?友元关键词是friend在类声明完后紧接着就是友元的声明。不仅全局函数可以作为友元，成员函数（其他类的函数），其他类都可以作为友元声明方式类似。