this指针：（通过一个典型的例子来认识他）
class Human
{
char fishc;
Human(char fishc);//构造函数
};
Human::Human(char fishc)//对构造函数进行初始化
{
fishc=fishc;//意图就是把这个传入参数赋值给这个上边类属性的fishc
}
//但是这样赋值的话，他们的名字一样，这样的话构造器就有可能认不出来，（因为他不知道你是要把属性去覆盖参数，还是把传入的参数去覆盖给属性，因为两者的名字一样，但是语法没有错。他们是两个不同区域的一个是传入的参数，一个是类的属性，（因为他们位于两个不同的区域，所以语法上没有错））
//所以怎么让构造器知道哪个是参数哪个是属性呢？这个时候就需要用到this指针。
this->fishc=fishc;//this指针是指向当前的类生成的对象//所以就很明显前者是类的属性，后边是参数。
//这样的话编译器就懂了，赋值操作符的左边将被解释为当前对象的fishc属性，右边将被解释为构造器的传入来的fishc的参数。
//PS：注意使用this指针的基本原则是如果代码不存在二义性隐患，就不必使用this指针。
------------类的继承-------
继承机制使得程序员可以创建一个类的堆叠层次结构，每个子类均将继承在他的基类里定义的方法和属性。（在继承原有方法的同时，再增加另外的一些属性的方法）（通过继承机制可以对现有的代码进行进一步的扩展，并应用在新的程序中）
（1）他们都是动物的子类。我们可以编写一个Animal作为Turtle和Pig的基类。
继承类的语法：
//语法：
class SubClass:public Superclass{...}
//例子：
class Pig:public Animal{...}基类是可以派生出其他的类，也称为父类和超类；子类是从基类派生出来的类（比如Turtle类和Pig类）。
实现如下：
#include<iostream>
#include<string>
class Anmial//声明一个基类
{
public:
std::string mouth;
void eat();
void sleep();
void drool();
};
//继承基类
class Pig:public Animal
{
public:
void climb();
};
class Turtle:public Animal
{
public:
void swim();
};
//对上述方法进行补充
void Animal::eat()
{
std::cout<<"我正在吃"<<std::endl；
}
void Animal::sleep()
{
std::cout<<"我正在睡觉"<<std::endl；
}
void Animal::eat()
{
std::cout<<"我正在流口水"<<std::endl；
}//上述把基类的三个方法给搞定了
//下面实现子类的方法（不管他们是基类还是父类，他们都是方法就按照类的方法实现来写）
void Pig::climb()
{
std::cout<<"我会爬树"<<std::endl;
}
void Turtle::swim()
{
std::cout<<"我会游泳"<<std::endl；
}
int main()
{
//对类进行实例化
Pig pig;
Turtle turtle;
pig.sleep();
turtle.sleep();
pig.climb();
turtle.swim();
}------带参数的构造器----
扫描二维码关注公众号，回复：
11962676 查看本文章
//构造器带着输入参数
//1、声明
class Animal
{
public:
Animal(std::string thename);
std::string name;
};
class Pig:public Animal
{
public:
Pig(std::string thename);
};
//2、方法定义
Animal::Animal(std::string thename)
{
name=thename;
}
Pig::Pig(std::string thename):Animal(thename)//Pig的构造器继承Animal的构造器
{
}
因为Pig的方法里面是空的，他是直接继承于Animal的方法的。
------访问控制--------
上述类的所有成员都是用public：语句声明。
所谓的访问控制就是c++提供了一种用来保护类里的方法和属性的手段。
-------覆盖------
（既有共同特征又需要在不同类里有不同的实现方法）意思就是在类里边重新声明一下这个方法，他的函数名字参数返回值一摸一样（不然的话就会变成重载了）。
例子：为Animal添加eat方法，并在子类中进行覆盖。
-------重载方法--------
继承之后不能重载。（子类里边不能重载）
----友元-------
声明另外一个类是这个类的友元类，友元关系是类之间的一种特殊关系，这种特殊关系不仅允许友元类访问对方的public方法和属性，还允许友元访问对方的protected和private方法和属性。
声明一个友元关系的语法，在类声明里的某个地方加上一条friend class **就行了（其中**表示你需要友元的另一个类的那个名字）。
注意这条语句可以放在任何地方，放在public，protected和private段落里边都可以。（这样之后他们两个人就相当于是同一个人）
例子:定义Lovers这个类，有两个子类Boyfriend和Girlfriend。Lovers类的方法kiss()和ask()；第三者Others类，想要kiss()Girlfriend类的对象。
#include<stdio.h>
#include<iostream>
class Lovers
{
public:
Lovers(std::string theName);//构造函数，就是给他命名
void kiss(Lovers* lover);//参数声明一个指针，
void ask(Lovers* lover,std::string something);
protected:
std::string name;
friend class others;//这时候others跟Lovers就是一对。
};
class Boyfriend:public Lovers
{
public:
Boyfriend(std::string theName);
};
class Girlfriend:public Lovers
{
public:
Girlfriend(std::string theName);
};
class Others
{
public:
Others(std::string theName);
void kiss(Lovers* lover);
protected:
std::string name;//Lover->name属于这个类的protected
};
Lovers::Lovers(std::string theName);
{
name=theName;//构造函数给它命名，也就是说我们造一个人出来的时候，
}
void Lovers::kiss(Lovers* lover)
{
std::cout<<name<<"亲亲"<<lover->name<<std::endl;
}
void Lovers::ask(Lovers* lover,std::string something)
{
std::cout<<Lover->name<<"帮我"<<something<<std::endl;
}
//子类
Boyfriend::Boyfriend(std::string name):Lovers(theName)
{
}
Girlfriend::Girlfriend(std::string name):Lovers(theName)
{
}
//友元类
Others::Others(std::string theName);
{
name=theName;//构造函数给它命名，也就是说我们造一个人出来的时候，
}
void Others::kiss(Lovers* lover)//这个里边的参数引用到了lover
{
std::cout<<name<<"吻一下"<<lover->name<<std::endl;//lover->name属于这个Lovers类的protected,不是这个类的子类根本访问不到，而others不是它的子类，所以理论上是访问不到的，这里因为上边是friend class others;所以可以访问到。
}
//主函数
int main()
{
Boyfriend boyfriend("A君");//造一个人出来给它命名叫做A君（构造函数）
Girlfriend girlfriend("B妞");//叫做B妞
Others others("路人甲")；//others这个陌生人叫做路人甲
girlfriend.kiss(&boyfriend);//因为参数是指针所以传进去的应该是对象的地址
girlfriend.ask(&boyfriend,"拖地")
std::cout<<"传说中的友元类，路人甲出现了\n"<<std::endl;
others.kiss(&girlfriend);
return 0;
}-------静态属性和静态方法-------
创建一个静态属性和静态方法：只需要在他的声明前加上static保留字即可。
#include<string>
#include<iostream>
class Pet
{
public:
Pet(std::string theName);//带参数的构造器
~Pet();
static int getCount();//这里作为一个接口，用来给他由他生成的对象来获取他这个计数器
protected:
std::string name;
private://private是这个类里的方法才能够调用的，getCount()函数可以调用//private成员只有这个类里边的方法才能够访问它
static int count;//私有成员，一个count计数器
};
class Dog :public Pet//继承Pet类
{
public:
Dog(std::string theName);
~Dog();
};
class Cat :public Pet//继承Pet类
{
public:
Cat(std::string theName);
~Cat();
};
int Pet::count = 0;//这一句做了两件事；第一：让编译器为count这个变量的值分配内存；第二：这个变量因为是在静态存储区，他是把这个变量初始化为0；
Pet::Pet(std::string theName)//构造函数，当该构造函数被调用的时候说明这个宠物已经被建造出来了
{
name = theName;
count++;//那么这个计数器就加一
std::cout << "一只宠物变出来了，名字叫做：" << name << std::endl;
}
Pet::~Pet()//析构器
{
count--; //析构器说明这个宠物已经挂掉了，所以计数器要减掉
std::cout << name << "挂掉了" << std::endl;
}
int Pet::getCount()//这个接口函数getCount()的唯一作用，把这个count返回出来，把他拿到的这个私有成员返回出来，然后show出来
{
return count;//是为了任何代码都可以通过调用getCount()函数（因为是public）从而来读取该属性count的值（因为该值是private，所以对该属性只能是读不能是写，只有在Pet的析构函数和构造函数才能够对他进行写）
}
Dog::Dog(std::string theName) :Pet(theName)//Dog的构造器继承Pet的构造器
{
//std::cout<<"this："<<this<<endl;//1生成一个dog对象之后就把this指针给打印出来//按此它生成一个dog对象的时候this指针应该是指向dog对象的。下边生成dog对象
}
Dog::~Dog()
{
}
Cat::Cat(std::string theName) :Pet(theName)
{
}
Cat::~Cat()
{
}
int main()
{
Dog dog("Tom");//整了一只狗dog叫做Tom（继承构造器的实现）//用Dog类生产出dog对象
Cat cat("Jerry");//整了一只猫叫做Jerry
std::cout<<"dog:"<<&dog<<std::endl;//2这里生成dog对象之后，我们把dog也给打印出来
std::cout << "已经诞生了" << Pet::getCount() << "只宠物！\n\n";//显示出来//getCount()函数调用私有成员count
{//注意这里的大括号，是有作用的。这里相当于是一个区域
Dog dog_2("Tom_2");//又整了一只狗
Cat cat_2("Jerry_2");//又整了一只猫
std::cout << "现在呢，已经诞生了" << Pet::getCount() << "只宠物！\n\n";
}//到此之前还剩下两只，因为大括号之后析构函数了，把宠物给毁掉
std::cout << "\n现在还剩下" << Pet::getCount() << "只宠物！\n\n";
return 0;//return 0的时候一只宠物都没有了，因为析构函数了，把宠物给毁掉
}
//上述1和2处打印的地址完全一样结果：右边结果是去掉main函数中间的大括号的
static静态变量的详解：https://www.cnblogs.com/dc10101/archive/2007/08/22/865556.html
静态成员是所有对象共享的，所以不能在静态方法里访问非静态的元素。
非静态方法可以访问类的静态成员，也可以访问类的非静态成员。
C++内存分配方式详解——堆、栈、自由存储区、全局/静态存储区和常量存储区：https://fishc.com.cn/blog-9-1097.html
this指针：this指针是类的一个自动生成，自动隐藏的私有成员，它存在于类的非静态成员函数中，指向被调用函数所在的对象的地址。（也就是说我生成每一个对象的时候，它都会自动生成一个this指针，这个指针指向的是对象它的一个地址）当一个对象被创建时，该对象的this指针就会自动指向对象数据的首地址。
#include<iostream>
class Point
{
private:
int x,y;
public:
point(int a,intb)
{
x=a;
y=b
}
void MovePoint(int a,int b)
{
x=a;
y=b;
}
void print()
{
std::cout<<"x="<<x<<"y="<<y<<endl;
}
};
int main()
{
Point point1(10,10);//用Point这个类生产出Point1这个对象。这个点的坐标在（10，10）这个位置
Point1.MovePoint(2,2);
point1.print();
return 0;
}
//当对象point1调用MovePoint这个成员的时候，（实时上我们生成point1这个对象的时候，就有一个this指针指向point1的地址），当他调用MovePoint这个函数的时候，即将point1对象的地址传递给this指针，（因为我们需要用到的是point1这个对象的成员，那我们就必须知道这个对象的地址，就必须传递给this指针）
//MovePoint函数的原型事实上应该是 void MovePoint(Point* this,int a,int b);他有三个参数，一个是隐含的this指针它指向Point对象（第一个参数是指向该类对象的一个指针，我们在定义成员函数时没看见是因为这个参数在类中是隐含的，是C++的一个规则，因为每一个都是默认添加进第一个规则）。
//这样子pOint1的地址就传递给this，所以在MovePoint()函数中便可以显示的写成void MovePoint(int a,int b)（this->x=a;this->y=b）(其实也可以x=a,这样编译器知道哪一个是参数哪一个是变量，用this做区分)
//我们这样就可以知道point1调用该函数后，也就是point1的数据成员被调用并更新了值。