继承，重载函数，派生函数

继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。

继承（Inheritance）可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类B继承于类A，那么B就拥有A的成员变量和成员函数。被继承的类称为父类或基类，继承的类称为子类或派生类。

使用继承的好处还有什么时候使用继承

1) 当你创建的新类与现有的类相似，只是多出若干成员变量或成员函数时，可以使用继承，这样不但会减少代码量，而且新类会拥有基类的所有功能。
2) 当你需要创建多个类，它们拥有很多相似的成员变量或成员函数时，也可以使用继承。可以将这些类的共同成员提取出来，定义为基类，

定义方式为：

class 派生类名:［继承方式］ 基类名（父类）{
    派生类新增加的成员
};

继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private（私有的）或者protected。

例如：

//继承
#include<iostream>

using namespace std;
class point{
public:
void p(float xx=0,float yy=0)
{
X=xx; Y=yy;
}
void move(float xo,float yo){
X+=xo; Y+=yo;
}
float getX(){
return X;
}
float getY(){
return Y;
}
private:
float X,Y;
};

class Rectangle:public point{    //公有继承，
public:
void initR(float x,float y,float w,float h){
p(x,y);
W=w;
H=h;
}

float getW(){
return W;
}
float getH(){
return H;
}

private:
float W,H;
};

int main(){
Rectangle rect;
rect.initR(3,5,7,9);
cout<<rect.getX()<<','<<rect.getY()<<','<<rect.getH()<<','<<rect.getW()<<endl;
system("pause");
return 0;
}

重点

1) public继承方式

• 基类中所有protected成员和private成员在派生类中可以被调用；
• 基类中所有private成员在派生类中不可访问。

2) protected继承方式

• 基类中所有protected成员和private成员在派生类中可以被调用；
• 基类中的所有private成员在派生类中仍然不可访问。

3) private继承方式

     基类中所有protected成员和private成员在派生类中可以被调用；

• 基类中的所有private成员在派生类中均不可访问。

由此可见：

• 基类中的 private 成员在派生类中始终是不可访问的。

     private 继承限制太多，实际开发中很少使用，一般使用 public。

在构造函数中，子类无法取得父类的私有属性，只能借助 父类的成员函数来间接访问。，然后在子类调用父类public里面的成员函数

多级继承

类A为基类，类B继承自类A，类C又继承自类B，那么类C也是类A的派生类，它们构成了多级继承的关系

//多重继承

#include<iostream>
using namespace std;

class  A{
public:
void showA(){
cout<<"爷爷 "<<endl;
}
};
class  B{
public:
void showB(){
cout<<"父亲 "<<endl;
}
};

class C:public A,private B{    //多重继承，顺序没关系，主要是继承类型
public:
void showC(){
showA();
showB();
}
};
int main(){
C c;
c.showC();
c.showA();
c.showB(); //错误。私有继承的派生实例无法访问无法访问父类的成员变量和函数
system("pause");
return 0;
}
//私有继承： public里面的数据和函数可以访问。private不能访问，protected可以访问：
//重点）；
//私有继承的派生类实例不能直接访问父类的成员变量和函数，

重载函数：

重载函数;在一个类中，有两个名字相同的函数，函数名一样，重而形成重载函数
函数的参数类型不一样
int add(int x,int y)
flost add(float x,float y)
函数的参数个数不一样
int add(int x,int y)
int add(int x,int y,int z)

//重载函数
#include<iostream>
using namespace std;

class  A{
public:
int add(int x,int y){   
return x+y;
}
float add(double x,double y){       //根据参数来确定调用拿个函数
return x+y;
}
};
int main(){
A abc;
cout<<abc.add(10,10)<<endl;
system("pause");
return 0;
}
//float型在C++里面默认为double

特别注意：
#include<iostream>

using namespace std;
class B1{        //基类B1，构造函数有参数
public:
B1(int i){
cout<<i<<endl;
}
};
class B2{        //基类B2，构造函数有参
public:
B2(int j){
cout<<j<<endl;
}
};
class B3{        //基类B3，构造函数无参数
public:
B3(){
cout<<'*'<<endl;
}
};
class C:public B3,public B2,public B1{      //从左到右的顺序
public:                          //派生类的公有成员
C(int a,int b,int c,int d):B1(a),memberB2(d),memberB1(c),B2(b){}      //调用父类的构造函数，传值
private:                     //派生类的私有对象成员
B1 memberB1;
B2 memberB2;        //上到下的顺序
B3 memberB3;
};

int main(){
C obj(1,2,3,4);
system("pause");
return 0;
}
//运行结果为


//构造函数的调用次序：1：按照构造函数的调用次序
//重点 ： C(int a,int b,int c,int d):B1(a),memberB2(d),memberB1(c),B2(b){}  调用父类的构造函数，传值
//2：成员变量 变成类，按照顺序执行