```rust
fn main() {
    let s1 = String::from("hello");
    // Ownership of s1 is transferred (moved) to s2
    let s2 = s1;

    // This line would cause a compile error,
    //  as s1 is no longer valid
    // println!("{}", s1);
    println!("{}", s2);
}
```

Ownership and Variable Binding - Rust Programming

Ownership is central and unique concept to the Rust programming language, and it refers to the way in which the ownership of resources (such as memory) is managed.
   Each value has a single owner, and when the owner goes out of scope, the value is automatically dropped. This ensures that there are no unused pointers or *use-after-free* errors, which can lead to crashes or security vulnerabilities in other programming languages.

University of Michigan - Ann Arbor

Functions in Rust can pass back a value to the code that calls them. The type of the returned value needs to be declared after an arrow (->) but it doesn't need a name. The final expression in the function's body is automatically returned unless the return keyword is used to specify a specific value or the function ends early.

For example:
```rust
// Way 1:
fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

// Way 2:
fn add(a: i32, b: i32) -> i32 {
    a + b;
    // The value of the final expression in the function
    // body will be implicitly returned as the output
}

let result = add(3, 4);
println!("The result is: {}", result);
```

In this example, the function add takes two integers, \`a\` and \`b\`, as input and returns an integer, which is the sum of \`a\` and \`b\`. The function is called with the values \`3\` and \`4\` and the result is stored in the variable \`result\`. The final line then prints "The result is: 7".

Functions with Return Values - Rust Programming

The "loop" command in Rust tells the computer to repeatedly run a specific set of instructions, either continuously or until a specific stopping point is reached, as instructed by the programmer.

Here is an example of how the "loop" keyword might be used in a Rust program:
```rust
let mut x = 0;
loop {
    x += 1;
    println!("x is now {}", x);
    if x == 10 {
        break;
    }
}
```

This code creates a variable x and sets it to 0. Then it starts a loop. Inside the loop, it increases the value of x by 1, prints out the new value of x, and then checks if x is equal to 10. If it is, the break keyword is used to exit the loop. The loop will keep running until x becomes equal to 10. It will print the value of x from 1 to 9.

loop - Rust Programming

An if expression in Rust allows you to choose which code to execute based on a certain condition. You specify a condition and then the code that will run only if the condition is true, and the code will not run if the condition is false.

```rust
let x = 15;

if x < 10 {
    println!("x is less than 10");
} else if x < 20 {
    println!("x is between 10 and 20");
} else {
    println!("x is greater than or equal to 20");
}
```
In this example, the variable \`x\` is assigned the value \`15\`. The first if expression checks if the value of \`x\` is less than 10, if it's not true, it goes to the next \`else if\` which checks if x is less than 20, if it's true, it will print "x is between 10 and 20", otherwise the last block of code will execute and print "x is greater than or equal to 20".

if-else - Rust Programming

In Rust programming, a "for loop" is a type of loop that allows you to iterate over a collection of items, such as an array or a vector. The basic syntax of a for loop in Rust is as follows:

```rust
for variable in collection {
    // code to execute for each item in the collection
}
```

For example, you can use a for loop to iterate over an array of integers and print out each value:

```rust
let numbers = [1, 2, 3, 4, 5];
for num in numbers.iter() {
    println!("{}", num);
}
```

In this example, the for loop iterates over the numbers array, assigns each value to the variable num, and prints the value of num at each iteration.

for - Rust Programming

A common task in programming is to repeatedly execute a loop as long as a certain condition is met. When the condition is no longer met, the loop is halted by utilizing the "break" command. This behavior can be accomplished using a combination of loops, if statements, else statements, and breaks. However, Rust provides a specialized language construct, called a "while loop," that can perform this task with greater ease.

Here is an example of a while loop in Rust that repeatedly runs a block of code as long as the variable "i" is less than 5:
```rust
let mut i = 0;
while i < 5 {
    println!("i is {}", i);
    i += 1;
}
```

In this example, the while loop will continue to execute the code block that prints the value of "i" and increments it by 1, as long as the condition "i < 5" is true. Once "i" becomes greater than or equal to 5, the loop will exit and the program will continue to execute any code that comes after the loop.

while - Rust Programming

Use-After-Free (UAF) vulnerability arises when dynamic memory is misused during program execution. If a program fails to reset the pointer to a memory location after freeing it, an attacker can exploit this error to compromise the program or relative program that is using same memory location

Learn Before

Related

Learn After