Rust 基础语法和数据类型

数据类型

Rust提供了一系列的基本数据类型，包括整型（如i32、u32）、浮点型（如f32、f64）、布尔类型（bool）和字符类型（char）。此外，Rust还提供了原生数组、元组和可变数组（Vec）等复合数据类型。

基本数据类型

整型 (Integers)
let decimal: i32 = 42; // 有符号32位整数

let hex: u32 = 0x1A; // 无符号32位十六进制整数

let binary: u32 = 0b1100; // 无符号32位二进制整数
浮点型 (Floating-Point Numbers)
let float: f32 = 3.14; // 32位浮点数

let double: f64 = 3.141592653589793; // 64位浮点数
布尔类型 (Booleans)

布尔值 true 或 false 

let is_active: bool = true;
字符类型 (Characters)

字符类型，表示一个 Unicode 标量值 

let ch: char = 'a';

复合数据类型

原生数组 (Arrays)

固定长度的数组，所有元素类型必须相同 

let arr: [i32; 5] = [1, 2, 3, 4, 5];
元组 (Tuples)

元组类型，可以包含不同类型的元素

let tuple: (i32, char, f64) = (1, 'a', 3.14);
可变数组 (Vectors)

动态长度的数组，可以通过push等方法修改

let mut vec: Vec<i32> = Vec::new();

vec.push(10);
vec.push(20);
vec.push(30);

变量的可变性

Rust中的变量默认是不可变的。如果你想要一个可变的变量，你需要在声明时使用mut关键字。这有助于编译器在编译时期就确保程序的状态变化是可预测和一致的。

可变变量的声明和修改
fn main() {
    let mut number: i32 = 10; // 声明一个可变的整数变量 
    number += 5; // 修改变量的值
    println!("The number is now: {}", number);
}

在这个例子中，我们声明了一个名为number的可变整数变量，并将其值初始化为10。然后我们通过加法操作符+=修改了它的值。由于number是可变的，所以我们可以这样做。

在函数中修改可变参数
fn increment(number: &mut i32) {
    *number += 1;
}

fn main() {
    let mut value: i32 = 42;
    increment(&mut value);
    println!("The value is now: {}", value);
}

在这个例子中，我们定义了一个函数increment，它接受一个可变引用作为参数，并增加其指向的值。在main函数中，我们调用increment并传入value的可变引用。由于value是可变的，我们可以传递它的引用给函数，函数内部通过解引用来修改它的值。

使用mut来修改集合中的元素
fn main() {
    let mut list: Vec<i32> = vec![1, 2, 3, 4, 5];
    for item in &mut list {
        *item += 1;
    } 
    println!("The list after incrementing: {:?}", list);
}

在这个例子中，我们创建了一个可变的整数向量list，并初始化了一些值。然后我们遍历这个向量的可变引用，并逐一增加每个元素的值。由于我们在遍历时使用了&mut，我们可以在循环内部修改每个元素。

引用和借用

在Rust中，引用和借用是核心概念，它们允许你安全地操作数据而不拥有它的所有权。引用是指向某个值的指针，而借用则是一种特殊的引用，它遵循一定的生命周期规则。Rust的引用和借用机制允许你安全地共享和操作数据。引用是一个指针，指向另一个值而不拥有它，而借用则是在一定条件下对数据的临时访问。这些机制确保了数据的安全性和完整性。下面是一些关于引用和借用的例子：

引用

引用允许你访问数据而不获取其所有权。这意味着你可以读取或修改数据，但不会将其从原始位置移动或复制。

fn main() {
    let s = "Hello, world!";
    let s_ref = &s; // 创建一个对s的引用
    println!("The string is: {}", s_ref);
}

在这个例子中，s_ref是一个对s的引用。我们没有获取s的所有权，因此s在s_ref创建后仍然有效。

可变引用

可变引用是对可变数据的引用，允许你修改数据的值。

fn main() {
    let mut s = String::from("Hello, world!");
    let s_mut = &mut s;
    s_mut.push_str(" in Rust!");
    println!("The modified string is: {}", s);
}

在这个例子中，s_mut是一个可变引用，它允许我们向s字符串中添加更多的文本。注意，s必须是可变的（String类型），因为只有可变变量才能有可变引用。

借用

借用是Rust中的一种机制，它确保你只能有一个可变引用或者任意数量的不可变引用。这是通过生命周期来实现的。

fn main() {
    let s = "Hello, world!";
    let result = longest_borrow(&s);
    println!("The result is: {}", result);
}

fn longest_borrow<'a>(_arg: &'a str) -> &'a str {
    _arg
}

在这个例子中，longest_borrow函数接受一个字符串的引用作为参数，并返回一个引用。函数的返回类型是&'a str，其中'a是生命周期。这意味着返回的引用的生命周期不会超过参数的生命周期。这样做可以防止数据竞争和悬挂引用，确保了内存安全。

借用规则

Rust的借用规则确保引用的有效性和安全性：

  1. 要么有多个不可变引用（但不允许可变引用），要么有一个可变引用（此时不允许其他任何引用）。
  2. 引用的生命周期不能超过被引用数据的生命周期。

这些规则在编译时由编译器强制执行，确保了代码的内存安全性。通过理解和使用引用和借用，你可以编写出既安全又高效的Rust代码。

控制语句

Rust提供了常见的控制结构：条件、循环、分支。

条件语句（if）

条件语句允许根据表达式的值来执行不同的代码块。

fn main() {
    let score = 85;

    if score >= 90 {
        println!("Grade: A");
    } else if score >= 80 {
        println!("Grade: B");
    } else if score >= 70 {
        println!("Grade: C");
    } else {
        println!("Grade: F");
    }
}

在这个例子中，根据 score 变量的值，程序会打印出相应的成绩等级。

循环（loop）

循环允许反复执行一段代码，直到满足某个条件。

fn main() {
    let mut count = 0;

    loop {
        count += 1;
        if count > 5 {
            break;
        }
        println!("Count: {}", count);
    }

    println!("Loop finished.");
}

在这个例子中，loop 会无限执行，直到 count 变量的值大于 5。break 语句用于退出循环。

for 循环

for 循环通常用于遍历集合中的元素。

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    for number in numbers.iter() {
        println!("Number: {}", number);
    }
}

在这个例子中，我们创建了一个整数向量 numbers，然后使用 for 循环遍历它的每个元素。

分支（match）

match 语句是一种多路选择结构，允许根据变量的值选择执行不同的代码块。

fn main() {
    let option = Some(4);

    match option {
        Some(0) => println!("Zero"),
        Some(1) => println!("One"),
        Some(2) ... Some(5) => println!("Two to five"),
        _ => println!("Something else"),
    }
}

在这个例子中，match 语句根据 option 变量的值来执行不同的代码块。这里使用了模式匹配和范围匹配。

这些控制流结构是 Rust 编程中的基础，它们使得编写逻辑清晰、结构良好的代码成为可能。通过合理使用这些结构，你可以构建出功能强大且易于维护的 Rust 程序。

函数

Rust的函数使用fn关键字来定义，并且可以返回值。根据其特性和用途被分为几个不同的类别。以下是一些主要的 Rust 函数分类以及相应的例子：

标准函数 (Standard Functions)

Rust 提供了一系列标准函数，这些函数可以直接使用，无需额外的导入或声明。

fn main() {
    let result = max(10, 20); // 使用标准函数max
    println!("The greater number is: {}", result);
}
用户定义函数 (User-Defined Functions)

用户可以定义自己的函数来执行特定的任务。

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    let message = greet("World");
    println!("{}", message);
}

在这个例子中，我们定义了一个 greet 函数，它接受一个字符串切片作为参数，并返回一个问候语的字符串。

关联函数 (Associated Functions)

关联函数与结构体相关联，但它们不是结构体的方法。它们通常用于操作与结构体相关的数据。

struct Point {
    x: f64,
    y: f64,
}

fn distance(p1: &Point, p2: &Point) -> f64 {
    ((p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sqrt()
}

fn main() {
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = Point { x: 4.0, y: 6.0 };
    let d = distance(&p1, &p2);
    println!("The distance is: {}", d);
}
方法 (Methods)

方法类似于关联函数，但它们是定义在结构体上的，可以通过实例调用。

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    let a = rect.area();
    println!("The area of the rectangle is: {}", a);
}

在这个例子中，我们定义了一个 Rectangle 结构体，并为其实现了 area 方法，用于计算矩形的面积。

闭包 (Closures)

闭包是一种匿名函数，可以捕获其环境的变量。

fn main() {
    let adder = |x: i32, y: i32| x + y;
    let result = adder(10, 20);
    println!("The result of adding is: {}", result);
}

在这个例子中，我们创建了一个闭包 adder，它接受两个 i32 类型的参数并返回它们的和。

函数指针 (Function Pointers)

Rust 允许将函数作为一等公民，这意味着你可以将函数作为参数传递给其他函数，或者将它们存储在变量中。

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn apply_operation(a: i32, b: i32, operation: fn(i32, i32) -> i32) -> i32 {
    operation(a, b)
}

fn main() {
    let result = apply_operation(10, 20, add);
    println!("The result of the operation is: {}", result);
}

在这个例子中，apply_operation 函数接受一个额外的参数 operation，它是一个函数指针，指向一个接受两个 i32 参数并返回一个 i32 的函数。

这些函数类别展示了 Rust 语言在函数定义和使用方面的灵活性和强大功能。通过合理地使用这些函数类型，你可以编写出高效、可读性强且易于维护的代码。

宏

可以使用称被为宏的自定义句法形式来扩展 Rust 的功能和句法。宏需要被命名，并通过一致的句法去调用：some_extension!(...)。定义新宏有两种方式：

  • 声明宏(Macros by Example)以更高级别的声明性的方式定义了一套新句法规则。
  • 过程宏(Procedural Macros)可用于实现自定义派生。

Rust提供了很多标准宏，如： 

println! 宏 - 用于打印输出到控制台，是 Rust 中最常用的宏之一。
format! 宏 - 用于创建一个格式化的字符串，与 println! 类似，但是返回一个 String 类型的值。
vec! 宏 - 用于创建一个 Vec 类型的数组。

println!("Hello, world!");

let formatted_string = format!("The value is: {}", value);

let numbers = vec![1, 2, 3, 4, 5];

结构体和方法

Rust使用结构体（struct）来定义复合数据类型。结构体可以包含数据和方法（与面向对象编程中的成员函数类似）。Rust的方法使用impl关键字来定义，并且可以修改结构体的状态。

在Rust中，结构体是一种自定义的数据类型，它允许你将多个可能不同类型的值组合成一个单一的复合类型。结构体的每个字段称为属性，可以有不同的数据类型。除了定义数据结构，你还可以为结构体定义方法来指定其行为。方法在Rust中通过impl关键字实现，它们类似于面向对象编程中的成员函数。

结构体定义

下面是一个简单的结构体定义的例子：

struct Point {
    x: i32,
    y: i32,
}

这个Point结构体有两个属性：x和y，它们都是i32类型。

方法定义

为结构体定义方法，你需要使用impl关键字，后面跟着结构体的名称。方法可以接受结构体的引用作为参数，并且可以有返回值。

impl Point {
    // 无参的关联函数
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    // 接收结构体的不可变引用，并返回一个值
    fn x(&self) -> i32 {
        self.x
    }

    // 接收结构体的可变引用，并修改其状态
    fn set_x(&mut self, value: i32) {
        self.x = value;
    }
}

在这个例子中，我们定义了三个方法：

  1. new - 一个关联函数，用于创建Point结构体的新实例。
  2. x - 一个实例方法，它返回Point的x属性的值。
  3. set_x - 一个实例方法，它接受一个i32类型的参数，并设置Point的x属性为这个值。
使用结构体和方法

创建Point结构体的实例并调用其方法：

fn main() {
    // 使用关联函数创建Point实例
    let point = Point::new(1, 2);

    // 调用实例方法获取x属性的值
    println!("Point x: {}", point.x());

    // 修改Point的x属性
    point.set_x(10);
    println!("Point x after set: {}", point.x());
}

在这个例子中，我们首先使用Point::new关联函数创建了一个Point实例。然后，我们调用了x方法来获取x属性的值，并打印出来。接着，我们调用了set_x方法来修改x属性的值，并再次打印出来。

通过这种方式，Rust的结构体和方法提供了一种强大的方式来定义和操作自定义数据类型。它们使得代码更加模块化，并且可以很容易地维护和扩展。

所有权系统

Rust的所有权系统是其核心特性之一，它允许语言在编译时期就避免数据竞争和空指针等问题。在Rust中，每个值都有一个变量作为其所有者。一个值在任意时刻只能有一个所有者，当所有者超出作用域，该值也会被自动清理。所有权可以通过变量赋值（move）或通过引用和借用来转移或共享。

特征（Traits）

Rust的特征（trait）是一种定义共享行为的方式。特征类似于接口，允许不同类型的数据实现相同的行为。特征还可以用于泛型编程，使得函数可以接受实现了特定特征的任何类型作为参数。

泛型

Rust支持泛型编程，允许定义可以操作多种类型数据的函数和结构体。泛型在Rust中通过类型参数和约束来实现，提供了强大的类型安全和灵活性。

总结

总的来说，Rust是一种现代的系统编程语言，它通过所有权、借用检查器和类型推断等机制，提供了一种安全、高效和灵活的编程方式。Rust的设计注重内存安全和并发，它提供了与C++相媲美的性能，同时避免了内存管理错误和数据竞争等问题。Rust的设计理念和特性使其成为了系统编程和并发编程的理想选择。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/521629.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

什么是文档一体化？文档一体化有什么意义？

什么是文档一体化？文档一体化有什么意义？

文档一体化是从文书和档案工作全局出发&#xff0c;实现从文件生成制发到归档管理的全过程控制。包括&#xff1a;文档实体生成一体化&#xff0c;文档管理一体化&#xff0c;文档信息利用一体化&#xff0c;文档规范一体化。 文档一体化的意义在于&#xff1a; 1、使档案收集完…
阅读更多...
11-pyspark的RDD的变换与动作算子总结

11-pyspark的RDD的变换与动作算子总结

目录 前言 变换算子动作算子 PySpark实战笔记系列第二篇 10-用PySpark建立第一个Spark RDD(PySpark实战笔记系列第一篇)11-pyspark的RDD的变换与动作算子总结(PySpark实战笔记系列第二篇)) 前言 一般来说&#xff0c;RDD包括两个操作算子&#xff1a; 变换&#xff08;Transf…
阅读更多...
BUUCTF：BUU UPLOAD COURSE 1[WriteUP]

BUUCTF：BUU UPLOAD COURSE 1[WriteUP]

构造一句话PHP木马 <?php eval(system($_POST[shell])); ?> 利用eval函数解析$shell的值使得服务器执行system命令 eval函数是无法直接执行命令的&#xff0c;只能把字符串当作php代码解析 这里我们构造的木马是POST的方式上传&#xff0c;那就用MaxHacKBar来执行 …
阅读更多...
【数据库】SQL简介

【数据库】SQL简介

SQL&#xff08;Structured Query Language&#xff0c;结构化查询语言&#xff09;是一种用于管理关系型数据库管理系统&#xff08;RDBMS&#xff09;的标准化语言。它用于访问和操作数据库中的数据&#xff0c;执行各种任务&#xff0c;如插入、更新、删除和检索数据&#x…
阅读更多...
215 基于matlab的快速跟踪算法

215 基于matlab的快速跟踪算法

基于matlab的快速跟踪算法&#xff0c;提出一种简单又快速、 鲁棒性的算法&#xff0c;基于贝叶斯框架下&#xff0c;该模型 &#xff08;即图像强度和从目标位置&#xff09; 的低级功能及周边地区的统计相关性的时空关系。跟踪问题是通过计算信心地图&#xff0c;并将以最大限…
阅读更多...
数据结构和算法：分治

数据结构和算法：分治

分治算法 分治&#xff08;divide and conquer&#xff09;&#xff0c;全称分而治之&#xff0c;是一种非常重要且常见的算法策略。分治通常基于递归实现&#xff0c;包括“分”和“治”两个步骤。 1.分&#xff08;划分阶段&#xff09;&#xff1a;递归地将原问题分解为两个…
阅读更多...
初学python记录：力扣1483. 树节点的第 K 个祖先

初学python记录：力扣1483. 树节点的第 K 个祖先

题目&#xff1a; 给你一棵树&#xff0c;树上有 n 个节点&#xff0c;按从 0 到 n-1 编号。树以父节点数组的形式给出&#xff0c;其中 parent[i] 是节点 i 的父节点。树的根节点是编号为 0 的节点。 树节点的第 k 个祖先节点是从该节点到根节点路径上的第 k 个节点。 实现…
阅读更多...
docker搭建EFK

docker搭建EFK

目录 elasticsearch1.创建网络2.拉取镜像3.创建容器如果出现启动失败&#xff0c;提示目录挂载失败&#xff0c;可以考虑如下措施 开放防火墙端口4.验证安装成功重置es密码关闭https连接创建kibana用户创建新账户给账户授权 kibana1.创建容器2.验证安装成功3.es为kibana创建用户…
阅读更多...
金融中的数学模型

金融中的数学模型

平稳时间序列 时间序列的基本统计特性&#xff0c;如均值、方差和自相关等&#xff0c;在时间上不随时间的推移而发生显著的变化。 平稳时间序列通常具有以下特征&#xff1a; 均值不随时间变化&#xff1a;序列的均值在时间上保持恒定。方差不随时间变化&#xff1a;序列的…
阅读更多...
元宇宙虚拟空间的场景渲染（五）

元宇宙虚拟空间的场景渲染（五）

前言 该文章主要讲元宇宙虚拟空间的场景渲染&#xff0c;基本核心技术点&#xff0c;不多说&#xff0c;直接引入正题。 场景渲染 下面第二个图中的代码是一个循环渲染逻辑&#xff0c;首先getDelta 获取2次时间的时间间隔&#xff0c;requestAnimationFrame请求我们的一个动…
阅读更多...
C++模版简单认识与使用

C++模版简单认识与使用

目录 前言&#xff1a; 1.泛型编程 2.函数模版 3.类模版 为什么要有类模版&#xff1f;使用typedef不行吗&#xff1f; 类模版只能显示实例化&#xff1a; 注意类名与类型的区别&#xff1a; 注意类模版最好不要声明和定义分离&#xff1a; 总结&#xff1a; 前言&…
阅读更多...
RobotFramework测试框架（13）--扩展RF

RobotFramework测试框架（13）--扩展RF

扩展RF 可以写Python库 Static Library 静态库中RF的关键字被定义为python的方法。 Static Library With a Class 将Python类导入为Library&#xff0c;则类中的方法可以是关键字。 class DemoLibrary:def __init__(self, *args, **kwargs):print(f"Sample Library …
阅读更多...
008 CSS盒子模型

008 CSS盒子模型

文章目录 盒子模型内容-宽度和高度内边距-padding边框-border圆角-border-radius 外边距-margin上下margin的传递上下margin的折叠块级元素的水平居中行内级元素(包括inline-block元素)的水平居中 外轮廓-outline盒子阴影-box-shadow文字阴影-text-shadow行内非替换元素的特殊性…
阅读更多...
代码随想录算法训练营第三十二天| LeetCode 122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II

代码随想录算法训练营第三十二天| LeetCode 122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II

一、LeetCode 122.买卖股票的最佳时机II 题目链接/文章讲解/视频讲解&#xff1a;https://programmercarl.com/0122.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAII.html 状态&#xff1a;已解决 1.思路 这题的核心思路是&#xff1a;…
阅读更多...
Python爬虫-爬取药膳食谱数据

Python爬虫-爬取药膳食谱数据

&#x1f388; 博主&#xff1a;一只程序猿子 &#x1f388; 博客主页&#xff1a;一只程序猿子 博客主页 &#x1f388; 个人介绍&#xff1a;爱好(bushi)编程&#xff01; &#x1f388; 创作不易&#xff1a;喜欢的话麻烦您点个&#x1f44d;和⭐&#xff01; &#x1f388;…
阅读更多...
第二十五周代码（蓝桥杯查缺补漏）

第二十五周代码（蓝桥杯查缺补漏）

2024/03/31 周日 填充 题目链接 【参考代码】 想用暴力&#xff0c;没过 //枚举&#xff0c;未出结果QAQ #include <bits/stdc.h> using namespace std; string s00 "00"; string s11 "11"; int ans 0; //m个问号&#xff0c;子串有2^m…
阅读更多...
C#探索之路基础夯实篇(4)：UML类图中的六种关系详细说明

C#探索之路基础夯实篇(4)：UML类图中的六种关系详细说明

文章目录 UML类图中的关系前景1、关联关系&#xff08;Association&#xff09;&#xff1a;2、聚合关系&#xff08;Aggregation&#xff09;&#xff1a;3、组合关系&#xff08;Composition&#xff09;&#xff1a;4、泛化关系&#xff08;Generalization&#xff09;&…
阅读更多...
计算机网络——37认证

计算机网络——37认证

认证 目标&#xff1a;Bob需要Alice证明他的身份 Protocol ap1.0&#xff1a;Alice说"A am Alice" 可能出现的问题&#xff1a; 在网络上Bob看不到Alice&#xff0c;因此Trudy可以简单的声称他是Alice 认证&#xff1a;重新尝试 Protocol ap2.0&#xff1a;Alice…
阅读更多...
12.自定义的多帧缓存架构

12.自定义的多帧缓存架构

1.简介 在数字图像处理中&#xff0c;经常需要用到的一个架构就是多帧缓存。视频流中需要用到多帧缓存来防止帧撕裂现象&#xff0c;图像处理中也需要帧差法来做移动目标检测。因此一个多帧缓存架构在图像系统的设计中是十分重要的。 2.多帧缓存 在视频流中&#xff0c;通常不…
阅读更多...
数据库 06-03 时间戳

数据库 06-03 时间戳

01.什么是时间戳 “时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。通俗的讲, 时间戳是一份能够表示一份数据在一个特定时间点已经存在的完整的可验证的数据。 02.用时间戳实现调度 定义 数据库给予一个事务一个时…
阅读更多...
最新文章

Copyright @ 2022~2023