当前位置: 首页> 财经> 创投人物 > 小游戏网站_工作总结范文简短_个人网站模板建站_桔子seo查询

小游戏网站_工作总结范文简短_个人网站模板建站_桔子seo查询

时间:2025/7/26 20:36:46来源:https://blog.csdn.net/u013985879/article/details/146502365 浏览次数:1次
小游戏网站_工作总结范文简短_个人网站模板建站_桔子seo查询

变量与数据类型

学习目标

完成本章学习后,你将能够:

  • 理解 Rust 中变量的声明和可变性概念
  • 掌握变量遮蔽(shadowing)的使用方法
  • 了解 Rust 的基本数据类型系统
  • 使用不同的数值类型、布尔值和字符
  • 创建和使用复合类型(元组和数组)
  • 进行基本的类型转换
  • 理解 Rust 中的字符串类型

在本章中,我们将学习 Rust 中的变量声明和基本数据类型。Rust 是一种静态类型语言,这意味着所有变量的类型在编译时必须是已知的,但 Rust 也提供了类型推断功能,使代码更加简洁。

变量声明

使用 let 关键字

在 Rust 中,使用 let 关键字声明变量:

let x = 5; // 声明一个变量 x 并赋值为 5

默认情况下,Rust 中的变量是不可变的(immutable)。这是 Rust 安全理念的一部分。

变量的可变性

如果需要一个可变变量,使用 mut 关键字:

let mut y = 5; // 声明一个可变变量
y = 10;        // 可以修改它的值

尝试修改一个不可变变量会导致编译错误:

let x = 5;
x = 10; // 错误:不能对不可变变量二次赋值

变量遮蔽(Shadowing)

Rust 允许声明同名的新变量,新变量会遮蔽(shadow)之前的变量:

let x = 5;
let x = x + 1; // 创建一个新变量 x,值为 6
let x = x * 2; // 再次创建一个新变量 x,值为 12

遮蔽与 mut 的区别:

  1. 使用 let 创建的是一个新变量,可以改变类型
  2. 使用 mut 修改的是同一个变量,类型不能改变
let spaces = "   "; // 字符串类型
let spaces = spaces.len(); // 数值类型,这是合法的let mut spaces = "   ";
spaces = spaces.len(); // 错误:类型不匹配

常量

使用 const 关键字声明常量:

const MAX_POINTS: u32 = 100_000;

常量与不可变变量的区别:

  1. 常量必须显式标注类型
  2. 常量可以在任何作用域中声明,包括全局作用域
  3. 常量只能设置为常量表达式,不能是函数调用的结果或运行时计算的值
  4. 常量在整个程序运行期间有效

数据类型

Rust 是静态类型语言,每个变量必须有一个确定的类型。大多数情况下,编译器可以推断类型,但有时需要显式标注。

标注类型

使用冒号 : 后跟类型名来标注变量类型:

let x: i32 = 5; // 显式指定 x 的类型为 32 位有符号整数

标量类型

Rust 有四种主要的标量类型:整数、浮点数、布尔值和字符。

整数类型
长度有符号无符号
8位i8u8
16位i16u16
32位i32u32
64位i64u64
128位i128u128
架构相关isizeusize

默认整数类型是 i32

整数字面值可以使用不同的表示方法:

let decimal = 98_222;      // 十进制
let hex = 0xff;            // 十六进制
let octal = 0o77;          // 八进制
let binary = 0b1111_0000;  // 二进制
let byte = b'A';           // 字节(仅限 u8)

可以使用下划线提高可读性:1_000_000

浮点数类型

Rust 有两种浮点数类型:f32f64。默认是 f64

let x = 2.0;      // f64
let y: f32 = 3.0; // f32
数值运算

Rust 支持基本的数学运算:

// 加法
let sum = 5 + 10;// 减法
let difference = 95.5 - 4.3;// 乘法
let product = 4 * 30;// 除法
let quotient = 56.7 / 32.2;// 取余
let remainder = 43 % 5;
布尔类型

布尔类型 bool 有两个可能的值:truefalse

let t = true;
let f: bool = false;
字符类型

char 类型表示单个 Unicode 字符,使用单引号表示。

let c = 'z';
let z = 'ℤ';
let heart_eyed_cat = '😻';

char 类型占用 4 字节,可以表示任何 Unicode 标量值。

复合类型

Rust 有两种基本的复合类型:元组(tuple)和数组(array)。

元组类型

元组是一个将多个不同类型的值组合到一起的复合类型。

let tup: (i32, f64, u8) = (500, 6.4, 1);

可以使用模式匹配来解构元组:

let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("y 的值是: {}", y);

也可以使用索引访问元组元素:

let x: (i32, f64, u8) = (500, 6.4, 1);
let five_hundred = x.0;
let six_point_four = x.1;
let one = x.2;
数组类型

数组中的每个元素必须具有相同的类型,且数组长度是固定的。

let a = [1, 2, 3, 4, 5];

声明数组类型的语法:

let a: [i32; 5] = [1, 2, 3, 4, 5];

创建包含相同值的数组:

let a = [3; 5]; // 等同于 let a = [3, 3, 3, 3, 3];

访问数组元素:

let a = [1, 2, 3, 4, 5];
let first = a[0];
let second = a[1];

数组访问是边界检查的,访问超出数组范围的元素会导致运行时错误(panic)。

类型转换

显式类型转换

Rust 要求显式类型转换,使用 as 关键字:

let a = 5;
let b = 2.0;let c = a as f64 + b; // 将 a 转换为 f64 类型

类型推断

Rust 编译器可以根据上下文推断变量类型:

let x = 5;      // 推断为 i32
let y = 1.0;    // 推断为 f64

字符串

Rust 中有两种主要的字符串类型:String&str

字符串字面值

字符串字面值是不可变的,类型为 &str

let s = "hello";

String 类型

String 类型是可增长、可变、有所有权的字符串类型:

let mut s = String::from("hello");
s.push_str(", world!"); // 追加字符串
println!("{}", s); // 输出 "hello, world!"

示例程序

让我们编写一个程序,展示 Rust 中的变量和数据类型:

fn main() {// 变量和可变性let x = 5;println!("x 的值是: {}", x);let mut y = 5;println!("y 的初始值是: {}", y);y = 10;println!("y 的新值是: {}", y);// 变量遮蔽let z = 1;let z = z + 1;let z = z * 2;println!("z 的值是: {}", z);// 常量const MAX_POINTS: u32 = 100_000;println!("常量值是: {}", MAX_POINTS);// 数据类型let a: i32 = -30;let b: u32 = 30;let c = 30; // 默认为 i32println!("整数: {}, {}, {}", a, b, c);let d = 2.5; // f64let e: f32 = 3.0;println!("浮点数: {}, {}", d, e);let f = true;let g: bool = false;println!("布尔值: {}, {}", f, g);let h = 'z';let i = '😊';println!("字符: {}, {}", h, i);// 复合类型let tup = (500, 6.4, true);let (j, k, l) = tup;println!("元组解构: {}, {}, {}", j, k, l);println!("元组索引: {}, {}, {}", tup.0, tup.1, tup.2);let arr = [1, 2, 3, 4, 5];let first = arr[0];let second = arr[1];println!("数组元素: {}, {}", first, second);// 字符串let s1 = "hello";let mut s2 = String::from("hello");s2.push_str(", world!");println!("字符串: {}, {}", s1, s2);
}

总结

在本章中,我们学习了:

  • 使用 let 声明变量,默认不可变
  • 使用 mut 创建可变变量
  • 变量遮蔽的概念和用法
  • 使用 const 声明常量
  • Rust 的基本数据类型:整数、浮点数、布尔值和字符
  • 复合类型:元组和数组
  • 字符串类型:&strString
  • 类型转换和类型推断

理解变量和数据类型是学习任何编程语言的基础。Rust 的类型系统是其安全性和性能的重要保障,掌握这些基础知识将帮助你编写更加健壮的 Rust 程序。在下一章中,我们将学习 Rust 的控制流结构,这将使你能够编写更加复杂和有用的程序。

关键字:小游戏网站_工作总结范文简短_个人网站模板建站_桔子seo查询

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: