Skip to content

4. 函数与结构体

4.1 函数定义

# 带返回值
def add(a: int, b: int) -> int:
    return a + b

# 无返回值
def say_hello() -> None:
    print("Hello")

# 无参数 → void
def get_value() -> int:
    return 42

生成 C：

int add(int a, int b) {
    return (a + b);
}
void say_hello(void) {
    printf("Hello");
    printf("\n");
}
int get_value(void) {
    return 42;
}

None 返回类型 → void。无参数的函数生成 (void)。

4.2 函数声明（不定义）

返回类型包含 c.State 时，只生成声明不生成函数体：

import c

def external_func() -> c.State | int   # int external_func();

生成 C：

int external_func();

4.3 结构体

4.3.1 定义

Python class 转换为 C struct：

class Point:
    x: int
    y: int

class Task:
    name: str
    priority: int
    next: struct Task  # 自引用指针

生成 C：

struct Point {
    int x;
    int y;
};
struct Task {
    char* name;
    int priority;
    struct Task* next;
};

类体内的 __init__ 方法中的 self.x: type 声明也会被提取为结构体成员。

4.3.2 内嵌结构体（init 成员）

class Person: def init(self): self.name: str self.age: int

等价于直接在类体中声明成员。

4.4 方法调用

对象方法转换为 structName__methodName(&obj, ...) 的形式：

class Counter:
    value: int

    def reset(self):
        self.value = 0

    def add(self, n: int):
        self.value += n

c = Counter()
c.reset()
c.add(5)

生成 C：

struct Counter c;
Counter____init__(&c);
Counter__reset(&c);
Counter__add(&c, 5);

4.5 构造函数

如果 __init__ 需要参数，翻译器会分离声明和调用：

class Person:
    name: str
    age: int

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

p = Person("Alice", 30)

生成 C：

struct Person p;
Person____init__(&p, "Alice", 30);

4.6 . vs -> 运算符

翻译器根据变量是否声明为指针自动选择：

s.field         # s 不是指针 → s.field
self.field      # self 总是指针 → self->field
task.field      # task 声明为 struct TASK* → task->field

4.7 主函数

def main() -> int:
    return 0

生成 C：

int main(void) {
    return 0;
}

main 函数的返回类型必须是 int（即使写 None 也会纠正）。

4.8 类型推断

声明变量时，如果右侧是已知函数调用，翻译器从 FunctionReturnTypes 查找返回值类型：

def get_flag() -> int:
    return 1

flag = get_flag()     # 自动推断 flag 为 int