C++之继承(一)
1、继承的基本语法
1.1、什么是类的继承？
- 类的继承，是新的类从已有类那里得到已有的特性。或从已有类产生新类的过程就是类的派生。原有的类称为基类或父类，产生的新类称为派生类或子类。
- 默认的继承方式是 private 私有继承。一个派生类可以同时有多个基类，这种情况称为多重继承，派生类只有一个基类，称为单继承。
单继承派生类
class 派生类名： [继承方式] 基类名
{};
多继承派生类
派生类名:public 基类名 1， public 基类名 2， ...,protected 基类名 n
{};
2、继承的构造函数
总参数列表：子类的形参和所有基类的形参总和
内嵌子对象：本质组合类
无内嵌对象的子类构造函数
派生类名::派生类名(总参列表):基类名(参数表)
{}
//无内嵌子对象的子类构造函数
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class B: public A
{
public:
B(int b1,int a1):A(a1)
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2);
return 0;
}
//输出：
//A()
//B()
含内嵌子对象的子类
派生类名::派生类名(总参列表):基类名(参数表),内嵌子对象(参数表)
{}
//含内嵌子对象的子类
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B: public A
{
public:
B(int b1,int a1,int c1):A(a1),MYC(c1)
{
cout<<"B()"<<endl;
}
private:
C MYC;
};
int main()
{
B b(1,2,3);
return 0;
}
//输出：
//A()
//C()
//B()
含内嵌子对象的多继承子类
派生类名::派生类名(总参列表)：
基类名 1(参数表 1)，基类名(参数名 2)....基类名 n(参数名 n)，
内嵌子对象 1(参数表 1),内嵌子对象 2(参数表 2)...内嵌子对象 n(参数表 n)
{};
//含内嵌子对象的多继承子类
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class D
{
public:
D(int d1)
{
cout<<"D()"<<endl;
}
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1,int d1):A(a1),C(c1),myd(d1)
{
cout<<"B()"<<endl;
}
private:
D myd;
};
int main()
{
B b(1,2,3,4);
return 0;
}
//输出：
//A()
//C()
//D()
//B()
3、继承的构造顺序
多继承的构造顺序
//多继承的构造顺序
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1):A(a1),C(c1) //C(c1),A(c1) 程序输出会有何不一样呢？ 答：参数列表顺序改变无影响
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2,3);
return 0;
}
//输出：
//A()
//C()
//B()
多内嵌子对象的构造顺序
//多内嵌子对象的构造顺序
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B
{
public:
B(int b1,int a1,int c1):MYA(a1),MYC(c1) //MYA(a1),MYC(c1)程序输出会有何不一样呢？ 答：参数列表顺序改变无影响
{
cout<<"B()"<<endl;
}
private:
C MYC;
A MYA;
};
int main()
{
B b(1,2,3);
return 0;
}
//输出：
//C()
//A()
//B()
3.1、继承类构造顺序总结
-
a、总的构造函数的调用顺序
构造顺序依次为：基类、内嵌子对象、派生类
-
b、多继承的基类的构造函数执行顺序为
class A: public b ,public c 重要：决定构造顺序
{
A():c(),c(),b() //无任何影响
{
}
}
总结： 基类的构造顺序仅与子类继承时的继承顺序有关，与构造函数的参数列表顺序无关。
该示例构造顺序依次为：b c a。
- c、多个内嵌子对象的构造函数的执行顺序为
class B
{
}
class C
{
}
class A
{
A():c1(),b1() //无任何影响
{
}
private: 重要：决定构造顺序
B b1;
C c1;
}
总结： 内嵌子对象的构造顺序仅与子类实例化对象的先后有关，与构造函数的参数列表顺序无关。
该示例构造顺序依次为：b c a。
4、无参构造函数与默认构造函数
//示例1
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A()"<<endl;
}
};
class C
{
public:
};
int main()
{
A a;
C c;
}
//输出：
//A()
//示例2：
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A()"<<endl;
}
};
class C
{
public:
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1,int d1)
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2,3,4);
return 0;
}
//输出：
//A()
//B()
4.1、无参与默认构造总结
不同点
1、默认构造函数指系统默认的隐士构造函数，不体现在用户代码中。当定义对象时它会隐士调用，内部可能不做任何操作。
2、无参构造函数指用户实现的构造函数，该函数没有参数，一旦用户定义对象时，该函数就会得到调用。
相同点
1、无参构造函数的类与默认构造函数的类定义对象时都一致,如：B b;
5、继承方式
- 三种不同的继承方式
| 继承方式 | 属性 |
|---|---|
| public | 基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类的私有成员。 |
| private | 基类的公有成员和保护成员在派生类中成了私有成员，其私有成员 仍为基类的私有成员。 |
| protected | 基类的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类的私有成员。 |
- 公有继承属性描述
| 原基类属性 | public | protected | private |
|---|---|---|---|
| 子类继承方式 | public | public | public |
| 基类成员在子类属性 | public | protected | invisible |