Rust by Example - страница 12
>
>}
>println!("outside inner block: {}", shadowed_binding);
>// This binding *shadows* the previous binding
>let shadowed_binding = 2;
>println!("shadowed in outer block: {}", shadowed_binding);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
It's possible to declare variable bindings first, and initialize them later. However, this form is seldom used, as it may lead to the use of uninitialized variables.
>fn main() {
>// Declare a variable binding
>let a_binding;
>{
>let x = 2;
>// Initialize the binding
>a_binding = x * x;
>}
>println!("a binding: {}", a_binding);
>let another_binding;
>// Error! Use of uninitialized binding
>println!("another binding: {}", another_binding);
>// FIXME ^ Comment out this line
>another_binding = 1;
>println!("another binding: {}", another_binding);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The compiler forbids use of uninitialized variables, as this would lead to undefined behavior.
When data is bound by the same name immutably, it also freezes. Frozen data can't be modified until the immutable binding goes out of scope:
>fn main() {
>let mut _mutable_integer = 7i32;
>{
>// Shadowing by immutable `_mutable_integer`
>let _mutable_integer = _mutable_integer;
>// Error! `_mutable_integer` is frozen in this scope
>_mutable_integer = 50;
>// FIXME ^ Comment out this line
>// `_mutable_integer` goes out of scope
>}
>// Ok! `_mutable_integer` is not frozen in this scope
>_mutable_integer = 3;
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Rust provides several mechanisms to change or define the type of primitive and user defined types. The following sections cover:
• Casting between primitive types
• Specifying the desired type of literals
• Using type inference
• Aliasing types
Rust provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the as keyword.
Rules for converting between integral types follow C conventions generally, except in cases where C has undefined behavior. The behavior of all casts between integral types is well defined in Rust.
>// Suppress all warnings from casts which overflow.
>#![allow(overflowing_literals)]
>fn main() {
>let decimal = 65.4321_f32;
>// Error! No implicit conversion
>let integer: u8 = decimal;
>// FIXME ^ Comment out this line
>// Explicit conversion
>let integer = decimal as u8;
>let character = integer as char;
>// Error! There are limitations in conversion rules. A float cannot be directly converted to a char.
>let character = decimal as char;
>// FIXME ^ Comment out this line
>println!("Casting: {} -> {} -> {}", decimal, integer, character);
>// when casting any value to an unsigned type, T,