C语言模式实现C++继承和多态的实例代码

这个问题主要考察的是C和C++的区别，以及C++中继承和多态的概念。

C和C++的区别

C语言是面向过程的语言，而C++是面向对象的过程。

什么是面向对象和面向过程？

面向过程就是分析解决问题的步骤，然后用函数把这些步骤一步一步的进行实现，在使用的时候进行一一调用就行了，注重的是对于过程的分析。面向对象则是把构成问题的事进行分成各个对象，建立对象的目的也不仅仅是完成这一个个步骤，而是描述各个问题在解决的过程中所发生的行为。

面向对象和面向过程的区别？

• 面向过程的设计方法采用函数来描述数据的操作，但将函数与操作的数据进行分离开来。
• 面向对象的设计方法是将对象和数据进行封装起来成为一个整体。
• 面向过程以设计步骤为过程，后期难以维护。
• 面向对象设计以数据为中心，数据相对与功能来说具有较强的稳定性更加易于维护。

面向对象的三大特征

封装：

对于封装来说就是数据与具体操作实现的代码都放在某个对象的内部，使这些代码的具体细节不被外界发现，只留下一些接口供外部来使用，而不能一任何的形式来对象内部的实现。使用封装能够隐藏具体的实现的细节，使代码更加易于维护并且保证了系统的安全性。

继承：

继承机制是面向对象程序设计使代码进行复用的最重要的手段，他允许程序员在保证类原有类特性的基础上进行扩展来增加功能。这样新产生的类就被称为派生类，继承就可以表现面向对象机制的的层次结构。

多态：

多态简单点说就是“一个接口，多种实现”，就是同一种事物表现出的多种形态。多态在面向对象语言中是指：接口多种的不同实现方式。也就是复用相同接口，实现不同操作。

C++多态支持两种多态性，编译时多态和运行时多态。编译时多态是通过重载函数来实现的，运行时多态是通过虚函数来实现的。静态多态：编译器在编译期间完成，编译器根据函数实参的类型（可能会隐式类型转换），可推断出要调用哪个函数，如果有对应的函数就调用相应的函数，否则就报一个编译错误。动态多态：在函数执行期间（非编译期）判断所引用对象的实际类型，根据实际类型的调用相应的方法。使用virtual关键字修饰类的成员函数，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定。

动态多态实现的条件：

1>、使用场景：父类的指针或者引用指向父类或者子类的对象（由赋值兼容规则决定）；

2>、实现多态的两个条件：虚函数的重写；父类的指针或者引用调用重写的虚函数。

3>、若父类中的成员函数加上virtual关键字，则子类中重写的该函数默认virtual，可以不指定，但是一般加上；

重写：子类重写父类的虚函数，要求函数名称，函数参数，返回值完全一样（协变除外）；

总的来说：封装可以隐藏实现细节包括包含私有成员，使得代码模块增加安全指数；继承可以扩展已存在的模块，为了增加代码的复用性；多态则是为了保证类在继承和派生的时候，类的实例被正确调用，实现了接口的重用

C模拟实现多态

C++中的多态

我们知道的是在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。如果一个父类的指针或者引用调用父类的虚函数则该父类的指针会在自己的虚函数表中查找自己的函数地址，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。

//c++中的多态

class A
{
public:
  virtual void fun()//虚函数实现
  {
    cout << "Base A::fun() " << endl;
  }
};

class B:public A
{
public:
  virtual void fun()//虚函数实现,子类中virtual关键字可以没有
  {
    cout << "Derived B::fun() " << endl;
  }
};

void Test1()
{
  A a;//基类对象
  B b;//派生类对象

  A* pa = &a;//父类指针指向父类对象
  pa->fun();//调用父类的函数

  pa = &b; //父类指针指向子类对象，多态实现
  pa->fun();//调用派生类同名函数
}

c语言实现多态

我们知道在C语言中是没有class类这个概念的，但是有struct结构体，我们可以考虑使用struct来模拟；但是在C语言的结构体内部是没有成员函数的，如果实现这个父结构体和子结构体共有的函数呢？我们可以考虑使用函数指针来模拟。但是这样处理存在一个缺陷就是：父子各自的函数指针之间指向的不是类似C++中维护的虚函数表而是一块物理内存，如果模拟的函数过多的话就会不容易维护了。

//C实现动态，用到函数指针

typedef void(*FUN)();//重定义一个函数指针类型

//父类
struct Base
{
  FUN _f;
};

//子类
struct Derived
{
  Base _b;//在子类中定义一个基类的对象即可实现对父类的继承
};

void FunB()
{
  printf("%s\n", "Base::fun()");
}
void FunD()
{
  printf("%s\n", "Derived::fun()");
}

void Test2()
{
  Base b;//父类对象
  Derived d;//子类对象

  b._f = FunB;//父类对象调用父类同名函数
  d._b._f = FunD;//子类调用子类的同名函数

  Base *pb = &b;//父类指针指向父类对象
  pb->_f();

  pb = (Base *)&d;//让父类指针指向子类的对象,由于类型不匹配所以要进行强转
  pb->_f();

}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。