1. 继承与派生
代码：
Father.h
#pragma once
#include <string>
using namespace std;
class Father
{
public:
Father(const char*name, int age);
~Father();
string getName();
int getAge();
string description();
private:
int age;
string name;
};
Son.h
#pragma once
#include "Father.h"
class Son : public Father {
public:
Son(const char *name, int age, const char *game);
~Son();
string getGame();
string description();
private:
string game;
};
Father.cpp
#include "Father.h"
#include <sstream>
#include <iostream>
Father::Father(const char*name, int age)
{
cout << __FUNCTION__ << endl;
this->name = name;
this->age = age;
}
Father::~Father()
{
}
string Father::getName() {
return name;
}
int Father::getAge() {
return age;
}
string Father::description() {
stringstream ret;
ret << "name:" << name << " age:" << age;
return ret.str();
}
Son.cpp
#include "Son.h"
#include <iostream>
#include <sstream>
// 创建Son对象时, 会调用构造函数!
// 会先调用父类的构造函数, 用来初始化从父类继承的数据
// 再调用自己的构造函数, 用来初始化自己定义的数据
Son::Son(const char *name, int age, const char *game) : Father(name, age) {
cout << __FUNCTION__ << endl;
// 没有体现父类的构造函数, 那就会自动调用父类的默认构造函数!!!
this->game = game;
}
Son::~Son() {
}
string Son::getGame() {
return game;
}
string Son::description() {
stringstream ret;
// 子类的成员函数中, 不能访问从父类继承的private成员
ret << "name:" << getName() << " age:" << getAge()
<< " game:" << game;
return ret.str();
}
main.cpp
#include <iostream>
#include "Father.h"
#include "Son.h"
int main(void) {
Father wjl("王健林", 68);
Son wsc("王思聪", 32, "电竞");
cout << wjl.description() << endl;
// 子类对象调用方法时, 先在自己定义的方法中去寻找, 如果有, 就调用自己定义的方法
// 如果找不到, 就到父类的方法中去找, 如果有, 就调用父类的这个同名方法
// 如果还是找不到, 就是发生错误!
cout << wsc.description() << endl;
system("pause");
return 0;
}
子类, 一般会添加自己的数据成员/成员函数,
或者, 重新定义从父类继承的方法!!! 子类对象就会调用自己重新定义的方法, 不会调用父类的同名方法
protected（保护）访问权限
为什么要使用protected访问权限？
子类的成员函数中，不能直接访问父类的private成员，已经这些成员已经被继承下来了，但是却不能访问。
只有通过父类的public函数来间接访问，不是很方便。
比如，刚才Demo中Father类中的name和age成员。
解决方案：
把name和age定义为protected访问访问权限。
效果：
Son类的成员函数中，可以直接访问它的父类的protected成员。
但是在外部，别人又不能直接通过Son对象来访问这些成员。
一个类, 如果希望, 它的成员, 可以被自己的子类(派生类)直接访问,
但是, 又不想被外部访问那么就可以把这些成员, 定义为 protected访问权限!!!
访问权限总结:
public
外部可以直接访问.
可以通过对象来访问这个成员
Fahter wjl(“王健林”, 65);
wjl.getName();
private
外部不可以访问
自己的成员函数内, 可以访问
Fahter wjl(“王健林”, 65);
wjl.name; // 错误!!!
Father内的所有成员函数内, 可以直接访问name
protected
protected和private非常相似
和private的唯一区别:
protecte: 子类的成员函数中可以直接访问
private: 子类的成员函数中不可以访问
派生和继承的各种方式
public（公有）继承 [使用最频繁]
父类中定义的成员（数据成员和函数成员）被继承后，访问权限不变！
public --> public
protected --> protected
private --> private
private（私有）继承
父类中定义的成员（数据成员和函数成员）被继承后，访问权限都变成private
public --> private
protected --> private
private --> private
protected（保护）继承
public --> protected
protected --> protected
private --> private
小结：
public 继承全不变
private继承全变私
protected继承只把public降级为protected
什么时候使用继承和派生
1）准备实现多个类，但是这些类在现实世界中有某种特殊关系（比如：类别与子类别的关系）
例如：人 女人 男人
如果完全独立的实现这3个类，将有很多重复代码，而且不利于以后的维护。
2）准备构建一个类，但是这个类与已经开发好的某个类非常相似，而且在现实世界中具有某种特殊关系（比如：类别与子类别的关系）。
如果全部重新写这个新类，效率较低，因为有很多东西已经在这个已有的类中实现了。
实例：某卫星监控平台的ODU和ODU232
ODU
class ODU232 : public ODU
3）对多个已经实现的类（这些类有某种特殊关系），进行重构。
一般在前两种情况使用，第3种（重构）是不得而为之。
子类对父类成员的访问权限
无论通过什么方式（public、protected、private）继承，
在子类内部均可访问父类中的public、protected成员，
private成员不可访问（如果想要子类能够访问，就定义为protected）
继承方式只影响外界通过子类对父类成员的访问权限。
public继承，父类成员的访问权限全部保留至子类；
protected继承，父类public成员的访问权限在子类中降至protected；
private继承，父类public、protected成员的访问权限在子类中均降至private。
实例测试：
通过修改Son类的继承方式，观察变化。
子类的构造函数
子类和父类的构造函数的调用顺序
当创建子类对象时, 构造函数的调用顺序：
静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数
注意:
无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!
执行顺序：
1.静态数据成员的构造函数
2.父类的构造函数
3.非静态数据成员的构造函数
4.非静态数据成员的构造函数
5.自己的构造函数
子类的析构函数
子类的析构函数的调用顺序，和子类的构造函数的调用顺序相反！！！
记住，相反即可。
第6节子类型关系
公有继承时，派生类的对象可以作为基类的对象处理，派生类是基类的子类型。
#include <iostream>
using namespace std;
class A {
public:
A() {}
~A() {}
void kill() { cout << "A kill." << endl; }
};
class B : public A {
public:
B(){}
~B(){}
void kill() { cout << "B kill." << endl; }
};
void test(A a) {
a.kill(); //调用的是A类对象的kill方法
}
int main(void) {
A a;
B b;
test(a);
test(b);
system("pause");
return 0;
}
子类型关系具有单向传递性。
C类是B类的子类型
B类是A类的子类型
子类型的作用：
在需要父类对象的任何地方， 可以使用”公有派生”的子类的对象来替代，
从而可以使用相同的函数统一处理基类对象和公有派生类对象
即：形参为基类对象时，实参可以是派生类对象
#include <iostream>
#include <sstream>
using namespace std;
class Father {
public:
void play() {
cout << "KTV唱歌！" << endl;
}
};
class Son : public Father {
public:
void play() {
cout << "今晚吃鸡！" << endl;
}
};
void party(Father *f1, Father *f2) {
f1->play();
f2->play();
}
int main(void) {
Father yangKang;
Son yangGuo;
party(&yangKang, &yangGuo);
system("pause");
return 0;
}
子类型的应用
1.基类（父类）的指针，可以指向这个类的公有派生类（子类型）对象。
Son yangGuo;
Father * f = &yangGuo;
2.公有派生类（子类型）的对象可以初始化基类的引用
Son yangGuo;
Father &f2 = yangGuo;
3.公有派生类的对象可以赋值给基类的对象
Son yangGuo;
Father f1 = yangGuo;
注意：以上的应用，反过来就会编译失败！
什么是多重继承
多继承/多重继承:
一个派生类可以有两个或多个基类(父类)。
多重继承在中小型项目中较少使用，在Java、C#等语言中直接取消多继承, 以避免复杂性.
实例:
例如已声明了类A、类B和类C，那么可以这样来声明派生类D：
class D: public A, private B, protected C{
//类D自己新增加的成员
};
D 是多继承形式的派生类，
D 有3个父类(基类)
它以公有的方式继承 A 类，
以私有的方式继承 B 类，
以保护的方式继承 C 类。
D 根据不同的继承方式获取 A、B、C 中的成员.
多继承的构造函数
多继承形式下的构造函数和单继承形式基本相同.
D(形参列表): A(实参列表), B(实参列表), C(实参列表){
//其他操作
}
多继承的构造函数的调用顺序
基类构造函数的调用顺序和和它们在派生类构造函数中出现的顺序无关，
而是和声明派生类时基类出现的顺序相同。
多重继承在”菱形继承”中的重大缺点
源码：
#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
// 电话类
class Tel {
public:
Tel() {
this->number = "未知";
}
protected:
string number; //电话号码;
};
// 座机类
class FixedLine : public Tel {
};
// 手机类
class MobilePhone :public Tel {
};
// 无线座机
class WirelessTel :public FixedLine, public MobilePhone {
public:
void setNumber(const char *number) {
//this->number = number; //错误, 指定不明确
this->FixedLine::number = number; //this可以省略
}
string getNumber() {
//return MobilePhone::number;
return MobilePhone::number;
}
};
int main(void) {
WirelessTel phone;
phone.setNumber("13243879166");
cout << phone.getNumber() << endl; //打印未知
system("pause");
return 0;
}
使用虚基类，和虚继承
#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
// 电话类
class Tel { //虚基类
public:
Tel() {
this->number = "未知";
}
protected:
string number; //电话号码;
};
// 座机类
class FixedLine : virtual public Tel { //虚继承
};
// 手机类
class MobilePhone : virtual public Tel { //虚继承
};
// 无线座机
class WirelessTel :public FixedLine, public MobilePhone {
public:
void setNumber(const char *number) {
this->number = number; //直接访问number
}
string getNumber() {
return this->number; //直接访问number
}
};
int main(void) {
WirelessTel phone;
phone.setNumber("13243879166");
cout << phone.getNumber() << endl;
system("pause");
return 0;
}
这个被共享的基类(Tel)就称为虚基类（Virtual Base Class）
常见错误总结
默认访问权限和语法要求
默认访问权限是private
访问权限之后一定要加冒号:
指定为某种访问权限之后, 就一直是这种权限, 除非再次指定为其他权限.
类的成员的访问权限, 与继承方式的区别
相同点：都有public, private, protected
不同点：意义完全不同。
小结：
成员的访问权限：
public, 可以通过外部来访问（通过对象直接访问）, 类似于C语言结构体中的成员
private, 只能在内部访问（在这个类的成员函数内访问），但是在子类的内部不能直接访问。
protected, 只能在内部访问，而且可以在子类的内部直接访问。
继承方式：
public, 父类成员， 被继承到子类后，访问权限都不变。
private, 父类成员， 被继承到子类后，访问权限都变为private
protected, 父类成员， 被继承到子类后，public权限的成员，降级为protected, 其他不变。
速度之巅-位图算法
#include <stdio.h>
#include <Windows.h>
void init(char *data, int len) {
// 根据实际需求来实现.
// 这里只是为了测试后面的算法效果, 假设:
// 能够被3整数的数, 都在这个集合中.[假设的需求]
unsigned int n = len * 8; //一共有n个数据
for (unsigned int i = 0; i < n; i++) {
// 假设: 能够被3整数的数, 都在这个集合中.[假设的需求]
if (i % 3 == 0) {
//计算这个位对应哪个字节
char *p = data + i / 8;
*p = *p | (1 << (i % 8));
}
}
}
// 位图算法
bool check(char *data, int len, int value) {
// 定位到指定的字节
char *p = data + value / 8;
// 判断这个字节中指定的位是否为1
bool ret = *p & (1 << (value % 8));
return ret;
}
int main(void) {
// 很配一块足够的内存, 用来表示位图
unsigned int n = 4000000000;
int len = n / 8 + 1;
char *data = (char*)malloc(len);
memset(data, 0, len); //清零
// 装载数据集合(只需要装载一次)
init(data, len);
while (1) {
printf("请输入要检测的数: [输入-1退出] ");
int value;
scanf_s("%d", &value);
if (value == -1) {
break;
}
if (check(data, len, value)) {
printf("%d在数据集合中\n", value);
}
else {
printf("%d不在数据集合中\n", value);
}
}
system("pause");
return 0;
}
Over!!