# Allocation of memory inside for new variable inside a loop

I am learning Rust. I am following the book second edition, and I was doing the exercises given at the end of this chapter.

I did Convert temperatures between Fahrenheit and Celsius. The code is:

``````use std::io;

fn main() {
println!("Welcome to temperature conversion tool.");
println!("---------------------------------------");

loop {
let mut choice = String::new();

println!("1. Fahrenheit to Celsius");
println!("2. Celsius to Fahrenheit");
println!("0. Quit");

let choice: u32 = match choice.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};

if choice == 1 {
let mut temperature = String::new();

println!("Enter Fahrenheit temperature");

let temperature: f32 = match temperature.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};

println!("Celsius temperature is {}", fahrenheit_to_celsius(temperature));
} else if choice == 2 {
let mut temperature = String::new();

println!("Enter Celsius temperature");

let temperature: f32 = match temperature.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};

println!("Fahrenheit temperature is {}", celsius_to_fahrenheit(temperature));
} else if choice == 0 {
break;
} else {
println!("Invalid choice");
continue;
}
}
}

fn fahrenheit_to_celsius(x: f32) -> f32 {
(x - 32.0) * (5.0 / 9.0)
}

fn celsius_to_fahrenheit(x: f32) -> f32 {
x * 9.0 / 5.0 + 32.0
}
``````

You can see that inside the `loop` and `if` condition I am creating mutable variables.

I would like to know how it impacts the system I am running this program on. For example,

• Does it allocates a new placeholder in the system memory for the new variable? Everytime a new variable is declared?

Thank you.

The `String::new()` call itself wonâ€™t allocate memory on the heap - `String::new()` (presumably) just initializes its internal pointer to null. However, every time you call `read_line` with a mutable borrow for those brand new mutable string variables, you will get a memory allocation. If you hoist the `String` variable declarations outside of the the loop structure, you may get fewer allocations - the String should only need to be re-allocated when reading in a larger string.

Itâ€™s important to note that Rust uses RAII, which is just a fancy way of saying all resources (including memory) are freed when they go out of scope. So when the â€śchoiceâ€ť string goes out of scope at the end of a loop iteration, any allocated memory it holds will be returned to the heap. So, if your concern is memory leaks, donâ€™t be concerned. As a rule of thumb, if no references to your resource are left, then the resource itself has been freed.

1 Like

It initializes it to `0x1`, but this is an implementation detail. Youâ€™re correct that it wonâ€™t allocate, and this is guaranteed by its docs.

It actually initializes it to `std::mem::align_of::<T>()`