1
// vtable：函数指针结构体，每个类型一份
2
typedef struct {
3
    double (*area)(void* self);
4
    double (*perimeter)(void* self);
5
} ShapeVtable;
6

7
// 圆形对象：vptr + 数据
8
typedef struct {
9
    ShapeVtable* vptr;  // 8 字节，指向 circle_vtable
10
    double radius;
11
} Circle;
12

13
// 矩形对象：vptr + 数据
14
typedef struct {
15
    ShapeVtable* vptr;  // 8 字节，指向 rect_vtable
16
    double width;
17
    double height;
18
} Rect;

1
// 基类 Shape 的 vtable
2
typedef struct {
3
    void (*draw)(void* self);
4
    double (*area)(void* self);
5
} ShapeVtable;
6

7
// 子类 ColoredShape 的 vtable = Shape 的 + 自己的
8
typedef struct {
9
    // 继承自 Shape（前缀部分，偏移完全一致）
10
    void (*draw)(void* self);
11
    double (*area)(void* self);
12
    // ColoredShape 新增的虚函数
13
    void (*set_color)(void* self, int color);
14
    int  (*get_color)(void* self);
15
} ColoredShapeVtable;

1
// 调用方检查 NULL，而不是假设每个函数指针都有效
2
if (file->f_op->mmap) {
3
    return file->f_op->mmap(file, vma);
4
}
5
return -ENODEV;  // 该操作不支持

1
// 静态分发：编译期为每个具体类型生成独立代码
2
fn total_area<T: Shape>(shapes: &[T]) -> f64 {
3
    shapes.iter().map(|s| s.area()).sum()
4
}
5
// 编译器生成 total_area::<Circle> 和 total_area::<Rect> 两个版本
6

7
// 动态分发：运行时通过 vtable 间接调用
8
fn total_area_dyn(shapes: &[&dyn Shape]) -> f64 {
9
    shapes.iter().map(|s| s.area()).sum()
10
}
11
// 只有一个版本，通过 vtable 分发

1
import "math"
2

3
// ShapeOps 是形状的虚函数表
4
type ShapeOps struct {
5
    Area      func(data []float64) float64
6
    Perimeter func(data []float64) float64
7
}
8

9
// Shape 把 vtable 指针和数据打包在一起
10
type Shape struct {
11
    Ops  *ShapeOps
12
    Data []float64
13
}
14

15
// 各类型提供自己的 vtable 实例
16
var CircleOps = &ShapeOps{
17
    Area:      func(d []float64) float64 { return math.Pi * d[0] * d[0] },
18
    Perimeter: func(d []float64) float64 { return 2 * math.Pi * d[0] },
19
}
20

21
var RectOps = &ShapeOps{
22
    Area:      func(d []float64) float64 { return d[0] * d[1] },
23
    Perimeter: func(d []float64) float64 { return 2 * (d[0] + d[1]) },
24
}
25

26
func NewCircle(r float64) Shape {
27
    return Shape{Ops: CircleOps, Data: []float64{r}}
28
}
29

30
func NewRect(w, h float64) Shape {
31
    return Shape{Ops: RectOps, Data: []float64{w, h}}
32
}
33

34
// 多态分发——不关心具体类型，查表调用
35
func totalArea(shapes []Shape) float64 {
36
    sum := 0.0
37
    for _, s := range shapes {
38
        sum += s.Ops.Area(s.Data) // 通过 vtable 间接调用
39
    }
40
    return sum
41
}

1
// 虚函数表定义接口
2
interface ShapeVtable {
3
  area: (data: number[]) => number;
4
  perimeter: (data: number[]) => number;
5
}
6

7
// 对象 = vtable 指针 + 数据
8
interface Shape {
9
  vtable: ShapeVtable;
10
  data: number[];
11
}
12

13
// 各类型的 vtable 实例
14
const circleVtable: ShapeVtable = {
15
  area: (d) => Math.PI * d[0] * d[0],
16
  perimeter: (d) => 2 * Math.PI * d[0],
17
};
18

19
const rectVtable: ShapeVtable = {
20
  area: (d) => d[0] * d[1],
21
  perimeter: (d) => 2 * (d[0] + d[1]),
22
};
23

24
// 多态分发
25
function totalArea(shapes: Shape[]): number {
26
  return shapes.reduce((sum, s) => sum + s.vtable.area(s.data), 0);
27
}

1
// CPython 中类型对象的简化结构
2
typedef struct _typeobject {
3
    PyObject_VAR_HEAD
4
    const char *tp_name;      // 类型名
5
    Py_ssize_t tp_basicsize;  // 实例大小
6
    destructor tp_dealloc;    // 析构函数
7
    reprfunc tp_repr;         // repr() 实现
8
    hashfunc tp_hash;         // hash() 实现
9
    ternaryfunc tp_call;      // 可调用对象 __call__
10
    // ... 几十个 tp_* 函数指针
11
} PyTypeObject;

1
// VFS 层的调用逻辑（简化）
2
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) {
3
    if (!file->f_op->read && !file->f_op->read_iter)
4
        return -EINVAL;  // 该文件系统不支持读操作
5
    // ... 调用具体的 read 实现
6
}