13/08/2023
Let us output an integer in Rust.
Rust has a simple line of code that we use in all programs to print to the console. This is the line that you see in the program to your right. (Ignore what this line means for now - we will explain it later)
• What matters for now is just Line 2
"println!" (pronounced "print-line"). This is what we use to output/print anything to the screen.
• Every Rust statement ends with a semicolon (;)
This code just prints 12 on the screen when you run it.
fn main() {
println!("{}", 12);
}
In the last problem, we saw how to output an integer (using println!).
Now let's see how to output some text.
There is only one difference. All textual content should start and end with double quotes.
For eg -
println!("_");
Task
• Replace the _ (underscores) in the editor with the text "I love Rust" to output "I love Rust".
We can also perform mathematical operations with 'println!'.
These use the familiar symbols of:
• ++ for addition
• −− for subtraction
• ∗∗ for multiplication
• // for division
Try printing the sum of 21 and 40.
Notice that on the editor on the right, the instructions appear in gray color. This is because they are comments and don't affect the code. The way we write comments is by adding "//" before it.
fn main() {
println!("{}", 21 + 40); //Replace the _ with the correct value
}
Which line of code will output the string "Hi"?
println!("Hi");
print!("Hi");
println!("{}", "Hi");
print!("{}", "Hi");
Which line of code will output the sum of 7 and 19?
We can add as many cout statements as we want.
Write a program which does the following
• Output: 3 + 4
• Output: 2 + 1.
Note - Notice that in the output they are printed together without any space between them.
fn main() {
print!("{}",3 + 4);
print!("{}", 2 + 1);
}
Write a program for the following problem
• Let’s consider a rectangle of sides 11 and 13.
• Output the following on separate lines
o Area of the rectangle
o Perimeter of the rectangle
fn main() {
let length = 11;
let width = 13;
let area = _____ * _____;
let perimeter = 2 * (_____ + _____);
println!("{}", area);
println!("{}", perimeter);
}
fn main() {
let length = 11;
let width = 13;
let area = length * width;
let perimeter = 2 * (length + width);
println!("{}", area);
println!("{}", perimeter);
}
Rearrange the code to produce this output:
Hello
World
• fn main() {
• println!("{}","");
print!("Hello");
print!("World");
• }
• fn main() {
• print!("Hello");
println!("{}","");
print!("World");
• }
You can also have multiple outputs together in a single "print!" command.
So, for example,
print!("{}" , 2);
println!("{}");
print!("{}" , 3);
and
print!("{}\n{}" , 2 , 3 );
are equivalent.
Task
Write a program which does the following
• Output: 3 + 4
• Output: 2 + 1 in a separate line using the syntax suggested above.
fn main () {
print!("{}\n{}" , 3+4 , 2+1 );
}
Write a Rust program that performs the following tasks:
• Outputs the result of the expression 3 + 4
• On the same line, separated by a single space, outputs the result of the expression 2 + 1. The two results should be displayed on the console on the same line with a space separating them.
Remember to use the space between the {} in the format string to represent the empty space between the two output values.
fn main() {
print!("{} {}",3+ 4 , 2 + 1 );
}
If we want any other text in between the outputs we can provide that text inside " " sign.
Write a program which does the following
• Output the result of 3 + 4
• Output the result of 2 + 1 on the same line
• Insert the text "and" between the outputs.
• Note: We have a space before and after the text as well, as without those, the output would be "7and3", instead of "7 and 3".
fn main() {
print!("{} and {}",3+ 4 , 2 + 1 );
}
What will be the output of this code?
fn main() {
print!("{}{} {}" , 82 , 2 , 3);
}
82 2 3
8223
822 3
822" "3
What will be the output of this code?
fn main() {
print!("{}{} {}{}","Add", 2 , "to" , 3);
}
Add2to3
Add 2 to 3
Add2 to3
Add2to 3
Write a program which does the following
• Output the result - Product of the integers 88 & 99
• Output the result - Sum of 100100 & 200200 multiplied by 22
• Output both results to separate lines
fn main () {
print!("{}\n{}",8*9,(100+200)*2);
}
Write a program which does the following
• Output the result - Difference of the integers 99 & 22
• Output the result - Division of 3030 by 55
• Output both results to the console on separate lines
fn main () {
print!("{}",9-2);
println!();
print!("{}" , 30/5);
}
Let us now look at some of the nuts and bolts of Rust.
Rust, like C++, uses several predefined functions and macros to perform specific tasks, such as handling inputs and outputs.
• fn main() { ... }: This is the main function of the program. In Rust, ex*****on begins with the main function. Any code inside its curly braces {} will be executed. If there are other functions in your code, main() is the function that gets executed first..
• Similar to C++, Rust ignores white space, and we can use it to make the code more readable.
• Comments in Rust start with // for single line comments, and /* ... */ for multi-line comments.
• "print!" - We've already seen what this does.
• Rust does not require a return 0; statement at the end of the main() function like C++ does. In Rust, the main() function returns () (the unit type) by default. If your main() function needs to return a value, it should return a Result.
• Do not forget to add the closing curly bracket "}" to actually end the main function.
Try displaying the sum of 12 & 7 using the given code
fn main() {
print!("{}" ,12+7); //Replace the _ with correct digits
}
What is the difference between
fn main() {
print!("{}",12);
print!("{}",11);
}
and
fn main() {
print!("{}",12);
print!("{}",11);
}
The first code will have outputs on the same line, and the second code will output in separate lines.
The two codes are equivalent.
The second code is wrong, and will not compile.
Suppose we now want to find the area and perimeter of the rectangle again which has length = 11 and width = 13.
But now the width has changed from 13 to 15.
So we'll have to change that number in both - the equation of area and the equation of perimeter.
Instead of changing it in two places each time we change the width, won’t it be easier if we can change it just once?
For that, let's consider doing something like this:
• Let’s take a box, call it "width" and put the number 13 inside it.
• Similarly, let’s also take a box called "length" and put the number 11 inside it.
• Now, to find the area, we just take the numbers inside these two boxes and multiply them. That is, println!("{}", length * width);.
• Similarly, to print the perimeter, we just do println!("{}", 2 * (length + width));.
Now, if we want to change the width from 13 to 15, we just have to change the number inside that box, and nothing else. Both the formulas will now be correct since they take the value from the box.
Note -
• let: In Rust, the let keyword is used to declare or initialize a variable.
• mut: The mut keyword in Rust makes a variable mutable, allowing its value to be changed after it is initially declared.
In Rust, we should also tell what kind of stuff we are going to put into every box.
• Here, we are only going to put integers inside the box called "width".
• So we write
let mut width = 13;
• This means that the box called "width" will contains i32 (i.e. 32-bit integers), and right now, we have put in the integer 13 into it. This is needed only when we name the box for the very first time.
• When we change the value inside the box later on, we'll just write
width = 15
• Note that we don't write "let" at the beginning here because the variable is mutable and we are not declaring a new one but changing its value.
Task
Update the value of 'width' to 15 in your Rust environment and then proceed to calculate the area and perimeter of the rectangle.
Did you like the problem?
fn main() {
let length = 11;
let mut width = 13;
// Calculate and print the area and perimeter
println!("{}", length * width);
println!("{}", 2 * (length + width));
// Update the width
width = __; // replace the underscore with the correct value
// Calculate and print the new area and perimeter
println!("{}", length * width);
println!("{}", 2 * (length + width));
}
Solution:
fn main() {
let length = 11;
let mut width = 13;
// Calculate and print the area and perimeter
println!("{}", length * width);
println!("{}", 2 * (length + width));
// Update the width
width = 15; // replace the underscore with the correct value
// Calculate and print the new area and perimeter
println!("{}", length * width);
println!("{}", 2 * (length + width));
}
The box we discussed in the previous problem is what is known as a Variable in Rust.
And the number that we put inside that box is called the 'Value' of the variable.
When we create a box, we should also specify what Type of box it is.
• If it is an "i32" box, then you can only place integers inside it. You cannot place 3.5 into it..
• For that, you will need to specify that you are going to place decimal values inside it while creating the box, which would make it an "f64" box. These are called Variable Types..
These are the various main types in Rust:
• i32 - stores integers (whole numbers), without decimals, such as 123 or -123
• f64 - stores floating point numbers, with decimals, such as 19.99 or -19.99
• char - stores single characters, such as 'a' or 'B'. Char values are surrounded by single quotes
• String - stores text, such as "Hello World". String values are surrounded by double quotes
• bool - stores values with two states: true or false
• Variables are immutable by default in Rust, meaning their values cannot be modified once assigned. However, by using the mut keyword, variables can be made mutable and their values can be changed.
NOTE
• In Rust, you can explicitly define a variable's data type by using a colon : after the variable's name, followed by the desired type. For example, let number: i32 = 10; explicitly declares number as a 32-bit integer and assigns it the value 10.
• While it's possible to explicitly specify a variable's type in Rust, it's often not necessary because Rust has a feature known as type inference. This feature allows the Rust compiler to automatically determine the types of most variables based on the values they are assigned.
Explicitly specifying the type of a variable is most useful in scenarios where:
• The type cannot be automatically inferred by the compiler.
• There could be ambiguity about which type to use.
• You want to ensure that a specific type is used for a certain variable, regardless of the value it's assigned initially.
Task
Write a program which does the following
• Create an i32 variable named NumberNumber
• Assign the value 19 to NumberNumber
• Use the println! macro to output the value of NumberNumber to the console.
Solution
fn main() {
let Number:i32=19; // Update the value assigned to number
println!("{}", Number);
}
Write a program which does the following
• Declare two variables aa and bb
• Assign the value 2323 to aa and 2020 to bb
• Output the sum of aa and bb to the console
Solution:
fn main () {
let a =23;
let b=20;
println!("{ }",a+b);
}
Write a program which does the following
• Find out and display the area of a rectangle of sides 45 and 76 respectively.
• Declare variables lengthlength, widthwidth and areaarea and assign the relevant values to them
• Make sure to add some text as well, so that the person reading the output knows what the output means.
Solution:
fn main() {
let length =45;
let width = 76;
let area = length *width;
println!("The Area of the given rectangle is {}",area);
}
If we want to introduce decimal values we use the f64 data type when declaring the variable.
Task
Write a program which does the following:
• Find the area of a circle whose radius is 8.9 cm. Take pi = 3.14
• Declare variables radiusradius, p**i and areaarea and assign the relevant values to them
• Note: Area of a circle is P**i ×× radius2radius2
NOTE
• To limit the output to three decimal places, use the println! macro with {:.3} as the placeholder in the output string. This formatting directive will round the floating point number to the nearest value with exactly three decimal places
Type Inference in Rust
• In Rust, the compiler uses Type Inference to automatically determine the data types of variables based on the values they are assigned.
• This means that even if you remove explicit type annotations like f64, the program would still work correctly as the compiler infers the correct type based on the assigned values, simplifying code and enhancing readability.
Did you like the problem?
Solution:
fn main() {
let pi: f64 = 3.14; // pi is declared as an 'f64' (double precision floating point)
let radius: f64 = 8.9;
let area: f64 = pi * radius *radius;
println!("The Area of the given Circle is {:.3}", area);
}
The &str and String types are used to store a sequence of characters, i.e. text. String values must be surrounded by double quotes, ie. " ".
Task
Write a program which does the following
• Declare two variables aa & bb
• Assign the values "Code" & "Chef" to aa and bb respectively
• Display the variables in a single line without any space between them
Note
In Rust, you have two main ways to represent strings
• &str: These are string slices, and they're typically used for fixed-length strings or string literals. They're immutable and usually point to a sequence of UTF-8 characters
• String : The String type is a growable, mutable, owned buffer of UTF-8 bytes. You might use String when you need to modify or own the string data.
For this task, you can use either.
Solution:
fn main() {
let a:&str= "Code";
let b:&str = "Chef";
println!("{}{}", a,b) // should print "CodeChef"
}
