rust学习1-入门

Rust学习1-入门

安装Rust &VScode集成Rust

目标:

• windows 环境下使用VScode IDE 进行rust编写和测试运行

• VScode集成rust

windows 安装Rust

It looks like you’re running Windows. To start using Rust, download the installer, then run the program and follow the onscreen instructions. You may need to install the Visual Studio C++ Build tools when prompted to do so. If you are not on Windows see “Other Installation Methods”.

1. 安装 Visual Studio 2019 的构建工具

   https://visualstudio.microsoft.com/visual-cpp-build-tools/

   语言包: 选择中文和英文

   

2. 安装rust

   https://www.rust-lang.org/tools/install 选择64位

   默认安装即可

3. 测试是否安装成功:

   $ cargo --version
   cargo 1.58.0 (f01b232bc 2022-01-19)
   

VSCode集成rust

1. 安装Rust and Friends 集成包

   

2. 集成包中包括: rust-analyzer

   使用rust-analyzer 进行编译运行

Rust语言

基元类型

bool,char

整型 最大支持128位

有符号	无符号
i8	u8
i16	u16
i32	u32
i64	u64
i126	u128

isize	尺寸可变的有符号整型
usize	尺寸可变的无符号整型
f32	32位浮点数
f64	64位浮点数
[T,N]	固定大小的数组, T元素类型,N数组大小
[T]	动态大小的连续序列的视图,T任意类型
str	字符串切片,主要做引用, 即&str
(T,U,…)	有限序列,T,U为不同类型
fn(i32) -> i32	接受i32类型参数并返回i32类型参数的函数

变量声明和不可变性

使用关键字let声明变量, 变量初始,无法分配其他值,若要修改,则前面添加mut关键字

fn main() {
    let a = 1;
    let mut b = 2;
    a = 3;
    b = 4;
    print!("{},{}",a,b);
}

报错.

函数

函数表示:

fn (u64,u64) ->u64

闭包

简单闭包, 通过a来调用, ||内存放参数

let a = ||();

实例:

fn main() {
    let double = |x| x*2;
    let value = 5;
    let twice = double(value);
    let big_c = |b,c| {
        let z = b+c;
        z * twice
    };
    let some = big_c(1,2);
    print!("{}",some);
}

     Running `target\debug\helloworld.exe`
30

字符串

&str, String 两种类型, 保证字符串为有效的UTF-8

条件和判断

类似 C++ if-else

但Rust的if-else 不是语句,而是一个表达式,表达式会返回值

花括号最后一行成为表达式的返回值, if-else分支应具有相同的返回类型

match 表达式

类似于c语言switch语句

fn main(){
    math a {
        b => println("b"),
        c => println("c"),
        other =>{
            xxxx;
        }
    }
}

循环

loop,while,for

loop 无限循环 break 跳出

rust中的for 循环只适用用可以转换为迭代器的类型

for i in 0..10{
    println!("{}",i);
}
// 0..10  0-10 不包括10 
// 0..=10 0-10 包括10

结构体

Rust结构体类似C语言结构体

Rust 中的结构体（Struct）与元组（Tuple）都可以将若干个类型不一定相同的数据捆绑在一起形成整体，但结构体的每个成员和其本身都有一个名字，这样访问它成员的时候就不用记住下标了。元组常用于非定义的多值传递，而结构体用于规范常用的数据结构。结构体的每个成员叫做"字段"。

这是一个结构体定义：

struct Site {
    domain: String,
    name: String,
    nation: String,
    found: u32
}

注意：如果你常用 C/C++，请记住在 Rust 里 struct 语句仅用来定义，不能声明实例，结尾不需要 ; 符号，而且每个字段定义之后用 , 分隔。

有一种更简单的定义和使用结构体的方式：元组结构体。

元组结构体是一种形式是元组的结构体。

与元组的区别是它有名字和固定的类型格式。它存在的意义是为了处理那些需要定义类型（经常使用）又不想太复杂的简单数据：

struct Color(u8, u8, u8);
struct Point(f64, f64);

let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);

"颜色"和"点坐标"是常用的两种数据类型，但如果实例化时写个大括号再写上两个名字就为了可读性牺牲了便捷性，Rust 不会遗留这个问题。元组结构体对象的使用方式和元组一样，通过 . 和下标来进行访问：

fn main() {
    struct Color(u8, u8, u8);
    struct Point(f64, f64);

    let black = Color(0, 0, 0);
    let origin = Point(0.0, 0.0);

    println!("black = ({}, {}, {})", black.0, black.1, black.2);
    println!("origin = ({}, {})", origin.0, origin.1);
}

Rust 语言不是面向对象的，从它所有权机制的创新可以看出这一点。但是面向对象的珍贵思想可以在 Rust 实现。

结构体方法的第一个参数必须是 &self，不需声明类型，因为 self 不是一种风格而是关键字。

struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {
    fn output(&self) -> u32{
        println!("{},",self.width * self.height);
        self.height + self.width
    }
}
fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    Rectangle::output(&rect1);
    println!("rect.1调用{}",rect1.output());
}
---------------------
输出:
1500,
1500,
rect.1调用80

• self 调用此方法后,不允许后续使用该类型
• &self 类型实例的读取访问权限
• &mut self 类型实例的可变访问

module,import,use

模块

• 每个rust程序都需要root模块, 可执行文件,通常为main.rs, 对于程序库,通常为lib.rs
• 模块可以在其他模块内部声明,也可以组织为文件和目录
• 使用mod声明, 使用use引用
• 模块中定义的元素默认为私有的, 使用pub 公共访问

Rust 中有两种简单的访问权：公共（public）和私有（private）。

默认情况下，如果不加修饰符，模块中的成员访问权将是私有的。

如果想使用公共权限，需要使用 pub 关键字。

对于私有的模块，只有在与其平级的位置或下级的位置才能访问，不能从其外部访问。

use 关键字能够将模块标识符引入当前作用域：

当存在两个相同的名称，且同样需要导入，可以使用 as 关键字为标识符添加别名：

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub fn govern() {}
}
   
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;

fn main() {
    nation_govern();
    govern();
}

use 关键字可以与 pub 关键字配合使用：

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub use government::govern;
}

fn main() {
    nation::govern();
}

数组,元组,项目列表

数组具有固定长度, 存储相同类型元素, 数组大小必须是usize确定值,不能是变量

元组可以是不同类型, 元组是异构集合,

项目列表: 类似数组, 但内容和长度可以不用事先指定; 从堆上分配,使用Vec::new 构造或 宏vec![]创建

    let mut number_vec: Vec<u8>  = Vec::new();
    number_vec.push(1);
    number_vec.push(2);
    let mut vec_with_macro = vec![1,2,3,4,6];
    vec_with_macro.push(3);
    let _ = vec_with_macro.pop();
    println!("number_vec :{:?}, vec_with_macro:{:?}",number_vec,vec_with_macro);
----------- 
输出:
number_vec :[1, 2], vec_with_macro:[1, 2, 3, 4, 6]

HashMap 键/值 对

来自std::collections 模块

使用HashMap::new 创建

    let mut fmap = HashMap::new();
    fmap.insert("a", 1);
    fmap.insert("b", 2);
    fmap.insert("c", 3);
    fmap.insert("d", 4);
    for (k,v) in &fmap{
        println!(" got {},{}",k,v);
    }

    //fmap["a"] = 11;  错误语法
    fmap.insert("a", 11);
    *fmap.get_mut("a").unwrap() = 13;
    println!("fmap[\"a\"] : {}",fmap["a"]);

修改内容无法直接使用fmap["a"] = 11; 进行修改

HashMap does not implement IndexMut, while Vec does.

修改方法:

若famp存在其值的话, 直接用insert方法修改

若不确定可以使用: *fmap.get_mut("a").unwrap() = 13; 这种方法