继承和多态
一、继承
子类可以访问基类的public和protected
基类的private只有自己和友元才能访问（友元会破坏类的封装性）
class A
{
public:
int ma;
protected:
int mb;
private:
int mc; // 自己或者友元能访问私有的成员
};
//继承 A 基类/父类 B 派生类/子类
struct B : A
{
public:
void func()
{
cout << ma << endl;
}
int md;
protected:
int me;
private:
int mf;
// int ma;
};
class C : public B
{
// 在C里面，请问ma的访问限定是什么？ 不可见的，但是能继承来
};
int main()
{
B b;
//cout << b.mb << endl;
return 0;
}
派生类构造过程
除构造函数和析构函数，派生类从基类可以继承来所有的成员(变量和方法)
派生类通过调用基类的构造函数来初始化从基类继承来的成员变量
派生类对象构造和析构的过程：
1.派生类调用基类构造，初始化从基类继承来的成员
2.调用派生类自己的构造，初始化派生类自己特有的成员
派生类对象的作用域到期了
1.调用派生类析构，释放派生类成员可能占用的外部资源（堆内存，文件）
2.调用基类析构，释放派生类内存中，从基类继承来的成员可能占用的外部资源（堆内存，文件）
例1：
class Base
{
public:
Base(int data) : ma(data) { cout << "Base()" << endl; }
~Base() { cout << "~Base()" << endl; }
protected:
int ma;
};
class Derive : public Base
{
public:
// “Base”: 没有合适的默认构造函数可用
Derive(int data) : Base(data), mb(data) // ma(data)
{
cout << "Base protected member:" << ma << endl;
cout << "Derive()" << endl;
}
~Derive()
{
cout << "~Derive()" << endl;
}
private:
int mb;
};
int main()
{
Derive d(20);
return 0;
}
例2
#ifndef _ROBOT_TCP_H_
#define _ROBOT_TCP_H_
#include <iostream>
class Robot_tcp_cilent
{
public:
Robot_tcp_cilent(const char* IP, int hont);
~Robot_tcp_cilent();
private:
};
#endif
class Client: public Robot_tcp_cilent
{
private:
ros::NodeHandle nh;
ros::Subscriber subDog_arrived;
public:
Client() : Robot_tcp_cilent("127.0.0.1", 5178)
{
subDog_arrived = nh.subscribe<std_msgs::Int8> ("/dog_arrivedsignal", 5, &Client::dogarrivedHandler, this, ros::TransportHints().tcpNoDelay());
}
~Client(){};
void dogarrivedHandler(const std_msgs::Int8::ConstPtr& arrived)
{
dogarrivedflag = arrived->data;
// 狗到达目标点标志位
}
}
二、多态
重载、隐藏、覆盖
1.重载
一组函数要重载，必须处在同一个作用域当中；而且函数名字相同，参数列表不同
2.隐藏(作用域的隐藏)
在继承结构当中，派生类的同名成员，把基类的同名成员给隐藏调用了（无论参数是否相同）。如果在派生类中想要访问基类的同名函数，可以使用作用域解析运算符(::)来显式调用。
3.覆盖
覆盖是指在派生类中重新定义一个与基类中同名的成员函数，使其具有相同的函数签名（返回类型、函数名和参数列表）。
通过覆盖，派生类可以改变基类成员函数的实现，但保持相同的函数接口。在使用基类指针或引用调用成员函数时，如果派生类中有与基类同名的函数，将会调用派生类中的函数，而不是基类中的函数。这实现了运行时多态性，允许通过基类指针或引用来调用派生类中特定的函数。
以上是实现多态性和灵活性的重要机制。重载提供了处理不同参数的能力，隐藏允许在派生类中屏蔽基类的同名函数，而覆盖允许在派生类中重新定义和改变基类成员函数的行为。
class Base
{
public:
Base(int data = 10) :ma(data) {}
void show() { cout << "Base::show()" << endl; } //#1
void show(int) { cout << "Base::show(int)" << endl; }//#2
protected:
int ma;
};
class Derive : public Base
{
public:
Derive(int data = 20) :Base(data), mb(data) {}
void show() { cout << "Derive::show()" << endl; } //#3
private:
int mb;
};
int main()
{
Base b(10);
Derive d(20);
// 基类对象b <- 派生类对象d 类型从下到上的转换 Y
b = d;
// 派生类对象d <- 基类对象b 类型从上到下的转换 N
// d = b;
// 基类指针（引用）<- 派生类对象 类型从下到上的转换 Y
Base *pb = &d;
pb->show();
//((Derive*)pb)->show();
pb->show(10);
// 派生类指针（引用）<- 基类对象 类型从上到下的转换 N
Derive *pd = (Derive*)&b; // 不安全，涉及了内存的非法访问！
pd->show();
#if 0
Derive d;
d.show();
d.Base::show();
//“Derive::show”: 函数不接受 1 个参数
d.Base::show(10);
d.show(20);//优先找的是派生类自己作用域的show名字成员；没有的话，才去基类里面找
#endif
return 0;
}
虚函数、静态绑定、动态绑定
本质为覆盖：
基类和派生类的方法，返回值、函数名以及参数列表都相同，而且基类的方法是虚函数，那么派生类的方法就自动处理成虚函数，它们之间成为覆盖关系。
一个类添加了虚函数，对这个类有什么影响？
总结一：
一个类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生一个唯一的vftable虚函数表，虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚函数表都会加载到内存的.rodata区。
总结二：
一个类里面定义了函数数，那么这个类定义的对象，其运行时，内存中开始部分，多存储一个vfptr虚函数指针，指向相应类型的虚函数表vftable。一个类型定义的n个对象，它们的额vfptr指向的都是同一张虚函数表。
总结三：
一个类里面虚函数的个数，不影响对象内存大小（vfptr），影响的是虚函数表的大小。
虚函数
问题一：哪些函数不能实现成虚函数？
虚函数依赖：
1.虚函数能产生地址，存储在vftable当中
2.对象必须存在(vfptr -> vftable -> 虚函数地址)
所以，以下函数不能为虚
- virtual + 构造函数 NO！
构造函数中（调用的任何函数，都是静态绑定的）调用虚函数，也不会发生静态绑定。
（派生类对象构造过程 1.先调用的是基类的构造函数 2.才调用派生类的构造函数） - virtual + incline NO！
- virtual + static NO！
静态成员函数属于类本身，而不是类的实例。
问题二：虚析构函数调用的时候，对象是存在的！所以基类析构函数必须实现成虚函数。
原因：如果将基类的析构函数不声明为虚函数，那么在删除派生类对象时，只会调用基类的析构函数，而派生类的析构函数将不会被调用。这将导致派生类的资源无法得到正确释放。
class Base
{
public:
Base(int data) :ma(data) { cout << "Base()" << endl; }
// 虚析构函数
virtual ~Base() { cout << "~Base()" << endl; }
virtual void show() { cout << "call Base::show()" << endl; }
protected:
int ma;
}; // &Base::~Base &Base::show
class Derive : public Base // &Derive::~Derive &Base::show
{
public:
Derive(int data)
:Base(data), mb(data), ptr(new int(data))
{
cout << "Derive()" << endl;
}
// 基类的析构函数是virtual虚函数，那么派生类的析构函数自动成为虚函数
~Derive()
{
delete ptr;
cout << "~Derive()" << endl;
}
private:
int mb;
int *ptr;
};
int main()
{
Base *pb = new Derive(10);
pb->show(); // 动态绑定 pb Base* *pb Derive
delete pb; // 基类析构为虚，才能正确调用派生类的析构
/*输出
~Derive()
~Base()*/
/*
pb->Base Base::~Base 对于析构函数的调用，就是静态绑定了
call Base::~Base
pb->Base Base::~Base 对于析构函数的调用，就是动态绑定了
pb -> Derive Derive vftable &Derive::~Derive
*/
Derive d(10);
Base *pb = &d;
pb->show();
return 0;
}
问题3：纯虚析构函数
纯虚析构函数需要在类的定义外部提供纯虚析构函数的实现，如示例中的Base::~Base()所示。
class Base {
public:
virtual ~Base() = 0; // 纯虚析构函数
};
Base::~Base() {
cout << "~Base()" << endl;
}
class Derived : public Base {
public:
~Derived() {
cout << "~Derive()" << endl;
}
};
int main() {
// Base* ptr = new Base(); // 错误，无法实例化抽象类
Base* ptr = new Derived(); // 可以使用派生类指针来指向派生类对象
delete ptr; // 调用Derived的析构函数
return 0;
}
输出：
~Derive()
~Base()
问题4：指针调用方式Derived* ptr = new Derived();和Base* ptr = new Derived();虽然语法上相似，但它们有一些不同的效果。
静态类型和动态类型：
在Derived* ptr = new Derived();中，ptr的静态类型和动态类型都是Derived*。这意味着编译器将ptr视为指向Derived类对象的指针，可以直接访问Derived类的成员和函数。
在Base* ptr = new Derived();中，ptr的静态类型是Base*，而动态类型是Derived*。这意味着编译器将ptr视为指向Base类对象的指针，但实际上它指向的是派生类Derived的对象。这种情况下，通过ptr只能访问到基类Base中定义的成员和函数，无法直接访问派生类Derived中特有的成员和函数。
多态性：
在Derived* ptr = new Derived();中，由于ptr的静态类型和动态类型相同，可以实现动态绑定（dynamic binding）和多态性。当使用虚函数时，可以根据实际对象的类型来调用相应的函数实现。
在Base* ptr = new Derived();中，由于ptr的静态类型是Base*，虽然它指向派生类Derived的对象，但在通过ptr调用虚函数时，只能根据静态类型的信息来进行绑定，而不考虑实际对象的类型。这称为静态绑定（static binding），无法实现多态性。
总结起来，Derived* ptr = new Derived();和Base* ptr = new Derived();在语法上相似，但它们的静态类型、动态类型和多态性方面有所不同。使用Derived可以访问派生类特有的成员和函数，并支持动态绑定和多态性。而使用Base只能访问基类的成员和函数，并且静态绑定导致无法实现多态性。选择使用哪种方式取决于具体的需求和设计目标。
动态绑定、静态绑定
复习多态的不同形式
1 静态多态：
是指在编译期间就可以确定函数的调用地址，并生产代码，这就是静态的，也就是说地址是早早绑定的。
静态多态往往通过函数重载（运算符重载）和模版（泛型编程）来实现。
2 动态多态
指函数调用的地址不能在编译器期间确定，必须需要在运行时才确定，这就属于晚绑定，动态多态也往往被叫做动态绑定。
动态绑定
当使用基类的引用或指针调用虚成员函数时会执行动态绑定。动态绑定直到运行的时候才知道到底调用哪个版本的虚函数，所以必为每一个虚函数都提供定义，而不管它是否被用到，这是因为连编译器都无法确定到底会使用哪个虚函数。被调用的函数是与绑定到指针或引用上的对象的动态类型相匹配的那一个。
问题：那是不是虚函数的调用一定就是动态绑定？ 肯定不是的！
1、在类的构造函数当中，调用虚函数，静态绑定（构造函数中调用其它函数（虚），不会发生动态绑定）。
2、不是通过指针或者引用变量来调用虚函数，也是静态绑定。
class Base
{
public:
Base(int data = 0) :ma(data) {}
virtual void show() { cout << "Base::show()" << endl; }
protected:
int ma;
};
class Derive : public Base
{
public:
Derive(int data = 0) :Base(data), mb(data) {}
void show() { cout << "Derive::show()" << endl; }
private:
int mb;
};
int main()
{
Base b;
Derive d;
// 静态绑定 用对象本身调用虚函数，是静态绑定
b.show(); // 虚函数 call Base::show
d.show(); // 虚函数 call Derive::show
// 动态绑定（必须由指针调用虚函数）
Base *pb1 = &b;
pb1->show();
Base *pb2 = &d;
pb2->show();
// 动态绑定（必须由引用变量调用虚函数）
Base &rb1 = b;
rb1.show();
Base &rb2 = d;
rb2.show();
// 动态绑定（虚函数通过指针或者引用变量调用，才发生动态绑定）
Derive *pd1 = &d;
pd1->show();
Derive &rd1 = d;
rd1.show();
Derive *pd2 = (Derive*)&b;
pd2->show(); // 动态绑定 pd2 -> b vfptr -> Base vftable Base::show
return 0;
}
多态总结
静态（编译时期）的多态： 函数重载、模板（函数模板和类模板）
动态（运行时期）的多态： Base Derive
在继承结构中，基类指针（引用）指向派生类对象，通过该指针（引用）调用同名覆盖方法（虚函数），基类指针指向哪个派生类对象，就会调用哪个派生类对象的同名覆盖方法，称为动态多态。
多态底层是通过动态绑定来实现的，pbase-》访问谁的vfptr=》继续访问谁的vftable =》当然调用的是对应的派生类对象的方法了
继承、多态的好处是什么？
1.可以做代码的复用
2.在基类中给所有派生类提供统一的虚函数接口，让派生类进行重写，然后就可以使用多态了
实例
抽象类Animal文章来源：https://www.toymoban.com/news/detail-470568.html
// 动物的基类
class Animal
{
public:
Animal(string name) :_name(name) {}
virtual void bark() {}
protected:
string _name;
};
// 以下是动物实体类
class Cat : public Animal
{
public:
Cat(string name) :Animal(name) {}
void bark() { cout << _name << " bark: miao miao!" << endl; }
};
class Dog : public Animal
{
public:
Dog(string name) :Animal(name) {}
void bark() { cout << _name << " bark: wang wang!" << endl; }
};
class Pig : public Animal
{
public:
Pig(string name) :Animal(name) {}
void bark() { cout << _name << " bark: heng heng!" << endl; }
};
/*
下面的一组bark API接口无法做到我们软件涉及要求的“开-闭“原则
软件设计由六大原则 “开-闭“原则 对修改关闭，对扩展开放
*/
void bark(Animal *p)
{
p->bark(); // Animal::bark虚函数，动态绑定了
/*
p->cat Cat vftable &Cat::bark
p->dog Dog vftable &Dog::bark
p->pig Pig vftable &Pig::bark
*/
}
int main()
{
Cat cat("猫咪");
Dog dog("二哈");
Pig pig("佩奇");
bark(&cat);
bark(&dog);
bark(&pig);
return 0;
}
抽象类Car文章来源地址https://www.toymoban.com/news/detail-470568.html
// 汽车的基类
class Car // 抽象类
{
public:
Car(string name, double oil) :_name(name), _oil(oil) {}
// 获取汽车剩余油量还能跑的公里数
double getLeftMiles()
{
// 1L 10 * oil
return _oil * this->getMilesPerGallon(); // 发生动态绑定了
}
string getName()const { return _name; }
protected:
string _name;
double _oil;
virtual double getMilesPerGallon() = 0; // 纯虚函数
};
class Bnze : public Car
{
public:
Bnze(string name, double oil) :Car(name, oil) {}
double getMilesPerGallon() { return 20.0; }
};
class Audi : public Car
{
public:
Audi(string name, double oil) :Car(name, oil) {}
double getMilesPerGallon() { return 18.0; }
};
class BMW : public Car
{
public:
BMW(string name, double oil) :Car(name, oil) {}
double getMilesPerGallon() { return 19.0; }
};
//给外部提供一个同一的获取汽车剩余路程数的API
void showCarLeftMiles(Car &car)
{
cout<<car.getName() << " left miles:"
<< car.getLeftMiles() << "公里" <<endl;
// 静态绑定 call Car::getLeftMiles()
}
int main()
{
Bnze b1("奔驰", 20.0);
Audi a("奥迪", 20.0);
BMW b2("宝马", 20.0);
showCarLeftMiles(b1);
showCarLeftMiles(a);
showCarLeftMiles(b2);
return 0;
}
到了这里，关于C++基础（一） —— 面向对象（2）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
