清华大学c++程序设计（第七单元随堂笔记）

C++语言程序设计（第七单元随堂笔记）

类的继承，是新的类从已有的类哪里得到的已有的特性，从已有的类里面产生新的类的过程叫做类的派生。原有的类称为基类或者父类，产生的新类称为派生类和子类。

派生类的定义

在c++中派生类的一般定义语法为：

class 派生类名：继承方式 基类名1，继承方式 基类名2，继承方式
{派生类成员声明;
}例：
class Derived:public Basel,private Basel2
{public:Derived();~Derived();
}

派生类成员是指除了从基类继承来的所有成员，新增的数据和函数成员。

如果派生类声明了一个和某基类成员同名的新成员（如果是成员函数，则参数表也要相同，参数不同的情况属于重载），原派生的新成员就隐藏了外层同名成员。

访问控制权限

公有继承

当类的继承方式为公有继承时，基类的公有成员和保护成员的访问属性在派生类中不变，而基类的私有成员不可以直接访问。

#include<iostream>
#include<math.h>
using namespace std;
class Point {
public:int getx() { return this->x; }int gety() { return this->y; }int line2(int x, int y) { this->x=x, this->y=y; cout << "line函数被调用"; return 0; };private:int x, y;
};
class line :public Point {
public:line(int x3, int y3) :x1(x3), y1(y3){}int line1(int x, int y, int x1, int y1) {line2(x, y);l = sqrt(static_cast<double>(x)*static_cast<double>(x) + static_cast<double>(y)*static_cast<double>(y));return l;}
private:int x1;int y1;int l;
};
int main() {line l1(1,2);cout<<l1.line1(1, 2, 3, 4)<<endl;cout << l1.getx() << "   " << l1.gety();}

私有继承

当类的继承方式为私有继承时，基类中的公有成员和保护成员都已私有成员身份出现在派生类中，而基类总共的私有成员在派生类中不可以直接访问。

#include<iostream>
#include<math.h>
using namespace std;
class Point {
public:int getx() { return this->x; }int gety() { return this->y; }int line2(int x, int y) { this->x=x, this->y=y; cout << "line函数被调用"; return 0; };private:int x, y;
};
class line :private Point {
public:line(int x3, int y3){this->x1 = x3;this->y1 = y3;}int line1(int x, int y, int x1, int y1) {line2(x, y);l = sqrt(static_cast<double>(x)*static_cast<double>(x) + static_cast<double>(y)*static_cast<double>(y));return l;}
private:int x1;int y1;int l;
};
int main() {line l1(1,2);cout<<l1.line1(1, 2, 3, 4)<<endl;cout << l1.getx() << "   " << l1.gety();  //报错getx和gety是私有函数成员不能访问}

修改：公有里面添加上这两个函数即可

	int getx() {return Point::getx();}int gety() {return Point::gety();}

保护继承

保护继承中，基类的共有成员和保护成员的身份出现在派生类中，而基类的私有成员不可直接访问。

类型兼容规则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。

兼容规则中所指的替代包括下列情况：

派生类的对象可以隐含转为基类对象

派生类的对象可以初始化基类的引用

派生类的指针可以隐含转化为基类的指针

在替代之后，派生类就可以作为基类的对象使用，但只能使用从基类继承的成员。

Point p1=l1;
Point *p1 = &l1;  //p1的指针
Point &p2 = l1;    //这是引用
p2.getx();
p1->getx();

引用小补充：

这里转载了一个很好的博客

1、什么是引用？引用是给一个已经定义的的变量取别名，而不是定义一个新的变量。引用定义格式：类型& 引用变量名 = 已定义变量2、引用的特点有哪些？1) 多个变量可以引用一个变量int a = 10;
int& b = a;
int& c = a;
cout<<a<<" "<<b<<" "<<c<<endl; // 10 10 10
2) 引用必须初始化int& a; // 语法错误
3) 引用只能在初始化的时候引用一次，不能在改变为引用其他的变量4) 常量不能被引用int& a = 10; // 语法错误const int& a = 10; // 正确，常量具有常性，只有常引用可以引用常量
cout<<a<<endl; // 10
3、引用和const#include <iostream>
using namespace std;int main()
{int a1 = 10;cout<<a1<<endl; // 10const int& a2 = a1;cout<<a1<<" "<<a2<<endl; //10 10a1 = 5;cout<<a1<<" "<<a2<<endl; //10 10  ai的值改变，a2的值也会改变const int a3 = 10;const int& a4 = a3;//int& a5 = a3; // 报错const int& a6 = 5; // 常量具有常性，只有常引用可以引用常量float a7 = 10.10;//int& a8 = a7; // 报错，a7是float类型，a8是int型，a7给a8赋值会产生一个临时变量，// 即a7引用的是这个带有常性的临时变量，所以不能赋值const int& a9 = a7;return 0;
}
4、引用和指针引用是变量别名，指针保存变量的地址，二者其实有异曲同工之妙，都是直接指向对象的内存块，但是引用和指针还是有诸多不同。例如a) 引用必须初始化；指针可以不初始化b) 引用只能在定义时初始化一次，之后不能改变指向其他变量；指针指向的对象可以改变c) 引用不能为空，必须指向有效对象；指针可以为空d) sizeof指针和引用的含义不同。sizeof引用对象得到的是引用所指对象的大小；sizeof指针变量得到的是对象地址大小e) 引用和指针自增自减意义不同f) 引用比指针安全5、使用引用时的注意事项a) 不要返回一个临时变量的引用b) 不要返回函数内部new分配的内存的引用

派生类的构造和析构函数

构造函数

构造派生类的对象时，需要对基类的成员对象和新增成员对象进行初始化。

如果对基类初始化时候，需要调用基类的带有形参的构造函数时，派生类必须声明构造函数。

调用派生类的构造函数的一般顺序：
1.调用基类构造函数，调用顺序按照他们被继承时声明的顺序

2.对派生类新增对象初始化，初始化顺序按照他们在类中声明的顺序

3.执行派生类的构造函数体的内容

派生类构造函数举例

#include<iostream>
using namespace std;
class Base1 {
public:Base1(int x) { cout << "Base1已经被建立" << endl; }
};
class Base2 {
public:Base2(int x) { cout << "Base2已经被建立" << endl; }
};
class Base3 {
public:Base3(int x) {cout << "Base2已经被建立" << endl;}
};
class Deriverd :public Base1, public Base2, public Base3 {
public:Deriverd(int a, int b, int c) :Base1(a),member1(a), Base2(b),member2(b),Base3(c),member3(c) {cout << "Deriverd类已经被建立";}
private:Base1 member1;Base2 member2;Base3 member3;
};
int main() {Deriverd obj( 2, 3, 4);
}

删除delete构造函数

基类删除的delete构造函数或者复制构造函数或者是移动构造函数，都会使派生类的复制移动构造函数失效。

派生类成员的标识与访问

作用域的分辨符（：：）:

作用域分辨符就是我们经常见到的”::“，它可以用来限制访问的成员所在的类的名称，一般使用形式为：

类名：：成员名 //数据成员

类名::成员名(参数表) //数据成员

如果派生类中声明了与基类成员相同的新函数，即使函数的参数表不同，从基类继承的同名函数的所有重载形式也会被隐藏。

如果某派生类的多个基类拥有相同的成员，同时，派生类有新增这样的同名成员，在这种情况下，派生类成员将隐藏的所有基类的同名成员。

如果希望不产生不二义型，可以使用using关键字加以澄清

class Derived:public Base1,public Base2{public:using Base1::var;using Base2::fun;//这样即使有同名的函数也会被当成多态使用
}

虚基类

解决多重多级继承造成的二义性问题。例如有基类B，从B派生出C和D，然后类F又同时继承了C和D，现在类F的一个对象里面包含了两个基类B的对象，如果F访问自己的从基类B那里继承过来的的数据成员或者函数成员那么编译器就不知道你指的到底是从C那里继承过来的B对象呢还是从D那里继承过来的B对象。

于是虚基类诞生了，将C和D的继承方式改为虚继承，那么F访问自己从B那里继承过来的成员就不会有二义性问题了，也就是将F对象里的B对象统一为一个，只有一个基类B对象，下面是一段代码说明了对虚基类的使用。

#include <iostream>using namespace std;class A
{public:int i;void showa(){cout<<"i="<<i<<endl;}
};class B:virtual public A      //此处采用虚继承
{public:int j;
};class C:virtual public A      //此处采用虚继承
{public:int k;
};class D:public B,public C
{public:int m;
};
int main()
{A a;B b;C c;a.i=1;a.showa();b.i=2;b.showa();c.i=3;c.showa();D d;d.i=4;d.showa();//cout << "Hello world!" << endl;return 0;
}