安装
不管OS是否带有rust，都应使用rustup来安装rust
- linux/freebsd
curl https://sh.rustup.rs -sSf | sh
- windows
https://www.rust-lang.org/tools/install
windows下建议使用GNU的编译链接库，不使用microsoft的VC++运行库。
rustup toolchain install stable-x86_64-pc-windows-gnu
rustup default stable-x86_64-pc-windows-gnu
管理和配置工具
- cargo
cargo管理编译、包，含有通用工具。 - rustc
编译器 - rustdoc
rust文档工具，代码注释中规定格式编写的文档，可用于生成格式化的html文档。
项目管理
- 创建项目
% cargo new --bin learn1
freebsd@localhost:~/learnrust % ls learn1
Cargo.toml src
Cargo.toml 保存包的元数据
% cat learn1/Cargo.toml
[package]
name = "learn1"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
测试
freebsd@localhost:~/learnrust % cd learn1/src
freebsd@localhost:~/learnrust/learn1/src % ls
main.rs
freebsd@localhost:~/learnrust/learn1/src % cat main.rs
fn main() {
println!("Hello, world!");
}
freebsd@localhost:~/learnrust/learn1/src % cargo run
Compiling learn1 v0.1.0 (/usr/home/freebsd/learnrust/learn1)
Finished dev [unoptimized + debuginfo] target(s) in 4.53s
Running `/usr/home/freebsd/learnrust/learn1/target/debug/learn1`
Hello, world!
类型
- 浮点型
f32 : 相当于float
f64: 相当于double
fn main() {
let x:f32=11.111;
let y:f64=11.1111111111111;
println!("{},{}",x,y);
}
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
11.111,11.1111111111111
- 推断
下面函数add里定义了myvec变量，但未明确指定其类型，rust编译器可以推断出其元素类型为i32，
fn add(a:i32,b:i32)->Vec<i32>{
let mut myvec=Vec::new();
myvec.push(a);
myvec.push(b);
myvec.push(a+b);
myvec
}
fn main() {
println!("{:?}",add(11,12));
}
字面值
- 不同进制
[maisipu@192 src]$ cat main.rs
fn main() {
println!("{},{},{},{}",22,0x8afb,0o102,0b10010001);
}
[maisipu@192 src]$ rustc main.rs
[maisipu@192 src]$ ./main
22,35579,66,145
ox 十六进制
0b：二进制
0o：八进制
- 转义字符
fn main() {
println!("{:?},{}",b'\n',b'\\');
}
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
10,92
格式输出
打印操作由 std::fmt 里面所定义的一系列宏来处理，包括：
- format!：将格式化文本写到字符串。
- print!：与 format! 类似，但将文本输出到控制台（io::stdout）。
- println!: 与 print! 类似，但输出结果追加一个换行符。
- eprint!：与 print! 类似，但将文本输出到标准错误（io::stderr）。
- eprintln!：与 eprint! 类似，但输出结果追加一个换行符。
位置参数
fn add(a:i32,b:i32)->Vec<i32>{
let mut myvec=Vec::new();
myvec.push(a);
myvec.push(b);
myvec.push(a+b);
myvec
}
fn main() {
let myvec=add(1,20);
println!("{}",myvec[0]);
println!("{0}+{1}={2}",myvec[0],myvec[1],myvec[2]);
}
% cargo run
Compiling learn1 v0.1.0 (/usr/home/freebsd/learnrust/learn1)
Finished dev [unoptimized + debuginfo] target(s) in 0.13s
Running `target/debug/learn1`
1
1+20=21
格式化文本
fn add(a:i32,b:i32)->Vec<i32>{
let mut myvec=Vec::new();
myvec.push(a);
myvec.push(b);
myvec.push(a+b);
myvec
}
fn main() {
let myvec=add(1,20);
println!("{}",myvec[0]);
println!("{:?}:{}+{}={}",myvec,myvec[0],myvec[1],myvec[2]);
}
% cargo run
Compiling learn1 v0.1.0 (/usr/home/freebsd/learnrust/learn1)
Finished dev [unoptimized + debuginfo] target(s) in 0.13s
Running `target/debug/learn1`
1
[1, 20, 21]:1+20=21
命名参数
fn add(a:i32,b:i32)->Vec<i32>{
let mut myvec=Vec::new();
myvec.push(a);
myvec.push(b);
myvec.push(a+b);
myvec
}
fn main() {
let myvec=add(1,20);
println!("{}",myvec[0]);
let result=myvec[2];
println!("{:?}:{result}",myvec);
}
% cargo run
Compiling learn1 v0.1.0 (/usr/home/freebsd/learnrust/learn1)
Finished dev [unoptimized + debuginfo] target(s) in 0.10s
Running `target/debug/learn1`
1
[1, 20, 21]:21
@
类型转换
使用as
[maisipu@192 src]$ cargo run
Compiling learnrust v0.1.0 (/home/maisipu/learn/learnrust)
Finished dev [unoptimized + debuginfo] target(s) in 0.57s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
11,11
fn main() {
let x:f32=11.111;
let y:f64=11.1111111111111;
println!("{},{}",x as i32 ,y as i8);
}
浮点字面值
fn main(){
let x=11.111_f32;
let y=11.1111111111111_f64;
println!("{},{}",x,y);
}
[maisipu@192 src]$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
11.111,11.1111111111111
[maisipu@192 src]$
字符类型
char为字符类型，用32位值形式表示unicode字符。
fn main(){
let x='你';
let y:char='z';
println!("{},{}",x,y);
}
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
你,z
数组
- 数组表达式构造数组。数组表达式有两种形式。
第一种形式列出了数组中的每个值。
语法是一个逗号分隔的统一类型的表达式列表，用方括号括起来。这将生成一个数组，其中按写入顺序包含这些值中的每一个。
第二种形式的语法是由方括号中的分号（；）分隔的两个表达式。
前面的表达式；称为重复操作数。后面的表达式；称为长度操作数。它必须具有usinize类型，并且是常量表达式，例如文字或常量项。此形式的数组表达式创建一个长度为长度操作数值的数组，每个元素都是重复操作数的副本。
当重复操作数是常量项时，将按长度操作数的值对其求值。如果该值为0，则根本不计算常量项。对于不是常量项的表达式，只计算一次，然后将结果复制到长度操作数的值次。
- 数组可以迭代
for表达式用于在std:：iter:：IntoIdeator的实现所提供的元素上循环。如果迭代器为空，则for表达式完成。
fn main(){
let y=[11,22,33];
for i in y{
println!("{}",i);
}
let z=[111;9];
println!("{:?}",z);
}
11
22
33
[111, 111, 111, 111, 111, 111, 111, 111, 111]
元组
-
元素的每个类型可以不同
-
元组不能迭代访问
fn main(){
let y=(11,22,33);
for i in y{
println!("{}",i);
}
}
上面代码是错误的，因为元组的元素类型不一定会一致
- 只允许用常量作为索引
与字段访问表达式不同，元组索引表达式可以是调用表达式的函数操作数，因为它不能与方法调用混淆，因为方法名称不能是数字。
尽管数组和切片也有元素，但必须使用数组或切片索引表达式或切片模式来访问它们的元素。
fn main(){
let y=(1,22,333);
println!("{},{},{}",y.0,y.1,y.2);
let z=(111,"asddsaddaa");
println!("{:?}",z);
}
[maisipu@192 src]$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
1,22,333
(111, "asddsaddaa")
- 元组经常作为函数的返回类型，可以返回多个值
- 元组也可以作为函数的参数
[maisipu@192 src]$ cat main.rs
fn get_sum(nums:(i32,i32,i32))->(i32,i32){
let mut result:i32=0;
result=result+nums.0+nums.1+nums.2;
(result,result/3)
}
fn main(){
let y=(1,22,333);
println!("{:?}",get_sum(y));
}
[maisipu@192 src]$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/maisipu/learn/learnrust/target/debug/learnrust`
(356, 118)
[maisipu@192 src]$