When I first came into contact with the language Rust, I mainly admired its performance and syntax. I found that Rust speed even exceeded C/C++ in some places, so I was more interested in this language.
Rust is comparable to C language speed and memory efficiency, but does not require manual memory management or garbage collection. It has excellent tool support, a friendly compiler and an ever-growing developer community. Using Rust can improve program performance, and most importantly, for Python developers, Rust is easier to learn than C language.
Next, let me talk about my views on the advantages of this language:
1. Multi-paradigm
Rust is a multi-paradigm language that supports functional and object-oriented well. Its unique function declaration method
fn Function name (parameter list) -> Return type
This simple declaration method can make people see at a glance that this is a function.
In terms of object-oriented, Rust has added many new concepts and ideas. For example, the Trait and Enum types, the most attractive thing is the Enum type in Rust. Whether it is the Option (Some/None) that handles null pointers or the Result (Ok/Err) that handles errors, this processing method is very user-friendly and very easy to read. Moreover, this Enum type supports generics very well and can truly solve the common memory security problems: such as dereferences of null pointers, etc.
In terms of object-oriented, it must also be mentioned that the Impl system based on Trait has completely cancelled the constructor and instead made it custom. In this case, some meanings that were difficult to express in previous traditional constructors are well reflected in the function name. For example, a TimeDuration class should have many constructors, such as from_ms, from_us, etc., but it is not only difficult to implement with just one constructor, but it is even more difficult to let the user perceive what the constructor is doing.
The Trait system I think is something similar to a tag. With some kind of tag this class has, it must define the behavior of this tag. For example, Add Trait is very commonly used. It is equivalent to telling the compiler that this thing can be used with the + sign. When we write generic functions or other classes, we can easily use this Trait to define the type of the parameter. Without Impl Add Trait, the compiler does not allow it to be used as a parameter. This will expose the errors to the compiler's check.
2. Error handling
I think error handling is also a very good link. A function throws panic when no error handling behavior is defined. This panic is equivalent to an error that is not caught. In general, expressions like try/catch are used to catch errors, but in fact, the readability is not only poor, but it is also completely impossible to predict where the error occurs.
In Rust, all possible functions will be labeled with the Result return value. This Result is also an enumeration generic type, but it has too many functions. It can not only serve as a correct return value, but also carry error information to be passed up. This design makes error search and handling throughout Rust very comfortable. In Rust, as long as the return value of a function is Result, the ? operator can be used in it. ? The function of the operator is mainly to unwrap Result<T,E> into T (that is, the default is the correct value), which has an almost irreplaceable role in the error transmission chain. It not only does not affect the readability of the overall code, but also clearly marks the possible errors in the code.
3. A powerful and standardized standard library
What is always criticized by C++ is its huge standard library. As a new language, Rust does not have as many historical missions as C++, so it can naturally ensure that the design style of its standard library is always consistent.
Rust's standard library is almost entirely designed in an object-oriented style. Among them, the most commonly used ones are Vec/Deque/(Hash/BTree)(Set/Map), etc. These statements are very normative. And they all comply with the same set of APIs, that is, they can operate through the same set of member functions. Even for built-in types, that is, primitive types, the standard library has a lot of mathematical and binary functions. For example, count_ones() can calculate the number of all 1s in a binary bit of a number, and (b) can take the maximum value of two numbers. This all-object-oriented operation also provides space for chain calls.
If you want to find the maximum value of three numbers in C/C++, you will usually write as follows
res = max(max(a, b), c);
But in Rust, it is generally written as follows
res = a
.max(b)
.max(c);
This makes it very easy to read when it is long. Iterator Trait is also adopted in this design, which means that basically all containers declare the Trait. It can handle chain operations well with Lambda expressions and map functions.
4. Macro
As a low-level language, macros are essential. But for example, macros based on simple string replacement such as C/C++ bring many unsafe and unstable factors. Rust has introduced procedural macros as a solution, allowing macros to be captured according to values and expressions, greatly improving the capabilities of macros. In Rust, macros generally have special usage marks - exclamation marks, which allow the caller to make it clear that the caller is calling a macro instead of an ordinary function.
Procedural macros are divided into attribute macros derived macros and functional macros. Functional macros act like ordinary functions and can have mutable parameters. Derived macros and attribute macros can act like decorators in python before procedures and classes.
// Usage of functional macros
let v = vec![1, 2, 3];
println!("{}", 3);
dbg!(v);
5. Modern package management system cargo
cargo is basically an unnecessary but irreplaceable member of the Rust toolchain. Although it is just a layer of rustc package, in terms of package management, Rust is basically the first echelon of all languages I have currently used. There is almost no package management in C/C++. Everyone’s tools are immature, and the installation of libraries can only rely on manual make, which is very primitive. As a new generation of language, Rust is of course connected to the network library. It only needs to write configurations in it to automatically download and compile, which is very efficient and convenient. There is also rustup as a toolchain management, which can be compiled very easily across platforms.
6. Summary
Here is the article about the difference between Rust and C/C++. Which article is better, Rust or C. This is the end. For more information about the difference between Rust and C/C++, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!