生产企业erp管理软件_北京网页设计公司有哪些_百度指数怎么下载_看广告赚钱的平台

一、Rust中的变量基础知识

1.在Rust中，使用Iet关键字来声明变量

2.Rust支持类型推导，但你也可以显式指定变量的类型：

let x:i32=5;/显式指定x的类型为i32

3.变量名蛇形命名法(Snake Case),而枚举和结构体命名使用帕斯卡命名法(Pasca|Case)

• 蛇形命名法即：两个单词之间加下划线
• 帕斯卡命名法即：首字母大写
• 如果变量没有用到可以前置下划线，消除警告（但是不会报错）

4.强制类型转换Casting a Value to a Different Type

let a 3.1;
let b=a as i32;

5.打印变量({}与{：？}需要实现特质之后章节会介绍，基础类型默认实现)

1.printIn!("val:{}"x);老方法
2.printIn!("val:{x}");新方法

1.Rust中的变量是默认不可变的

不可变性是Rust实现其可靠性和安全性目标的关键

它迫使程序员更深入地思考程序状态的变化，并明确哪些部分的程序状态可能会发生变化的

不可变性有助于防止一类常见的错误，如数据竞争和并发问题

2.使用mut关键字进行可变声明

如果你希望一个变量是可变的，你需要使用ut关键字进行明确声明

let mut y=10;/可变变量
y=20;//合法的修改

3.Shadowing Var iables并不是重新赋值

Rust允许您隐藏一个变量，这意味着您可以声明一个与现有变量同名的新变量，

• 从而有效地隐藏前一个变量
• 可以改变值
• 可以改变类型
• 可以改变可变性

4.Example

 cargo new project

fn main() {println!("Hello, world!");// 不可变与命名let _nice_count = 100;let _nice_number: i16 = 100;// nice_number=1//shadowinglet x = 5;{// 命名空间let x = 10;println!("inner x: {}", x);} //内部的x被销毁println!("outer x: {x}");// 在同一个作用域下重新声明了下，最终覆盖了之前的xlet x = "hello";println!("New x: {x}");// 可以重定义类型 可变性let mut x = "this";println!("mut x: {x}");x = "that";println!("mut x: {x}");
}

编译以及运行

 cargo runCompiling project v0.1.0 (/home/wangji/installer/rust/project)Finished dev [unoptimized + debuginfo] target(s) in 0.27sRunning `target/debug/project`
Hello, world!
inner x: 10
outer x: 5
New x: hello
mut x: this
mut x: that

二、常量const与静态变量static

1.const常量

常量的值必须是在编译时已知的常量表达式，必须指定类型与值

• 与C语言的宏定义（宏替换)不同，Rust的const常量的值被直接嵌入到生成的底层机器代码中，而不是进行简单的字符替换

常量名与静态变量命名必须全部大写，单词之间加入下划线

常量的作用域是块级作用域，它们只在声明它们的作用域内可见

2.static 静态变量

与const常量不同，static变量是在运行时分配内存的

并不是不可变的，可以使用unsafe修改

静态变量的生命周期为整个程序的运行时间

3.Example

// static 一般声明的位置
static MY_STATIC: i32 = 42;
static mut MY_MUT_STATIC: i32 = 42;fn main() {println!("Hello, world!");// constconst SECOND_HOUR: usize = 3600; //等价于3_600const SECOND_DAY: usize = 26 * SECOND_HOUR;{// 块作用域const SE: usize = 1_1000;println!("{SE}");}println!("{SECOND_DAY}");// unsafe 代码unsafe {println!("{}", MY_MUT_STATIC);MY_MUT_STATIC = 30;println!("{}", MY_MUT_STATIC);}
}

编译以及运行

 cargo runCompiling ch2_const_static v0.1.0 (/home/wangji/installer/rust/project/ch2_const_static)
warning: static `MY_STATIC` is never used--> src/main.rs:2:8|
2 | static MY_STATIC: i32 = 42;|        ^^^^^^^^^|= note: `#[warn(dead_code)]` on by defaultwarning: `ch2_const_static` (bin "ch2_const_static") generated 1 warningFinished dev [unoptimized + debuginfo] target(s) in 0.50sRunning `target/debug/ch2_const_static`
Hello, world!
11000
93600
42
30

三、基础数据类型

rust的基础类型包括：整型，浮点型，bool类型，char类型

1. 整型

·Integer types默认推断为i32

• i8、i16、i32、i64、i128

Unsigned Integer Types

• u8、u16、u32、u64、u128

Platform-Specific Integer Type(由平台决定)

• usize
• isize

Float Types
·f32与f64

尽量用f64，除非你清楚边界需要空间

2.Bool类型

Boolean Values

• true
• false

3.Char类型

Character Types

• Rust支持unicode字符（eg：笑脸）
• 表示char类型，要使用单引号

4.Example

fn main() {println!("Hello, world!");// 进制的字面量let a1 = -125; //十进制let a2 = 0xFF; //16进制let a3 = 0o13; //8进制let a4 = 0b10; //二进制println!("{a1} {a2} {a3} {a4}");// MAX MINprintln!("u32 max: {}", u32::MAX);println!("u32 min: {}", u32::MIN);println!("i32 max: {}", i32::MAX);println!("i32 min: {}", i32::MIN);println!("usize max: {}", usize::MAX);println!("isize is: {} bytes", std::mem::size_of::<isize>());println!("usize is: {} bytes", std::mem::size_of::<usize>());println!("u64 is: {} bytes", std::mem::size_of::<u64>());println!("i64 is: {} bytes", std::mem::size_of::<i64>());println!("i32 is: {} bytes", std::mem::size_of::<i32>());// floatlet f1: f32 = 1.23234;let f2: f32 = 9.9888888;println!("Floats ars: {:.2} {:.2}", f1, f2);// boollet is_ok = true;let can_ok: bool = false;println!("is_ok: {}", is_ok);println!("can_Ok: {}", can_ok);println!("or:{}, and:{}", is_ok || can_ok, is_ok && can_ok);// charlet char_c = 'C';let emo_char = '😊';println!("char_c: {}", char_c);println!("emo_char: {}", emo_char);println!("{}", emo_char as usize);println!("{}", emo_char as i32);
}

编译及运行：

 cargo run Compiling ch3_simple_type v0.1.0 (/home/wangji/installer/rust/project/ch3_simple_type)Finished dev [unoptimized + debuginfo] target(s) in 0.38sRunning `target/debug/ch3_simple_type`
Hello, world!
-125 255 11 2
u32 max: 4294967295
u32 min: 0
i32 max: 2147483647
i32 min: -2147483648
usize max: 18446744073709551615
isize is: 8 bytes
usize is: 8 bytes
u64 is: 8 bytes
i64 is: 8 bytes
i32 is: 4 bytes
Floats ars: 1.23 9.99
is_ok: true
can_Ok: false
or:true, and:false
char_c: C
emo_char: 😊
128522
128522

四、元组与数组

相同点

• 元组和数组都是Compound Types（复合类型），而vector，string，map都是Collection Types(集合类型)
• 元组和数组长度都是固定的
• 都可以设置未可变的

不同点

• Tuples，由不同类型的数据类型构成
• Arrays，由相同一类型的数据类型构成

1.数组

数组是固定长度的同构集合

创建方式

• [a,b,c]
• [value;size]

获取元素arr[index]
获取长度arr.Ien()

2.元组

元组是固定长度的异构集合

Empty Tuple()

• 为函数默认返回值

元组获取元素

• tup.index
• 没有Ien()，不同于数组

3.Example

fn main() {println!("Hello, world!");// tuplelet tup = (0, "hi", 3.14);println!("tup element {} {} {}", tup.0, tup.1, tup.2);let mut tup2 = tup;println!("tup2 element {} {} {}", tup.0, tup.1, tup.2);tup2.1 = "world";println!("tup2 element {} {} {}", tup.0, tup2.1, tup.2);// 空的tuple： ()let tup3 = ();println!("tup3: {:?}", tup3); //只能打印格式// arraylet mut arr = [1, 2, 3];arr[0] = 100;println!("arr[0]: {}, size: {}", arr[0], arr.len());for item in arr {println!("{}", item);}let arr2 = [9527; 3];for item in arr2 {println!("{}", item);}// 基础数据类型的拷贝都是深拷贝let arr_item: [i32; 3] = [1, 2, 3];let tuple_item = ("wangji", 18);println!("{:?}", arr_item);println!("{:?}", tuple_item);let arr_copy = arr_item;let tuple_copy = tuple_item;println!("{:?}", arr_item);println!("{:?}", tuple_item);// String数据类型的拷贝是浅拷贝，且拷贝时，所有权会转移let string_item = String::from("ww");let string_copy = string_item;// println!("{:?}", string_item);println!("{:?}", string_copy);
}

编译及测试：

 cargo run
warning: unused variable: `arr_copy`--> src/main.rs:37:9|
37 |     let arr_copy = arr_item;|         ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_arr_copy`|= note: `#[warn(unused_variables)]` on by defaultwarning: unused variable: `tuple_copy`--> src/main.rs:38:9|
38 |     let tuple_copy = tuple_item;|         ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_tuple_copy`warning: `ch4_tuple_array` (bin "ch4_tuple_array") generated 2 warnings (run `cargo fix --bin "ch4_tuple_array"` to apply 2 suggestions)Finished dev [unoptimized + debuginfo] target(s) in 0.00sRunning `target/debug/ch4_tuple_array`
Hello, world!
tup element 0 hi 3.14
tup2 element 0 hi 3.14
tup2 element 0 world 3.14
tup3: ()
arr[0]: 100, size: 3
100
2
3
9527
9527
9527
[1, 2, 3]
("wangji", 18)
[1, 2, 3]
("wangji", 18)
"ww"

参考

• 2024 Rust现代实用教程：2.1-2.4