1. 类与类之间的关系
class A
{
public:
int a;
void funcA()
{}
}
包含：
class B
{
public:
void funcB(){}
A a;
}
//如果类B有类A的成员变量，那么B has A，类B依赖于类A
使用：
class C
{
public:
void funC(A *a)
{
}
}
//C的成员方法需要A的形参，C use A
*B与A的耦合度比C要高。
//
继承：
class D:public A
{
void funcD()
{
}
D(int a):A(a) //与C#不同的地方，C#是D(int a):base(a)，可能是C++有多重继承的原因
{
//..
}
}
*D si A，耦合度最高。
//为什么要写public 呢？应该是确定能否通过D来访问A的成员？？？
has A，use A, is A;
2.
A->B->C
A->B1->C1
B->D
B1->D
D是多继承
3.类的继承方式
这是和C#不同的地方，C#没有继承方式，继承就是继承了，就算有，C#都是public继承， A中的成员的“外部和继承可访问性”，继承后还是一样。
C++通过继承方式，限制了继承后，改变了原来A“对外和继承的可访问性”。
更多是private和protect的继承方式，对原来A中public的影响最大
*一般用public就行了，其他继承方式不建议使用。
4. 类的兼容原则
class A;
class Aplus:public A;
int main()
{
Aplus ap;
A a=ap;
}
//跟C#类似，能里氏替换，c#子类引用变量能赋值给父类引用变量；
//C++因为子类有父类的所有东西，所以能给父类的所有字段初始化；
//父类指针可以指向子类对象
//父类引用可以引用子类对象
//左父=右子（右子赋值（=号操作符）给左父，右子初始化左父（构造函数））
//子类能够满足父类指针、引用、变量的全部需求。反之不行。
5. 子类构造析构
构造函数，跟C#一样，会先调用父类的构造函数
6. 继承中，子类的成员和父类成员有重名：
子类内部
void func()
{
this->a=1;
A::a=1;//注意，这里要和使用静态的成员区分。
}
//一般都避免这样
//C++的继承其实是很粗暴的，内存的开辟直接堆上去，不管重不重名，有就堆上去。
//C#中，子类的字段不能和父类同名，属性也是，如果非要同名，要加public new int Age{ get;set;}
7.
class A
{
public:
static int a;//静态变量在静态区，继承方式是影响不了其访问性
}
int A::a=100;//静态变量初始化
//
int main()
{
A a;
cout<<a.a<<endl;
}
8. 多继承
//
class Furniture
{
public : int price;
}
class Sofa:public Furniture;
class Bed:public Furniture;
class SofaBed:public Bed,public Sofa;
//
那SofaBed就有两个price空间的大小了(c++粗暴的堆上去)，那只能
int main()
{
SofaBed sb;
sb.Bed::price=100;
sb.Sofa::price=200;
}
//这是和C#不同的地方，C#没有多继承
9. 虚继承 （一般很少这样做）
**要不想这样子，给两个price赋值，那么只能：
class Sofa:vitual public Furniture;//加virtual
class Bed:vitual public Furniture;//加virtual
class SofaBed:public Bed,public Sofa;//不变
####出现棱形继承#####
**父类继承爷爷类的时候加virtual
**virtual继承，只是为了开辟“爷类”的字段一次
#区别开C#中的virtual方法，C#中virtual只是用来标记方法，能被子类重新，在以父类或者子类引用的方式调用时，均会执行子类的重写的方法。
10. C++中的虚方法（重要）
class A {
public:
function()
{
//...
}
};
class Aplus:public A
{
public:
function()
{
//...
}
}
//
int main()
{
A *a=new Aplus();//左父右子
a->Function();//这里是调用了A的fuction，不写成虚方法，就执行指针类型的funtion;
}
(这种又叫重定义，调用以A的指针调用function，那么执行A的function；以Aplus的指针调用function，那么执行Aplus的function。)
//这里又和C#不同了，同名方法没有标记为virtual都可以继承。
//C++是父类型指针变量，指向子类对象，能调用子类方法。
***如果想象C#一样，用父类变量引用子类对象，依然可以执行子类的方法。
解决办法：
class A {
public:
vitual function()//虚方法
{
//...
}
};
//这里又和C#不同了，子类不需要在方法前写override
****************但是，习惯上也在子类的方法前加virtual，做一个标识作用，就当做C#中的override****************
//在.cpp文件中，实现虚方法，就不需要加virtual了。
11. 虚析构函数（重要）
防止在使用“左父-右子”的父指针 delete father，如果不标记析构函数为virtual（原因见下），只能析构父类的空间。子类写成virtual析构，能两个析构都调用，不用自己再在子析构中，显式调用父析构。
***特别是用工厂方法new对象时，较为要紧*********
*在正常析构子类对象时，父类对象能自动析构
***********继承也要注意父析构函数标记virtual**********
13. vtpr指针（重要）。
vtpr指针，是指向虚函数表的指针。
例如：A中有virtual fun1(); Aplus重写；
fun1会放到A的虚函数表；fun1会放到Aplus的虚函数表；
当
A a=new Aplus();
a->fun1();
编译器发现fun1()是虚的，应该会额外标记（重要步骤）。在运行的时候，vtpr指针会去虚函数表找fun1的函数，因为a实质上是Aplus，所以实质上是去找Aplus的虚函数表。
//所以，如果A的fun1没标记为virtual，那么编译自然不会额外标记了，在运行时就只按照A类查找普通的函数表；
//小知识，同样的类，有函数加了virtual，那么sizeof(A)会莫名增大，因为多了vtpr指针的大小。
//不要在父类构造函数中调用virtual函数，否则子类vtpr指针还没初始化好，调的依然是父类的函数，vtpr指针是随着各个父类的构造函数，不断变换指向，直到最后的子类的。
14. 指针步长
A array[] = {Aplus(0),{Aplus(1),{Aplus(2)};//相当于C#A[] array = {new Aplus(0),..};
可以使用array代表是指向第一个元素的地址；
array++可以指向第二个元素；但是，要注意的是，array++是按A的内存大小，往下跳的，如果Aplus所占用的大小大于A，那么array++会跳到一个错误的位置。
15. 纯虚函数，抽象类（C++没有C#中的接口，但是有纯虚函数）
class shape{
public:
double height;
double weight;
virtual int func()=0;//=0只是一个语法，标记为纯虚函数。并不是返回值
shape(){}
virtual ~shape(){}//抽象类最好提供一下虚析构
}
//如果一个类有纯虚函数，那么就是抽象类，不管有没有普通函数。
//跟C#一样，抽象类不能实例化。
//跟C#一样，抽象类能继承抽象类。
/ /跟C#不一样，C#的抽象类必须写成abstract，而且可以写virtual函数，virtual函数能有实现，反而抽象函数，要标记开abstract
class A:public Interface;