Day3 用 rustlings 练习 Rust 语言

大家好

今天 完成 2024年自动驾驶OS开发训练营-初阶营第四期-导学

Day2用 rustlings 练习 Rust 语言 -Move Semantics

在正式开营之前，我们特别设置了导学阶段，旨在帮助大家更好地迎接颇具挑战性的项目实战。

导学阶段包括一系列精心准备的视频课程和配套习题。 github链接：https://classroom.github.com/a/7jeNPL16

第一阶段作业 rustlings ranking：https://cicvedu.github.io/rust-rustlings-semester-4-ranking/

第二阶段作业：https://docs.qq.com/doc/DSk5xTHRJY1FZVUdK 冲💯呀！

Structs

Rust has three struct types: a classic C struct, a tuple struct, and a unit struct.

Further information

• Structures
• Method Syntax

我的题目

https://github.com/cicvedu/rustlings-semester-4-watchpoints

Enums

Rust allows you to define types called "enums" which enumerate possible values. Enums are a feature in many languages, but their capabilities differ in each language. Rust’s enums are most similar to algebraic data types in functional languages, such as F#, OCaml, and Haskell. Useful in combination with enums is Rust's "pattern matching" facility, which makes it easy to run different code for different values of an enumeration.

Further information

• Enums
• Pattern syntax

This section explores a case study of Option, which is another enum defined by the standard library.

enum Option { None, Some(T), }

Strings

Rust has two string types, a string slice (&str) and an owned string (String). We're not going to dictate when you should use which one, but we'll show you how to identify and create them, as well as use them.

Further information

• Strings

C++ 默认绑定的，只有指针类型 在&

https://github.com/cicvedu/rustlings-semester-4-watchpoints

创建ssh key，用于ssh方式克隆github代码。 在linux环境下，使用ssh-keygen -t rsa -b 4096 -C "你的邮箱"命令，创建ssh key， 下面的选项全部直接敲回车即可。 随后使用 cat ~/.ssh/id_rsa.pub

Modules

In this section we'll give you an introduction to Rust's module system.

Further information

• The Module System

Hashmaps

A hash map allows you to associate a value with a particular key. You may also know this by the names unordered map in C++, dictionary in Python or an associative array in other languages.

This is the other data structure that we've been talking about before, when talking about Vecs.

Further information

• Storing Keys with Associated Values in Hash Maps

** ****# Options

Type Option represents an optional value: every Option is either Some and contains a value, or None, and does not. Option types are very common in Rust code, as they have a number of uses:

• Initial values
• Return values for functions that are not defined over their entire input range (partial functions)
• Return value for otherwise reporting simple errors, where None is returned on error
• Optional struct fields
• Struct fields that can be loaned or "taken"
• Optional function arguments
• Nullable pointers
• Swapping things out of difficult situations

Further Information

• Option Enum Format
• Option Module Documentation
• Option Enum Documentation
• if let
• while let **

Error handling

Most errors aren’t serious enough to require the program to stop entirely. Sometimes, when a function fails, it’s for a reason that you can easily interpret and respond to. For example, if you try to open a file and that operation fails because the file doesn’t exist, you might want to create the file instead of terminating the process.

Further information

• Error Handling

• Generics

• Result

• Boxing errors

  Generics

Generics is the topic of generalizing types and functionalities to broader cases. This is extremely useful for reducing code duplication in many ways, but can call for rather involving syntax. Namely, being generic requires taking great care to specify over which types a generic type is actually considered valid. The simplest and most common use of generics is for type parameters.

Further information

• Generic Data Types

• Bounds

  Traits

A trait is a collection of methods.

Data types can implement traits. To do so, the methods making up the trait are defined for the data type. For example, the String data type implements the From<&str> trait. This allows a user to write String::from("hello").

In this way, traits are somewhat similar to Java interfaces and C++ abstract classes.

Some additional common Rust traits include:

• Clone (the clone method)
• Display (which allows formatted display via {})
• Debug (which allows formatted display via {:?})

Because traits indicate shared behavior between data types, they are useful when writing generics.

Further information

• Traits

  在 Rust 中，当你创建一个持有引用的 struct 时，你需要确保这些引用在 struct 的使用期间保持有效。这里的问题在于 Book 这个结构体的字段 author 和 title 是对字符串字面量的引用，但在 main 函数中，它们是对 String 类型的引用。由于 String 类型的大小可变，它不能保证其引用的生命周期，因此我们需要明确地指定生命周期。

要修复这个问题，我们需要为 Book 结构体中的引用添加生命周期注解。这可以通过在结构体定义中为每个引用字段添加生命周期参数来完成。这里是修复后的代码：

struct Book<'a> {
    author: &'a str,
    title: &'a str,
}

fn main() {
    let name = String::from("Jill Smith");
    let title = String::from("Fish Flying");
    
    // 必须保证 name 和 title 在 Book 使用期间有效
    let book = Book { author: &name, title: &title };

    println!("{} by {}", book.title, book.author);
}

  
  

在这个修复版本中，我们为 Book 结构体添加了一个生命周期参数 'a，并在 author 和 title 字段的引用上使用了这个生命周期参数。这意味着 Book 中的引用必须和 'a 生命周期一样长。

然而，上面的代码仍然无法编译，因为 main 函数中的 name 和 title 是 String 类型，而不是 &str 类型。我们需要将它们转换为字符串切片（&str）：

fn main() {
    let name = String::from("Jill Smith");
    let title = String::from("Fish Flying");

    // 转换 String 为 &str 类型的切片
    let book = Book {
        author: name.as_str(),
        title: title.as_str(),
    };

    println!("{} by {}", book.title, book.author);
}

  
  

在这个版本中，我们使用 as_str 方法将 String 类型转换为 &str 类型的切片，这样就可以满足 Book 结构体的要求了。这样修改后，代码应该能够编译并运行，打印出书名和作者名。