import stdio import t, c # ============================================================ # 纯内存结构体（class）测试 # ============================================================ class Point: x: t.CInt y: t.CInt class Box: width: t.CInt height: t.CInt depth: t.CInt class Size: w: t.CInt = 100 h: t.CInt = 200 # ============================================================ # 枚举（t.CEnum）测试 # ============================================================ class State(t.CEnum): Idle: t.State Run: t.State Stop: t.State class Color(t.CEnum): Red: t.State = 10 Green: t.State Blue: t.State = 20 Yellow: t.State class MixedType(t.CEnum): Small: t.CInt8T Big: t.CInt64T Medium: t.CInt16T # ============================================================ # 联合体（t.CUnion）测试 # ============================================================ class DataUnion(t.CUnion): i: t.CInt f: t.CFloat l: t.CInt64T # ============================================================ # 主函数 # ============================================================ def struct_test() -> int: # ============================================================ # 测试 1: 结构体字段读写 # ============================================================ p: Point = Point() p.x = 10 p.y = 20 stdio.printf("struct: p.x=%d p.y=%d\n", p.x, p.y) # 修改字段 p.x = 100 p.y = 200 stdio.printf("struct: modified p.x=%d p.y=%d\n", p.x, p.y) # 字段运算 sum_xy: int = p.x + p.y stdio.printf("struct: sum=%d\n", sum_xy) # ============================================================ # 测试 2: 多字段结构体 # ============================================================ b: Box b.width = 3 b.height = 4 b.depth = 5 vol: int = b.width * b.height * b.depth stdio.printf("struct: volume=%d\n", vol) # ============================================================ # 测试 3: t.CArray 数组遍历 # ============================================================ arr: t.CArray[t.CInt, 5] arr[0] = 100 arr[1] = 200 arr[2] = 300 arr[3] = 400 arr[4] = 500 arr_total: int = 0 for i in range(5): arr_total = arr_total + arr[i] stdio.printf("array: total=%d\n", arr_total) # 修改数组元素 arr[2] = 999 stdio.printf("array: arr[2]=%d\n", arr[2]) # ============================================================ # 测试 4: 指针遍历（字符串） # ============================================================ s: str = "hello" sp: str = s slen: int = 0 while c.Deref(sp) != 0: slen = slen + 1 sp = sp + 1 stdio.printf("ptr: len(hello)=%d\n", slen) # 累加字符值 p2: str = "ABC" total_ch: int = 0 while c.Deref(p2) != 0: total_ch = total_ch + c.Deref(p2) p2 = p2 + 1 stdio.printf("ptr: sum(A,B,C)=%d\n", total_ch) # ============================================================ # 测试 5: 结构体构造函数 Point() / Point(x, y) # ============================================================ # 无参数构造：零初始化 z: Point = Point() stdio.printf("ctor: z.x=%d z.y=%d\n", z.x, z.y) # 带参数构造：按位置赋值 p3: Point = Point(7, 8) stdio.printf("ctor: p3.x=%d p3.y=%d\n", p3.x, p3.y) # 多字段构造 bx: Box = Box(10, 20, 30) stdio.printf("ctor: bx.w=%d bx.h=%d bx.d=%d\n", bx.width, bx.height, bx.depth) # ============================================================ # 测试 6: 结构体关键字参数（乱序传参） # ============================================================ # 全关键字乱序 p4: Point = Point(y=20, x=10) stdio.printf("kw: p4.x=%d p4.y=%d\n", p4.x, p4.y) # 混合：位置 + 关键字 p5: Point = Point(5, y=15) stdio.printf("kw: p5.x=%d p5.y=%d\n", p5.x, p5.y) # 多字段关键字乱序 bx2: Box = Box(depth=30, width=10, height=20) stdio.printf("kw: bx2.w=%d bx2.h=%d bx2.d=%d\n", bx2.width, bx2.height, bx2.depth) # ============================================================ # 测试 7: 结构体默认赋值 # ============================================================ # 无参数构造：使用默认值 sz: Size = Size() stdio.printf("def: sz.w=%d sz.h=%d\n", sz.w, sz.h) # 位置参数覆盖默认值 sz2: Size = Size(5, 6) stdio.printf("def: sz2.w=%d sz2.h=%d\n", sz2.w, sz2.h) # 关键字参数覆盖默认值（乱序） sz3: Size = Size(h=999, w=888) stdio.printf("def: sz3.w=%d sz3.h=%d\n", sz3.w, sz3.h) # 混合：位置参数 + 默认值（w=7 覆盖默认值，h 保持默认值 200） sz4: Size = Size(7) stdio.printf("def: sz4.w=%d sz4.h=%d\n", sz4.w, sz4.h) # ============================================================ # 测试 8: 枚举自动赋值（Idle=0, Run=1, Stop=2） # ============================================================ s_idle: int = State.Idle s_run: int = State.Run s_stop: int = State.Stop stdio.printf("enum: Idle=%d Run=%d Stop=%d\n", s_idle, s_run, s_stop) # ============================================================ # 测试 9: 枚举手动赋值（Red=10, Green=11, Blue=20, Yellow=21） # ============================================================ c_red: int = Color.Red c_green: int = Color.Green c_blue: int = Color.Blue c_yellow: int = Color.Yellow stdio.printf("enum: Red=%d Green=%d Blue=%d Yellow=%d\n", c_red, c_green, c_blue, c_yellow) # ============================================================ # 测试 10: 枚举混用数字类型（基准类型应为 i64） # ============================================================ m_small: int = MixedType.Small m_big: int = MixedType.Big m_medium: int = MixedType.Medium stdio.printf("enum: Small=%d Big=%d Medium=%d\n", m_small, m_big, m_medium) # 枚举参与运算 s_sum: int = State.Idle + State.Run + State.Stop stdio.printf("enum: sum(Idle,Run,Stop)=%d\n", s_sum) # 枚举比较 if State.Idle == 0: stdio.printf("enum: Idle==0 true\n") if Color.Red == 10: stdio.printf("enum: Red==10 true\n") if State.Run != State.Stop: stdio.printf("enum: Run!=Stop true\n") # ============================================================ # 测试 11: 联合体字段读写 # ============================================================ u: DataUnion u.i = 42 stdio.printf("union: u.i=%d\n", u.i) # 写入 l 字段（覆盖 i 的内存，因为 l 是 i64） u.l = 20015998343868 stdio.printf("union: u.l=%lld\n", u.l) # ============================================================ # 测试 12: 联合体共享内存验证 # ============================================================ u2: DataUnion u2.i = 1 # 写入 l 后，i 的值已被覆盖（不再是 1） u2.l = 100 if u2.i != 1: stdio.printf("union: shared memory verified\n") return 0