C语言实现多态

原创 于 2025-10-20 20:59:11 发布 · 954 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #开发语言

C 语言实现 OOP 多态的核心就是：

  1. 在基类中定义函数指针（虚函数表）
  2. 在构造函数中绑定具体实现
  3. 通过基类指针实现多态调用

看代码示例：

#include <stdio.h>
#include <stdlib.h>

// 1. 定义“基类” Shape
// ------------------------------------
struct Shape; // 前向声明

// 定义“虚函数”指针类型
typedef void (*FuncDraw)(struct Shape*);
typedef double (*FuncArea)(struct Shape*);

// Shape 结构体，模拟“基类”
typedef struct Shape {
    int x;
    int y;
    FuncDraw draw;
    FuncArea area;
} Shape;

// 2. 定义“派生类” Circle 和 Rectangle
// ------------------------------------
// Circle 结构体，模拟“派生类”
typedef struct {
    Shape base; // 继承！将基类作为第一个成员
    int radius;
} Circle;

// Rectangle 结构体，模拟“派生类”
typedef struct {
    Shape base; // 继承！
    int width;
    int height;
} Rectangle;


// 3. 实现具体的“方法”
// ------------------------------------
void draw_circle(Shape* s) {
    Circle* c = (Circle*)s; // 向下转型
    printf("Drawing a circle at (%d, %d) with radius %d\n", c->base.x, c->base.y, c->radius);
}

double area_circle(Shape* s) {
    Circle* c = (Circle*)s;
    return 3.14159 * c->radius * c->radius;
}

void draw_rectangle(Shape* s) {
    Rectangle* r = (Rectangle*)s;
    printf("Drawing a rectangle at (%d, %d) with size %dx%d\n", r->base.x, r->base.y, r->width, r->height);
}

double area_rectangle(Shape* s) {
    Rectangle* r = (Rectangle*)s;
    return (double)(r->width * r->height);
}

// 4. 实现“构造函数”
// ------------------------------------
Circle* create_circle(int x, int y, int radius) {
    Circle* c = (Circle*)malloc(sizeof(Circle));
    c->base.x = x;
    c->base.y = y;
    // 将函数指针指向具体的实现！这是多态的关键
    c->base.draw = draw_circle;
    c->base.area = area_circle;
    c->radius = radius;
    return c;
}

Rectangle* create_rectangle(int x, int y, int w, int h) {
    Rectangle* r = (Rectangle*)malloc(sizeof(Rectangle));
    r->base.x = x;
    r->base.y = y;
    // 将函数指针指向具体的实现！
    r->base.draw = draw_rectangle;
    r->base.area = area_rectangle;
    r->width = w;
    r->height = h;
    return r;
}

// 5. 多态的演示
// ------------------------------------
int main() {
    // 创建一个 Circle 对象和 Ractangle 对象
    Circle* c = create_circle(10, 20, 5);
    Rectangle* r = create_rectangle(30, 40, 8, 4);

    // 使用一个通用的 Shape 指针数组来存放它们
    Shape* shapes[2];
    shapes[0] = (Shape*)c; // 向上转型
    shapes[1] = (Shape*)r;

    // 多态调用！同样的代码，根据对象的实际类型执行不同的函数
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw(shapes[i]); // 调用 draw 方法
        printf("Area: %f\n", shapes[i]->area(shapes[i])); // 调用 area 方法
    }
    
    // 释放内存
    free(c);
    free(r);

    return 0;
}

多态的实现依赖于：

  1. 继承：将基类作为第一个成员（内存布局兼容）
  2. 虚函数表：用函数指针模拟（在构造时绑定）
  3. 动态绑定：通过函数指针在运行时调用正确的函数

1. 继承：将基类作为第一个成员

1.1 内存布局

Circle 和 Rectangle 都将 Shape base 作为第一个成员，所以：

Circle* c = create_circle(10, 20, 5);
// 内存布局：
// +----------------+
// | Shape base     |  <- 从偏移量 0 开始
// |   - x          |
// |   - y          |
// |   - draw       |  <- 指向 draw_circle
// |   - area       |  <- 指向 area_circle
// +----------------+
// | radius         |
// +----------------+

内存布局对比：

Circle 对象的内存布局：
地址 0x1000:  ┌──────────────┐
              │ x            │ ← Shape base 的开始
              │ y            │
              │ draw         │
              │ area         │
              ├──────────────┤
              │ radius       │
              └──────────────┘

Shape* 视角看到的：
地址 0x1000:  ┌──────────────┐
              │ x            │
              │ y            │
              │ draw         │ ← shapes[0]->draw 直接访问这里
              │ area         │
              └──────────────┘
              （后面的 radius 看不到，但不影响）

// 方式 1：通过 Shape* 直接访问（你的代码）
shapes[0]->draw(shapes[0]);

// 方式 2：显式访问 base（多此一举）
((Circle*)shapes[0])->base.draw(shapes[0]);

设计成第一个成员, 这种访问就成为了可能：

typedef struct {
    Shape base;  // 必须是第一个成员！
    int radius;
} Circle;

C 语言标准保证：

  • 结构体第一个成员的地址 = 结构体的地址
  • 即：&c->base == (Shape*)c

验证：

Circle* c = create_circle(10, 20, 5);
Shape* s = (Shape*)c;

// 这三个地址完全相同！
printf("%p\n", (void*)c);           // 0x1000
printf("%p\n", (void*)&c->base);    // 0x1000
printf("%p\n", (void*)s);           // 0x1000

// 所以这两种访问完全等价
s->draw;           //  正确
c->base.draw;      //  也正确，但不需要
  • shapes[0]->draw 是正确且推荐的写法
  • shapes[0]->base.draw 会编译错误，因为 shapes[0] 的类型是 Shape*，没有 base 成员
  • 如果要用 base，必须先转型：((Circle*)shapes[0])->base.draw，但这完全没必要

1.2 向上转型不改变指针地址

shapes[0] = (Shape*)c;  // 向上转型

这个转型只是改变了类型，但指针指向的内存地址完全相同！

  • c 指向的地址 = shapes[0] 指向的地址
  • 因为 Shape base 是第一个成员，所以 &c->base == c

1.3 函数指针已经在构造时设置好

在 create_circle 中：

c->base.draw = draw_circle;  // 关键！
c->base.area = area_circle;

在 create_rectangle 中：

r->base.draw = draw_rectangle;  // 关键！
r->base.area = area_rectangle;

1.4 多态调用的完整过程

shapes[i]->draw(shapes[i]);

这行代码的执行步骤：

当 i = 0 时（Circle 对象）：

  1. shapes[0] 指向 Circle 对象的起始地址
  2. shapes[0]->draw 访问该地址的 draw 成员
  3. 因为构造时设置了 c->base.draw = draw_circle
  4. 所以 shapes[0]->draw 实际上是 draw_circle 函数的地址
  5. shapes[0]->draw(shapes[0]) 等价于 draw_circle(shapes[0])

当 i = 1 时（Rectangle 对象）：

  1. shapes[1] 指向 Rectangle 对象的起始地址
  2. shapes[1]->draw 访问该地址的 draw 成员
  3. 因为构造时设置了 r->base.draw = draw_rectangle
  4. 所以 shapes[1]->draw 实际上是 draw_rectangle 函数的地址
  5. shapes[1]->draw(shapes[1]) 等价于 draw_rectangle(shapes[1])

图解说明

创建 Circle 时：
shapes[0] ──────┐
                ↓
        ┌──────────────┐
        │ x = 10       │
        │ y = 20       │
        │ draw ────────┼──→ draw_circle 函数
        │ area ────────┼──→ area_circle 函数
        ├──────────────┤
        │ radius = 5   │
        └──────────────┘
创建 Rectangle 时：
shapes[1] ──────┐
                ↓
        ┌──────────────┐
        │ x = 30       │
        │ y = 40       │
        │ draw ────────┼──→ draw_rectangle 函数
        │ area ────────┼──→ area_rectangle 函数
        ├──────────────┤
        │ width = 8    │
        │ height = 4   │
        └──────────────┘

2 虚函数表：用函数指针模拟（在构造时绑定）

3 动态绑定：通过函数指针在运行时调用正确的函数

4 其他函数方法需要实现多态，也需要添加到shape基类

例如：要添加FuncFly 4.1：

typedef void (*FuncFly)(struct Shape*);

4.2. 添加到 Shape 结构体

typedef struct Shape {
    int x;
    int y;
    FuncDraw draw;
    FuncArea area;
    FuncFly fly;     // 新增！
} Shape;

4.3. 在派生类的构造函数中绑定具体实现

// Circle 的 fly 实现
void fly_circle(Shape* s) {
    Circle* c = (Circle*)s;
    printf("Circle flying at (%d, %d)!\n", c->base.x, c->base.y);
}

// Rectangle 的 fly 实现
void fly_rectangle(Shape* s) {
    Rectangle* r = (Rectangle*)s;
    printf("Rectangle can't fly! It's at (%d, %d)\n", r->base.x, r->base.y);
}

// 修改构造函数
Circle* create_circle(int x, int y, int radius) {
    Circle* c = (Circle*)malloc(sizeof(Circle));
    c->base.x = x;
    c->base.y = y;
    c->base.draw = draw_circle;
    c->base.area = area_circle;
    c->base.fly = fly_circle;    // 绑定 fly 方法
    c->radius = radius;
    return c;
}

Rectangle* create_rectangle(int x, int y, int w, int h) {
    Rectangle* r = (Rectangle*)malloc(sizeof(Rectangle));
    r->base.x = x;
    r->base.y = y;
    r->base.draw = draw_rectangle;
    r->base.area = area_rectangle;
    r->base.fly = fly_rectangle;  // 绑定 fly 方法
    r->width = w;
    r->height = h;
    return r;
}

4.4. 多态调用

for (int i = 0; i < 2; i++) {
    shapes[i]->draw(shapes[i]);
    printf("Area: %f\n", shapes[i]->area(shapes[i]));
    shapes[i]->fly(shapes[i]);   // 新增的多态调用！
}

优点

  • 所有派生类都能使用统一的接口
  • 通过基类指针就能调用所有多态方法

缺点

  1. 所有派生类都必须实现所有方法
    • 即使 Rectangle 不能 fly，也要提供 fly_rectangle 实现
  2. 基类会变得臃肿
    • 每增加一个方法，Shape 就多一个函数指针
    • 所有对象的内存占用都会增加
  3. 缺乏灵活性
    • 不能只让某些派生类实现特定方法

改进方案：接口分离

如果只有部分派生类需要 fly 方法，可以考虑：

// 单独定义一个 Flyable 接口
typedef struct {
    FuncFly fly;
} Flyable;

// 只让需要飞的类继承这个接口
typedef struct {
    Shape base;
    Flyable flyable;  // 可选的飞行能力
    int radius;
} FlyingCircle;

但这会让设计变复杂，C 语言中通常还是用你原来的方式——在基类中添加所有需要的虚函数指针。

jimy1
关注
使用C语言实现多态
qq_41687938的博客
07-30 3998
目录 一、C++的三大特性为：继承，多态，封装 1.1 继承 1.2 多态 1.3 封装 二、用C语言实验多态 2.1 多态的主要特点 2.2 代码实现 2.2.1 C++中的继承与多态 2.2.2C语言实现C++的继承与多态 一、C++的三大特性为：继承，多态，封装 1.1 继承 一个对象直接使用另一个对象的属性和方法。优点： 减少重复的代码。 继承是多态的前提。 继承增加了类的耦合性。 缺点： 继承在编译时刻就定义了，无法在运行时刻改变父类继承的实现； 父...
用C语言实现多态
Zinthos 的笔记本
09-06 949
怎样用C语言实现多态，首先想到的应该是去模拟C++的虚函数。在C++中，每一个含有虚函数的类，都有一个虚函数表。对于类的每一个对象，都有一个指向虚函数表的指针。用C语言模拟这个过程。先考虑最简单的情况，只含有一个虚函数的类，并且只有构造函数，没有虚析构函数。 假设这个类Base有一个int类型的成员变量val，虚函数run(int num)能够输出(val+num)的值。它的派生类Derived的
用C语言实现C++继承与多态
qq704072809的博客
10-18 1409
用C语言实现C++继承与多态
C语言--面向对象编程之多态
weixin_46185705的博客
03-27 5030
系列文章目录 C语言–面向对象编程之封装 C语言–面向对象编程之继承 文章目录系列文章目录前言一、多态是什么？二、使用步骤1.引入库2.读入数据总结 – 前言 C语言实现面向对象编程的第三篇，在前面两篇里面我们已经讨论了C语言实现面向对象的封装与继承，这篇我们了解，面向对象的最后一个特性，多态，顺便了解一下C++中的虚指针与虚表。 一、多态是什么？ 多态指的是能够根据对象的不同类型调用同一个接口，实现不同的功能。在C++中有一个叫做重载的功能，作用类似，比如下面的函数。 看例子： /*函数重载*/ in
C语言实现C++继承和多态
学习使我快乐
08-23 906
C++中的多态 我们知道的是在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。如果一个父类的指针或者引用调用父类的虚函数则该父类的指针会在自己的虚函数表中查找自己的函数地址，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。 //c++中的多态 class Base { pub...
基于C语言实现多态属性（源码+解析）
03-22
代码展示了如何在C语言中模拟实现多态，通过函数指针和结构体来实现基类和派生类的关系，以及通过基类指针调用不同对象的成员函数，实现了多态的效果。虽然在C语言中实现多态不如面向对象语言那样直接，但仍然可以...
C语言实现多态链表
12-07
本资源“C语言实现多态链表”是某培训机构内部的学习材料，旨在帮助开发者理解如何在C语言中通过宏定义来实现一个具有多态性的链表数据结构。下面我们将深入探讨这一主题。 首先，链表是一种动态数据结构，与数组...
c语言实现多态
11-21
下面将详细介绍如何在C语言中实现多态。 1. 函数指针： 函数指针是C语言中实现多态的一种基础方式。它可以被用作参数传递，或者存储在结构体中，使得不同的函数可以通过相同的接口调用。例如，你可以定义一个通用...
C语言如何实现多态
honortech的博客
10-14 800
C语言实现多态的关键在于 void* 类型指针，其可接收任意类型指针
用 C 语言实现程序的多态性
fhb1922702569的博客
03-02 884
简介：使用面向对象的语言可以实现多态，并且在很大程度上降低了代码的复杂性。对于面向过程的 C 语言同样可以实现多态，本文将着重介绍 C 语言是如何实现多态的。 标记本文！ 前言：关于多态，关于 C 多态 (polymorphism) 一词最初来源于希腊语 polumorphos，含义是具有多种形式或形态的情形。在程序设计领域，一个广泛认可的定义是“一种将不同的特殊行为和单个泛化记号相关联的能力”。然而在人们的直观感觉中，多态的含义大约等同于“同一个方法对于不同类型的输入...
C语言：多态
一鸣惊人的博客
04-23 4129
多态指同一个接口的多种实现方式，是面向对象的核心。一般实现多态需满足：必须要有继承，必须要有重写 ，必须要父类引用/指针指向子类对象，三个必要条件。本文将从多态的三个必要条件入手，借鉴Javascript原型链设计并实现了一种C语言的多态实现范式。
C语言实现多态（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
01-10 1838
在C语言中，多态（Polymorphism）是面向对象编程（OOP）中的重要特性，通常用于描述一个接口能够对应多种不同类型的对象。在C语言中，虽然它不是面向对象的语言，但我们可以通过使用结构体、函数指针等技术来模拟多态性。
[C语言]利用函数指针实现C++多态
weixin_43717520的博客
04-10 939
1
C语言实现多态？
master-dragon的专栏
03-18 2184
c语言实现多态。c++的多态分为两种： 1.编译时多态：重载 2.运行时多态：重写（也称为覆盖override）C++实现函数重载，依据的是不同的函数签名（与返回值无关，函数名+函数参数列表决定，这些将写入函数符号表），具体参考http://blog.youkuaiyun.com/qq_26437925/article/details/53740808c语言没有类似C++的上述函数机制。 c语言中有__V
C语言对象编程三：多态
zhen
10-17 625
c语言
C语言实现继承和多态
miyunhong的专栏
03-01 1256
本文来自：http://blog.chinaunix.net/uid-20940095-id-66146.html   非常感谢！ 继承和多态是面向对象语言最强大的功能。有了继承和多态，我们可以完成代码重用。在C中有许多技巧可以实现多态。本文的目的就是演示一种简单和容易的技术，在C中应用继承和多态。通过创建一个VTable（virtual table）和在基类和派生类对象之间提供正确的访
C语言实现多态 (polymorphism)
fareast_mzh的博客
02-08 1165
使用多态，后期扩展功能，不用修改上层策略代码，只需要补充底层模块代码。依赖倒置效果。 * shape.h #ifndef shape_h #define shape_h typedef short int16_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; struct ShapeVtbl; type...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值