Shulou(Shulou.com)06/03 Report--

This article mainly explains the "Rust Learning Notes to achieve a guessing game project method tutorial", the article explains the content is simple and clear, easy to learn and understand, the following please follow the editor's ideas slowly in-depth, together to study and study the "Rust Learning Notes to achieve a guessing game project method tutorial" bar!

How Rust manages projects

Not all code is like hello_world.rs, and it can be done with a single file. A project often has complex code, and we need a mechanism to manage this complexity by dividing a project into small parts, each of which is segmented and abstracted until it reaches a scale that the human brain can handle. Every programming language has such a mechanism, such as Java's package mechanism, and Rust is no exception.

Rust uses two concepts to manage projects: one is crate (project) and the other is mod (module). Modules are mechanisms for layering and encapsulation within crate, and modules can be included within modules.

Crate: can be simply understood as a project. Crate is a separate compilation unit (compile unit) in Rust. Each crate generates a library or executable file. For comparison, in the familiar C language, a single .c file and all its include files form a compilation unit, each .c generates an .o, and then links these .o together to generate an executable.

Mod: can be simply understood as a namespace. Mod can be nested (note that there can be no circular references between crate), and you can control the visibility of internal elements.

When it comes to visibility, in Rust, elements are private by default, and those decorated with the pub keyword are public. Public and private access is provided as follows:

If an element is private, only the elements in this module and its submodules can be accessed

If an element is public, it can be accessed outside the scope of this module.

The module is an abstract concept, and the file is the entity that carries the concept, but the module and the file are not a simple one-to-one correspondence. There are three ways to create a mod within an crate:

Create an embedded module in a rs file and use the mod keyword directly.

A separate rs file is a module, and the file name is the module name.

A folder can also create a module with a xxx.rs file inside the folder, which is the entry to the module. Its submodules must be declared in this xxx.rs, otherwise the submodules cannot be compiled as the source code of the project.

New project

Cargo is not only the package manager for Rust, but can also be used to create projects. Use the following command to create a project named guessing_game:

Cargo new guessing_game-bin

Note that the following-- bin means that we want the project to generate an executable program, and if we want to be library, we can use the-- lib option.

The above is the manual creation of the project on the command line. In Clion, you can click File- > New Project to fill in the figure below, and then click the Create button:

Project structure

We can use tree. Command or view the current folder structure directly in Clion, as shown in the following figure:

Src/main.rs: this is the rs file automatically generated by cargo. Remember the concepts of crate and mod mentioned earlier? In this project, guessing_game is the crate,src folder and mod,main.rs is the entrance to srcmod. We can create sub-modules in srcmod, but note that these sub-modules must be declared in main.rs, otherwise we cannot participate in the compilation.

.gitignore: this is a file ignored by git, and students who don't understand its function can search it on their own. The point here is that the project created through cargo new is naturally a git project, which confirms Rust's support for open source.

Cargo.toml: this is the project management profile. TOML is a very concise and easy-to-use configuration file format. TOML is the acronym of Tom's Obvious, Minimal Language. Tom here is one of the co-founders of Github. Interested students can learn more about how to write TOML configuration files.

Cargo.lock: this file contains exact information about project dependencies and is maintained by Cargo, so we don't need to care about it.

Compilation execution

In src/main.rs, cargo has automatically generated the output Hello, world! Let's run it and see if it can output properly.

By the way, during your long career in Rust coding, you will find that you will spend a lot of time dealing with compilation errors. Remember, one of the features of Rust is memory security, which ensures that Rust code is almost free of memory errors as long as it runs, and the price behind such an attractive effect is that we have to put extra effort into coding. Rust designed a complex set of rules to ensure memory security, which caused our code to compile inadvertently. Therefore, one of the operations that you often use in the future is to check whether it can be compiled, rather than compiling directly, because it is relatively time-consuming to do code optimization and so on. You can check for compilation errors using the following command:

Cargo check

You need to add a new Configuration in Clion to execute the cargo check command, as shown in the following figure:

After ensuring that the cargo check passes, you can execute the cargo build to perform the compilation. The compilation will result in a target folder and an executable file with the same name as crate under target/debug. But generally for convenience, you can execute cargo run directly, which is equivalent to compiling and then executing. The following figure shows the console output of Clion after cargo run:

Guessing game

After the completion of the project, the next step is to start writing the code for the guessing game. I divided them into six parts: creating variables, input, output, error handling, random number generation, and complete code.

Create variabl

Using the let statement to create variables, it is important to note that in Rust, variables are immutable by default, and you can use mut before the variable name to make the variable variable:

Let a = 5; / / immutable let mut b = 10; / / variable

In the above let statement, we don't show the type that declares the variable, but that doesn't mean that Rust is dynamically typed, Rust is still statically typed, but Rust has a powerful compiler that can infer types from context.

Output

We have already seen the most basic mode of output in hello_world.rs:

Println! ("Hello, world!")

It should be noted that the println here! Is a macro, not a function, and the exclamation point after println is the symbol of the macro. Macros in Rust are completely different from macros in CCompact +. To put it simply, it can be understood as a compile-time syntax extension for the secure version. The reason for using output macros instead of functions is that standard output macros can complete compile-time format checking and are more secure.

If you need to output the value of a variable, you can use the placeholder {}, for example:

Let x = 0 and y = 10 println! ("x = {} println y = {}", x, y)

The output is as follows:

X = 0 and y = 10 input

To get the user's input from the console, you need to use the standard library std::io. Use the use statement to introduce the library into the current scope:

Use std::io

We can use the function stdin in the io library:

Let mut guess = String::new (); / / create a variable variable of string type io::stdin () .read_line (& mut guess) .variant ("Failed to read line")

The stdin function returns an instance of std::io::Stdin, which represents the type of terminal standard input handle. Then call the read_line method, which reads a row from the standard input and stores it in the guess variable. & indicates that this is a reference, this is a complex feature, and we don't need to know about it now.

After reading the user input, we need to determine whether the user entered the number correctly. The String type comes with some methods for handling string handling:

Let guess: U32 = guess.trim () .parse () .expect ("Please type a number!")

The parse method of a string parses a string into a number. Because this method can parse multiple numeric types, you need to tell Rust the specific numeric type, which is specified here by let guess: U32. The colon after guess: tells Rust that we have specified the type of variable. Rust has some built-in numeric types, and U32 is an unsigned 32-bit integer. The trim method is used to eliminate symbols such as carriage returns.

Error handling

There is another expect that has not been analyzed in the previous section of code, and this involves the error handling mechanism in Rust. The return type of read_line is io::Result, which is a specialized version of the Result type in the io module. Result is an enumerated type whose members are Ok and Err,Ok members indicating that the operation was successful and contains the values generated when the operation is successful. An Err member means that the operation failed and contains the causes and consequences of the failure.

The purpose of the Result type is to encode error handling information. Result types, like other types, have methods defined on them. The instance of io::Result has the expect method. If the value of the io::Result instance is Err,expect, it will cause the program to crash and print the information passed to expect by the parameter. If the value of the io::Result instance is Ok,expect, it gets the value in Ok and returns. In this case, this value is the number of bytes entered by the user into the standard input.

Random number generation

Guessing games need to be able to generate random numbers automatically. The random number function is not included in the Rust standard library, but we can get the random number function by introducing external crate. Remember Rust's official open source warehouse, where there are a lot of babies. Open https://crates.io/, type rand in the search box to search for crate with random number function, and the first result is the crate we need.

Now let's introduce this library into our project. Open Cargo.toml and add the following under [dependencies]:

[dependencies] rand = "0.8.3"

[dependencies] tells Cargo which external crate and their versions the project depends on.

Let's use the rand library to generate random numbers. First, introduce rand,use rand::Rng; using the use statement. Then call the following function to produce a number between 1 and 100:

Let number = rand::thread_rng (). Gen_range (1.. 100); complete code

The complete code of the guessing game is as follows.

Use std::io;use std::cmp::Ordering;use rand::Rng;fn main () {println! ("Guess the number!"); let secret_number = rand::thread_rng (). Gen_range (1.. 100); loop {println! ("Please input your guess."); let mut guess = String::new () Io::stdin (). Read_line (& mut guess) .initiate ("Failed to read line"); let guess: U32 = match guess.trim (). Parse () {Ok (num) = > num, Err (_) = > continue,}; println! ("You guessed: {}", guess) Match guess.cmp (& secret_number) {Ordering::Less = > println! ("Too small!"), Ordering::Greater = > println! ("Too big!"), Ordering::Equal = > {println! ("You win!"); break;}

Among them, loop, match, continue, break and other grammars related to control flow operations should be able to make sense. For this complete code, you can read and know what each line has done, without having to dwell on the syntax details.

The results of the guessing game are as follows:

Thank you for your reading, the above is the content of the "Rust Learning Notes to achieve a guessing game project method tutorial", after the study of this article, I believe that you have a deeper understanding of the Rust learning notes to achieve a guessing game project method tutorial, the specific use of the need for you to practice and verify. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.