继承是类与类之间的关系,是一个很简单很直观的概念,与现实世界中的继承(例如儿子继承父亲财产)类似。
继承(Inheritance)可以理解为一个类从另一个类获取成员变量和成员函数的过程。例如类B继承于类A,那么B就拥有A的成员变量和成员函数。被继承的类称为父类或基类,继承的类称为子类或派生类。
使用继承的好处还有什么时候使用继承
1) 当你创建的新类与现有的类相似,只是多出若干成员变量或成员函数时,可以使用继承,这样不但会减少代码量,而且新类会拥有基类的所有功能。
2) 当你需要创建多个类,它们拥有很多相似的成员变量或成员函数时,也可以使用继承。可以将这些类的共同成员提取出来,定义为基类,
2) 当你需要创建多个类,它们拥有很多相似的成员变量或成员函数时,也可以使用继承。可以将这些类的共同成员提取出来,定义为基类,
定义方式为:
class 派生类名:[继承方式] 基类名(父类){ 派生类新增加的成员 };继承方式包括 public(公有的)、private(私有的)和 protected(受保护的),此项是可选的,如果不写,那么默认为 private(私有的)或者protected。
例如:
//继承
#include<iostream>
#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继承方式
2) protected继承方式
3) private继承方式
- 基类中所有protected成员和private成员在派生类中可以被调用;
- 基类中所有private成员在派生类中不可访问。
2) protected继承方式
- 基类中所有protected成员和private成员在派生类中可以被调用;
- 基类中的所有private成员在派生类中仍然不可访问。
3) private继承方式
基类中所有protected成员和private成员在派生类中可以被调用;
- 基类中的所有private成员在派生类中均不可访问。
由此可见:
- 基类中的 private 成员在派生类中始终是不可访问的。
在构造函数中,子类无法取得父类的私有属性,只能借助 父类的成员函数来间接访问。,然后在子类调用父类public里面的成员函数
多级继承
类A为基类,类B继承自类A,类C又继承自类B,那么类C也是类A的派生类,它们构成了多级继承的关系
//多重继承
#include<iostream>
using namespace std;
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)
函数的参数类型不一样
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;
#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:成员变量 变成类,按照顺序执行
#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:成员变量 变成类,按照顺序执行