We use data types in Rust to determine the type of data associated with the variables. For example,
let alphabet: char;
Here, char
is the data type that specifies that the alphabet variable can only store the character data.
There are four primary data types in Rust also known as scalar types:
In Rust, we use integer data types to store whole numbers. For example,
let number: i32 = 200;
Here, we have created the number variable of type i32
(integer) and stored the value 200
.
The integer type i32
has two parts to it:
i
- specifies signed integer type (can store both positive or negative value)32
- size of the data type (takes 32 bits of space in memory)fn main() {
// Signed integer type
let x: i32 = -200;
let y: i32 = 200;
println!("x = {}", x);
println!("y = {}", y);
}
Output:
x = -200
y = 200
Here, we have defined two integers x and y with values -200
and 200
respectively and printed it to the screen.
We can also create variables that can only store positive integer values. For example,
fn main() {
// Unsigned integer type
let x: u32 = 300;
println!("x = {}", x);
}
Output:
x = 300
Here, u32
specifies that the x variable can only store positive values. u
specifies unsigned integer type.
If we try to store negative numbers to u32
type variables, we will get an error. For example,
fn main() {
let x: u32 = -200;
println!("x = {}", x);
}
Error:
error[E0600]: cannot apply unary operator `-` to type `u32`
--> main.rs:2:18
|
2 | let x: u32 = -200;
| ^^^^ cannot apply unary operator `-`
|
= note: unsigned values cannot be negated
Depending on the size of data, we can further classify the signed and unsigned integer type into various categories:
Size | Signed | Unsigned |
---|---|---|
8-bit | i8 | u8 |
16-bit | i16 | u16 |
32-bit | i32 | u32 |
64-bit | i64 | u64 |
128-bit | i128 | u128 |
Floating point types are used to store fractional numbers (numbers with decimal points). In Rust, floating-point data types can be divided into:
f32
f64
Here, the f
character represents a floating point number, 32
and 64
represent the size in bits.
Let's take a look at an example,
let x: f32 = 3.1;
Here, f32
is a type declaration for the floating point value. In this case, x is assigned to a floating point value of 3.1
.
fn main() {
// f32 floating point type
let x: f32 = 3.1;
// f64 floating point type
let y: f64 = 45.0000031;
println!("x = {}", x);
println!("y = {}", y);
}
Output:
x = 3.1
y = 45.0000031
Note: f32
is a single-precision floating type whereas f64
is double-precision type. With double-precision, f64
can store data with a larger decimal range and is considered more precise.
In Rust, a boolean data type can have two possible values: true
or false
. For example,
// boolean value true
let flag1: bool = true;
// boolean value false
let flag2: bool = false;
Here, we have used the bool
keyword to represent the boolean type in Rust.
fn main() {
// boolean type
let flag1: bool = true;
let flag2: bool = false;
println!("flag1 = {}", flag1);
println!("flag2 = {}", flag2);
}
Output:
flag1 = true
flag2 = false
Note: Booleans are frequently used in conditional statements like if/else expressions.
The character data type in Rust is used to store a character. For example,
fn main() {
// char type
let character: char = 'z';
println!("character = {}", character);
}
Output:
character = z
Here, char
represents the character type variable and we use single quotes to represent a character.
We can also store special characters like $
, @
, &
, etc. using the character type. For example,
fn main() {
// char type
let character: char = 'z';
let special_character: char = '$';
println!("character = {}", character);
println!("special_character = {}", special_character);
}
Output:
character = z
special_character = $
Note: We can also store numbers as characters using single quotes. For example,
let numeric_character: char = '5';
Here, '5'
is not an integer, it's a character because we have enclosed it inside single quotes.
So far we have mentioned the data type during the variable declaration. However, in Rust we can create variables without mentioning a data type. For example,
let x = 51;
In this case, Rust automatically identifies the data type by looking at the value of the variable x and associates it with the variable. This process is known as Type Inference.
Let's see an example,
fn main() {
let x = 51;
println!("x = {}", x);
}
Output:
x = 51
Here, you can see that we haven't mentioned the data type of x
variable. It is because Rust will automatically set i32
as the type (default type for integer variable) by looking at the value 51
.