Carbon基本类型 #

一、类型系统概述 #

Carbon是静态类型语言，每个变量和表达式都有确定的类型。类型系统确保类型安全，防止类型错误。

二、整数类型 #

2.1 有符号整数 #

类型 大小 范围
i8 8位 -128 到 127
i16 16位 -32768 到 32767
i32 32位 -2147483648 到 2147483647
i64 64位 约 ±9.2 × 10^18
i128 128位 更大范围
iN N位 自定义宽度
carbon 
var small: i8 = 100;
var medium: i16 = 30000;
var standard: i32 = 2000000000;
var large: i64 = 9000000000000000000;

2.2 无符号整数 #

类型 大小 范围
u8 8位 0 到 255
u16 16位 0 到 65535
u32 32位 0 到 4294967295
u64 64位 0 到 约1.8 × 10^19
u128 128位 更大范围
uN N位 自定义宽度
carbon 
var byte: u8 = 255;
var word: u16 = 65535;
var dword: u32 = 4000000000;
var qword: u64 = 18000000000000000000;

2.3 整数字面量 #

carbon 
// 十进制
var dec: i32 = 42;

// 十六进制
var hex: i32 = 0x2A;      // 42

// 二进制
var bin: i32 = 0b101010;  // 42

// 八进制
var oct: i32 = 0o52;      // 42

// 分隔符（提高可读性）
var big: i32 = 1_000_000;

2.4 整数运算 #

carbon 
var a: i32 = 10;
var b: i32 = 3;

var sum: i32 = a + b;      // 13
var diff: i32 = a - b;     // 7
var product: i32 = a * b;  // 30
var quotient: i32 = a / b; // 3 (整数除法)
var remainder: i32 = a % b; // 1

// 注意：整数除法会截断
var result: i32 = 7 / 2;   // 3

2.5 溢出处理 #

carbon 
// 检测溢出
var x: u8 = 255;
// x = x + 1;  // 可能溢出

// 安全运算
var safe_result: Optional(u8) = x.CheckedAdd(1);
if (safe_result.HasValue()) {
  Print("结果: {0}", safe_result.Value());
} else {
  Print("溢出!");
}

三、浮点类型 #

3.1 浮点类型 #

类型 大小 精度 范围
f16 16位 半精度 约 ±65504
f32 32位 单精度 约 ±3.4 × 10^38
f64 64位 双精度 约 ±1.8 × 10^308
carbon 
var half: f16 = 3.14;
var single: f32 = 3.14159;
var double: f64 = 3.14159265358979;

3.2 浮点字面量 #

carbon 
// 小数形式
var a: f64 = 3.14;

// 科学计数法
var b: f64 = 1.5e10;    // 15000000000
var c: f64 = 1.5e-3;    // 0.0015

// 分隔符
var d: f64 = 3.141_592_653;

3.3 浮点运算 #

carbon 
var x: f64 = 10.0;
var y: f64 = 3.0;

var sum: f64 = x + y;      // 13.0
var diff: f64 = x - y;     // 7.0
var product: f64 = x * y;  // 30.0
var quotient: f64 = x / y; // 3.333...

// 幂运算
var power: f64 = x.Pow(2); // 100.0

// 平方根
var sqrt_val: f64 = x.Sqrt(); // 3.162...

3.4 特殊值 #

carbon 
// 无穷大
var inf: f64 = f64.Infinity;
var neg_inf: f64 = -f64.Infinity;

// 非数字
var nan: f64 = f64.NaN;

// 检查
if (inf.IsInfinite()) {
  Print("无穷大");
}

if (nan.IsNaN()) {
  Print("非数字");
}

四、类型转换 #

4.1 显式转换 #

carbon 
// 整数之间
var i: i32 = 42;
var l: i64 = i64(i);
var u: u32 = u32(i);

// 整数到浮点
var f: f64 = f64(i);

// 浮点到整数（截断）
var d: f64 = 3.7;
var n: i32 = i32(d);  // 3

4.2 安全转换 #

carbon 
// 检查转换是否安全
var large: i64 = 3000000000;
var small: Optional(u32) = u32.TryFrom(large);

if (small.HasValue()) {
  Print("转换成功: {0}", small.Value());
} else {
  Print("转换失败：值超出范围");
}

4.3 隐式转换 #

Carbon不支持隐式类型转换：

carbon 
var i: i32 = 42;
// var l: i64 = i;  // 错误：需要显式转换
var l: i64 = i64(i);  // 正确

五、类型推断 #

5.1 自动推断 #

carbon 
var x = 42;        // i32
var y = 3.14;      // f64
var z = 0x100;     // i32
var w = 1_000_000; // i32

5.2 类型注解影响 #

carbon 
var a: i64 = 42;   // i64
var b: f32 = 3.14; // f32

5.3 上下文推断 #

carbon 
fn TakesI64(x: i64) -> i64 {
  return x;
}

var result = TakesI64(42);  // 42被推断为i64

六、类型别名 #

6.1 基本别名 #

carbon 
typealias UserID = i64;
typealias Port = u16;
typealias Coordinate = f64;

var id: UserID = 1001;
var port: Port = 8080;
var x: Coordinate = 1.5;

6.2 语义化类型 #

carbon 
typealias Seconds = i64;
typealias Milliseconds = i64;

fn Sleep(duration: Seconds) {
  // ...
}

Sleep(5);  // 清晰表示5秒

七、类型属性 #

7.1 类型大小 #

carbon 
Print("i32大小: {0} 字节", i32.Size);   // 4
Print("i64大小: {0} 字节", i64.Size);   // 8
Print("f64大小: {0} 字节", f64.Size);   // 8

7.2 类型范围 #

carbon 
Print("i32最小值: {0}", i32.Min);  // -2147483648
Print("i32最大值: {0}", i32.Max);  // 2147483647
Print("u8最大值: {0}", u8.Max);    // 255

7.3 类型检查 #

carbon 
var x: i32 = 42;
if (x is i32) {
  Print("x是i32类型");
}

八、数值方法 #

8.1 数学方法 #

carbon 
var x: f64 = -3.7;

var abs_val: f64 = x.Abs();      // 3.7
var floor_val: f64 = x.Floor();  // -4.0
var ceil_val: f64 = x.Ceil();    // -3.0
var round_val: f64 = x.Round();  // -4.0

8.2 比较方法 #

carbon 
var a: f64 = 3.14;
var b: f64 = 3.14159;

Print("最小值: {0}", a.Min(b));  // 3.14
Print("最大值: {0}", a.Max(b));  // 3.14159

8.3 位操作 #

carbon 
var x: i32 = 42;

var clz: i32 = x.CountLeadingZeros();   // 前导零
var ctz: i32 = x.CountTrailingZeros();  // 后导零
var pop: i32 = x.PopCount();            // 1的位数

九、最佳实践 #

9.1 选择合适的类型 #

carbon 
// 年龄：使用较小的无符号整数
var age: u8 = 25;

// 计数：使用标准整数
var count: i32 = 0;

// 大数据：使用64位整数
var big_data: i64 = 0;

// 科学计算：使用双精度浮点
var measurement: f64 = 3.14159265358979;

9.2 避免溢出 #

carbon 
// 使用足够大的类型
var large_count: i64 = 0;

// 检查运算结果
var a: i32 = 2000000000;
var b: i32 = 2000000000;
// var c: i32 = a + b;  // 可能溢出

// 使用i64
var c: i64 = i64(a) + i64(b);  // 安全

9.3 浮点精度 #

carbon 
// 不要直接比较浮点数
var a: f64 = 0.1 + 0.2;
var b: f64 = 0.3;
// if (a == b) { ... }  // 可能不成立

// 使用近似比较
if ((a - b).Abs() < 1e-9) {
  Print("近似相等");
}

十、总结 #

本章我们学习了：

  1. 整数类型：有符号和无符号，各种大小
  2. 浮点类型：f16、f32、f64
  3. 类型转换：显式转换、安全转换
  4. 类型推断：自动推断类型
  5. 类型别名：语义化类型定义
  6. 类型属性：大小、范围、检查
  7. 数值方法：数学运算、位操作

接下来让我们学习Carbon的字符串类型！

最后更新：2026-03-27