前前言：如果有时间，搜一个完整的教程看，用到啥学啥，这样可能可以省更多的时间==
前言：C++的命名规范
C++命名规范_ajioy的博客-CSDN博客
和“&”符号的多重含义
C++ 引用详解(引用的特点，引用与指针的区别，引用的其他使用)_Mi ronin的博客-CSDN博客_c++引用
以下内容参考：
c++面向对象编程速成！90分钟搞定_哔哩哔哩_bilibili
一、Class（类）
和C语言中的结构体类似，只不过分成了public和private两类成员
class student//大括号里的叫类定义
{
private://私有成员，若不写private，默认是private，私有成员的初始化和引用都不能在主函数中直接调用，需要用该类的成员函数（方法）或友元函数进行操作。
int age;//private中的变量不能直接赋值如age=1(C++11中允许这样的操作)，而public中的变量可以直接进行初始化。
protected：
int height；//保护成员也不能通过对象访问，但是可以被该类或派生类的成员函数进行操作。
public：//公有成员，其定义了类的外部接口
string name;
}；
student a；//定义student类的对象（object），名字叫a
a.name ="KL";//给a中的属性（成员数据）name赋值
声明：文中关于public和private的定义是野路子写法，以方便举例说明。
二、类的成员函数（又叫方法）
成员函数的实现（定义），可以放在类的里面，也可以放在类的外面。
1.成员函数（类中的成员函数本质上就是对成员数据进行读读写写，加加减减的修改）的重载：
class student
{
public：
int age；
string name；
bool set(int a);//这个就是成员函数的声明，又叫方法。这个函数的定义写在类的外面，set()函数的定义可以用template,也可以分开定义两次
bool set(string b);//两个函数名字一样，但输入格式不一样，也是可以的。调用时，a.set(10)然后根据函数定义返回ture/false
}；
2.构造函数（本质就是对象的初始化）和带参数的构造函数
构造函数(只在创建对象的时候使用，从“构造”二字就可以看出来)的特点：
a.被声明为公有
b.函数名与类名相同
c.可以重载
d.不能指定返回类型
e.不能显示调用
class student//类定义里先声明构造函数
{
public：
int age；
string name；
void student（）；//这是构造函数，没有返回值和输入值，并且名字和类的名字一样
void student（int a,string b）;//同名的构造函数声明，即重载，带两个输入参数，即name和age
}；
void student::student（）//构造函数定义，前一个student代表类，后一个student代表构造函数，注意这个函数没有输入值
{
age=20；//构造函数里，可以对全部的成员数据给一个默认值
name=“KL”；
}
void student::student（int a，string b）//构造函数定义，前一个student代表类，后一个student代表带参数的构造函数
{
age=a；//构造函数里，可以对全部的成员数据给一个默认值
name=b；
}
//下面是主函数
student aa；//新建一个student类的对象，名字叫aa，这里将自动调用构造函数给age和name分配的默认值
student bb(20,"KL");//构造函数重载，新建一个student类的对象bb，同时动态输入名字和年龄
3.析构函数（销毁内存数据，一般大型程序代码中才能见到）
定义方法：
student::~student()
4.常成员函数 const
一个方法只读取属性，而不修改属性，就是常成员函数。
class student
{
public：
int age=1；
string name=“KL”；//非const类型可以在类外完成初始化，若为const型，必须在声明位置就进行赋值
bool set（int i）；//这个就是成员函数的声明，又叫方法
bool read（）const；//后面加了const，表示这个函数只读不写
}；
bool student::read() const//常成员函数内容，后面加了const，只读不写
{
cout<<name;//常成员函数只能调用常数据成员
cout<<age;
return ture;
}
//主函数
student aa;//创建对象
aa.read();//在创建aa后，调用read的方法；
在函数参数前加const表示参数在传入函数内后不能进行修改，以此保护参数。
5.静态成员static
在类定义中加入静态成员数据，静态成员函数
class student
{
public:
int age;//成员数据，年龄
string name；//成员数据，名字
student（）；//这是没参数的构造函数，创建对象是给age、name默认值
static int cnt；//static表示静态成员数据，其写在最前面，统计有多少个对象
static int count（）；//static表示静态成员函数，返回有多少个对象
}
定义静态成员：
student::student（）//构造函数定义
{
age=20；
name=“KL”；
Cnt=cnt+1；//每次调用构造函数创建对象时，cnt加一，就可以统计出有多少对象了
}
int student::count()//静态成员函数的定义，注意这里不写static
{
return cnt；//返回静态成员数据
}
在主函数中使用静态成员函数：
student aa;//创建对象aa
student bb;//创建对象bb
aa.count();//调用count方法，返回静态成员数据cnt=2，表示已建立两个对象
bb.count();//同样，返回的静态成员数据cnt=2，和aa.count()一样
student::count（）；//返回静态成员数据cnt=2，这个写法和aa.count（）效果完全一样，只有不依赖于对象的静态函数才可以这么写，相当于静态函数是属于类的，而不属于对象
6.this指针
this指针是类创建时自带的隐式指针，一个类可以创建多个对象a,b,c，但这多个对象共用类中的函数，当对象a调用类中的成员时，this指向a（即a=*this）,当对象b调用类中的成员时，this指向b（即b=*this）,以此实现共用的功能。和static 函数一样，都是面对类层面上的操作。
看到一句总结this的话：“关键字this告诉编译器正在引用此类的当前实例”。
7.友元函数
在调用类的私有成员时，一般是用类的public中的成员函数对私有成员进行操作。友元函数是在类中说明的由关键字friend修饰的非成员函数，他不是当前类的成员函数，而是独立于当前类的外部函数，但他可以访问该类的所有对象的成员。这样能使两个类相互合作、协调工作。（感觉有点鸡肋）
三、public和private
设置private的目的：
高手：对类的外部隐藏了类内部工作机制，即所谓“封装性”
新手：public的内容，可以在主函数看到，private内容只能在类的内部看到。
class student
{
private：
void print_age();//这个print年龄是私有的方法
public：
void print_name();//这个print名字是公有的方法
}；
void student::print_name()//定义print name公有方法
{cout<<"KL";}
void student::print_age()//定义print age私有方法
{cout<<"20";}
//以下是主函数
student aa;
aa.print_name();//调用公有方法
aa.print_age();//调用私有方法，不允许，会报错
私有方法不是不能用，是有条件（核心思想：通过公有方法的外壳调用私有方法）：
class student
{
private：
void print_age_private();//这个print_age_private是私有的方法
public：
void print_age_public();//这个print_age_public名字是公有的方法
}；
void student::print_age_public()//定义print_age_public公有方法
{print_age_private();}//重点来了，这里通过公有方法的外壳调用了私有方法。注意：函数一般包括三个阶段，定义、声明和调用，定义和声明都要对函数的参数和返回值进行说明，以告诉编译器该函数的完整信息。调用的时候直接用函数名就行，不要加返回值，即使返回值是void也不行！！！
void student::print_age_private()//定义print_age_private私有方法
{cout<<"20";}
//以下是主函数
student aa;
aa.print_age_public();//通过公有的外壳调用私有，然后打印出来
aa.print_age_private();//调用私有方法，不允许，会报错
注意：正规类的定义的写法：一般“方法”全部放在public中，“属性”放在private中。以防止随意修改数据。
四、类的派生继承
派生是相对于父类而言的，继承是相对于子类而言的。
子类全部继承基类（父类），但是不能访问继承的基类private，只有基类才能访问，等于子类继承的基类private成员隐藏了。private和protected的不同点：在同一类中视为一样，但在继承中就不同了，private在派生类中不可以被访问，而protected可以。
以下代码表示在不同情况下的继承和子类的构造函数相关内容：
class postgraduate：public student//研究生类定义，如果student中分为public和private，虽然全部继承了但仅可以调用student的public，如果student中分为public和protected，则student中的public和protected都可以调用
{
public：
string research；//这行新增定义了一个公开的属性research
postgraduate（）；//无参数的构造函数声明
postgraduate（int a,string b,string c）;//带参数的构造函数声明，参数为年龄姓名和研究方向
}；
postgraduate::postgraduate（）//无参数的构造函数定义
{
research =“asic design”；//对研究生的research属性进行赋值为asic design，注意没有age和name
}
postgraduate::postgraduate（int a,string b,string c）：student（a,b）//带参数的构造函数定义,student（a,b）含义看主函数中的注释
{
research =“c”；//将c的赋值给research
}
//下面是主函数:
postgraduate aa;//创建研究生对象aa,调用无参数构造函数。这里程序创建子类aa对象时，系统首先自动运行父类student构造函数，对age和name进行赋值，随后运行子类postgraduate构造函数，对aa对象进行拓展，增加research内容。换句话说，子类只能调用而不能继承父类的构造函数。
postgraduate bb(25,"KL"，“ASIC design”)；//创建研究生对象bb,传入带有参数的构造函数，这里程序会先调用父类student构造函数，把“25”和“KL”两个值传入父类student带参数的构造函数。随后把参数c=“asic design”传给bb自己的research属性。
五、多态
主要是讨论子类和父类中同名函数的问题，三种方法：重载、隐藏、覆盖。后续要用到在学吧==
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
