1
/**
2
 * test_cast_and_defense.c
3
 * 演示向上转型（含多派生类地址对比）、向下转型（container_of）和虚函数防御宏。
4
 */
5

6
#include <stdio.h>
7
#include <stdlib.h>
8
#include <string.h>
9
#include <stddef.h>        /* offsetof */
10

11
/* ----------  container_of 宏 ---------- */
12
#define container_of(ptr, type, member) \
13
    ((type *)((char *)(ptr) - offsetof(type, member)))
14

15
/* ---------- 基类 Person ---------- */
16
typedef struct Person {
17
    const struct VTable* vtable_;
18
    char name_[50];
19
    int  age_;
20
} Person;
21

22
typedef struct VTable {
23
    void (*print_)(void* self);
24
    void (*greet_)(void* self);
25
    void (*destroy_)(void* self);
26
} VTable;
27

28
/* ---------- 派生类 Student ---------- */
29
typedef struct {
30
    Person base_;
31
    char   school_[50];
32
} Student;
33

34
/* ---------- 派生类 Teacher ---------- */
35
typedef struct {
36
    Person base_;
37
    char   subject_[50];
38
    int    years_;
39
} Teacher;
40

41
/* ---------- 虚函数实现 ---------- */
42
void Person_print_impl(void* self) {
43
    Person* p = (Person*)self;
44
    printf("[Person] 姓名：%s，年龄：%d\n", p->name_, p->age_);
45
}
46
void Person_greet_impl(void* self) {
47
    Person* p = (Person*)self;
48
    printf("[Person] 你好，我是%s！\n", p->name_);
49
}
50
void Person_destroy_impl(void* self) {
51
    free(self);
52
}
53

54
void Student_print_impl(void* self) {
55
    Student* s = (Student*)self;
56
    printf("[Student] 姓名：%s，年龄：%d，学校：%s\n",
57
           s->base_.name_, s->base_.age_, s->school_);
58
}
59
void Student_greet_impl(void* self) {
60
    Student* s = (Student*)self;
61
    printf("[Student] 你好，我是%s，来自%s！\n",
62
           s->base_.name_, s->school_);
63
}
64
void Student_destroy_impl(void* self) {
65
    free(self);
66
}
67

68
void Teacher_print_impl(void* self) {
69
    Teacher* t = (Teacher*)self;
70
    printf("[Teacher] 姓名：%s，年龄：%d，科目：%s\n",
71
           t->base_.name_, t->base_.age_, t->subject_);
72
}
73
void Teacher_greet_impl(void* self) {
74
    Teacher* t = (Teacher*)self;
75
    printf("[Teacher] 同学们好，我是%s老师，教%s。\n", t->base_.name_, t->subject_);
76
}
77
void Teacher_destroy_impl(void* self) {
78
    free(self);
79
}
80

81
/* ---------- 静态虚表 ---------- */
82
static const VTable Person_vtable = {
83
    .print_   = Person_print_impl,
84
    .greet_   = Person_greet_impl,
85
    .destroy_ = Person_destroy_impl
86
};
87

88
static const VTable Student_vtable = {
89
    .print_   = Student_print_impl,
90
    .greet_   = Student_greet_impl,
91
    .destroy_ = Student_destroy_impl
92
};
93

94
static const VTable Teacher_vtable = {
95
    .print_   = Teacher_print_impl,
96
    .greet_   = Teacher_greet_impl,
97
    .destroy_ = Teacher_destroy_impl
98
};
99

100
/* ---------- 构造函数 ---------- */
101
Person* Person_newWith(const char* name, int age) {
102
    Person* self = (Person*)malloc(sizeof(Person));
103
    if (!self) return NULL;
104
    self->vtable_ = &Person_vtable;
105
    self->age_ = age;
106
    strncpy(self->name_, name, sizeof(self->name_) - 1);
107
    self->name_[sizeof(self->name_) - 1] = '\0';
108
    return self;
109
}
110

111
Student* Student_newWith(const char* name, int age, const char* school) {
112
    Student* self = (Student*)malloc(sizeof(Student));
113
    if (!self) return NULL;
114
    self->base_.vtable_ = &Student_vtable;
115
    self->base_.age_ = age;
116
    strncpy(self->base_.name_, name, sizeof(self->base_.name_) - 1);
117
    self->base_.name_[sizeof(self->base_.name_) - 1] = '\0';
118
    strncpy(self->school_, school, sizeof(self->school_) - 1);
119
    self->school_[sizeof(self->school_) - 1] = '\0';
120
    return self;
121
}
122

123
Teacher* Teacher_newWith(const char* name, int age,
124
                         const char* subject, int years) {
125
    Teacher* self = (Teacher*)malloc(sizeof(Teacher));
126
    if (!self) return NULL;
127
    self->base_.vtable_ = &Teacher_vtable;
128
    self->base_.age_ = age;
129
    strncpy(self->base_.name_, name, sizeof(self->base_.name_) - 1);
130
    self->base_.name_[sizeof(self->base_.name_) - 1] = '\0';
131
    strncpy(self->subject_, subject, sizeof(self->subject_) - 1);
132
    self->subject_[sizeof(self->subject_) - 1] = '\0';
133
    self->years_ = years;
134
    return self;
135
}
136

137
/* ---------- 安全调用宏 ---------- */
138
#define SAFE_CALL(obj, func) \
139
    do { \
140
        Person* _self_ = (Person*)(obj); \
141
        if ((_self_) && (_self_)->vtable_ && (_self_)->vtable_->func) { \
142
            (_self_)->vtable_->func(_self_); \
143
        } \
144
    } while(0)
145

146
/* ---------- 测试入口 ---------- */
147
int main(void) {
148
    /* 0. 多派生类内存布局验证 */
149
    Student* stu = Student_newWith("Bob", 20, "XYZ University");
150
    Teacher* tch = Teacher_newWith("Alice", 35, "Physics", 10);
151

152
    printf("=== Student 内存布局 ===\n");
153
    printf("Student*    = %p\n", (void*)stu);
154
    printf("&base_      = %p\n", (void*)&stu->base_);
155
    printf("&school_    = %p\n", (void*)&stu->school_);
156

157
    printf("\n=== Teacher 内存布局 ===\n");
158
    printf("Teacher*    = %p\n", (void*)tch);
159
    printf("&base_      = %p\n", (void*)&tch->base_);
160
    printf("&subject_   = %p\n", (void*)&tch->subject_);
161
    printf("&years_     = %p\n", (void*)&tch->years_);
162

163
    Person* ps = (Person*)stu;
164
    Person* pt = (Person*)tch;
165
    printf("\n(Person*)Student = %p  ( == Student* )\n", (void*)ps);
166
    printf("(Person*)Teacher = %p  ( == Teacher* )\n", (void*)pt);
167

168
    /* 1. 向上转型与多态调用 */
169
    printf("\n=== 向上转型与多态 ===\n");
170
    SAFE_CALL(ps, print_);   // Student 版本
171
    SAFE_CALL(pt, print_);   // Teacher 版本
172

173
    /* 2. 向下转型（container_of） */
174
    Student* recovered = container_of(ps, Student, base_);
175
    printf("\n=== 向下转型（container_of） ===\n");
176
    printf("学校：%s\n", recovered->school_);
177
    printf("stu == recovered : %d\n", (void*)stu == (void*)recovered);
178

179
    /* 3. 销毁 */
180
    stu->base_.vtable_->destroy_(stu);
181
    tch->base_.vtable_->destroy_(tch);
182

183
    /* 4. 虚函数防御测试 */
184
    printf("\n=== 虚函数防御测试 ===\n");
185
    SAFE_CALL(NULL, print_);        // 传入 NULL，宏安全跳过
186
    ps = NULL;
187
    SAFE_CALL(ps, print_);          // ps 置空后也安全跳过
188

189
    return 0;
190
}

1
=== Student 内存布局 ===
2
Student*    = 0x55a7c2d4b2a0
3
&base_      = 0x55a7c2d4b2a0
4
&school_    = 0x55a7c2d4b2d8
5

6
=== Teacher 内存布局 ===
7
Teacher*    = 0x55a7c2d4b320
8
&base_      = 0x55a7c2d4b320
9
&subject_   = 0x55a7c2d4b358
10
&years_     = 0x55a7c2d4b38c
11

12
(Person*)Student = 0x55a7c2d4b2a0  ( == Student* )
13
(Person*)Teacher = 0x55a7c2d4b320  ( == Teacher* )
14

15
=== 向上转型与多态 ===
16
[Student] 姓名：Bob，年龄：20，学校：XYZ University
17
[Teacher] 姓名：Alice，年龄：35，科目：Physics
18

19
=== 向下转型（container_of） ===
20
学校：XYZ University
21
stu == recovered : 1
22

23
=== 虚函数防御测试 ===