Design of `std::stdin()`

help
1

The docs for std::io have a basic code to capture input:

let guess = String::new(); 
io::stdin().read_line(&mut guess)

But why wouldn't there be something like:

let guess = io::stdin().read_line()

which returns a String ? I assume there is a good reason since otherwise it'd be unnecessarily made harder.

2 Likes
2

Because usually in real-world programs you want to read more than one line (eg. in a loop one line at a time, or append multiple lines worth of data to the same string), and if so, you want to reuse the string to avoid unneeded allocations.

10 Likes
3

It's a common theme throughout rust std. The callers provide the buffer, providing more control over allocations. There's more ergonomic stuff like, io::stdin().lines().next(), which returns Option<io::Result<String>>

9 Likes
4

Thanks for that; I was in fact wondering how appending to a String was ergonomic, since in many cases those inputs will be independent and now we would have to extract them from the String.

So that argument would've been more convincing getting a Vec<String>, which is somewhat close to what lines() do.

As they have in the example, using the iterator:

use std::io::stdin;
fn main() {
    for line in stdin().lines() {
        println!("line: {}",line.unwrap());
    }
}

which I wouldn't need if reading just one String (I'd use the one-liner you provided) but if needing to parse the separate answers.

1 Like
5

You would usually use string.clear() to empty the string before each call to read_to_string.

6

Doesn't the same argument apply to every function that returns a String or a Vec or any other collection, that might be used in a loop?

Reusing recent allocations when possible should normally be the memory allocator's job. This API is basically saying: we want you to pre-allocate memory manually rather than use the memory allocator.

This should at best be a secondary, lower-level API for people that want more control over such details, rather than the default way to read a line. Especially since reading a line is such a common function in non performance critical settings, such as interactive programs.

2 Likes
8

Or use something like mem::replace to move it somewhere else (and as a consequence, alse leave the string empty).

9

Doesn't the content of a String get reallocated anyways as the String changes size?

10

I think it reallocates less often than assigning anew each time, when the capacity is larger than the length:

fn main() {
let mut a = String::from("hello");
println!("len: {}, capacity: {}", a.len(), a.capacity());
a.push_str("more hello");
println!("len: {}, capacity: {}", a.len(), a.capacity());
a.push_str("more hello");
println!("len: {}, capacity: {}", a.len(), a.capacity());
a.push_str("abcde");
println!("len: {}, capacity: {}", a.len(), a.capacity());
}

Output:

len: 5, capacity: 5
len: 15, capacity: 15
len: 25, capacity: 30 // now adds abcde without realloc.
len: 30, capacity: 30

i.e pushing abcde did not reallocate.

PS: If I used clear as suggested below and above my reply, it'd re-allocate even less often.

1 Like
11

That's how dynamically allocated data structures work. String reallocate when they grow past capacity. But reusing means you hit that capacity ceiling once, then coast. Creating new Strings means paying the allocation cost every single time.

use std::io::{Result, stdin};

fn main() -> Result<()> {
    let mut buf = String::new();

    // First read: might allocate/grow to say 100 bytes capacity
    stdin().read_line(&mut buf)?; // len=50, capacity=100

    buf.clear(); // len=0, capacity=100 (!!allocation kept!!)

    // Second read: no allocation needed if line fits in 100 bytes
    stdin().read_line(&mut buf)?; // reuses existing allocation

    Ok(())
}

When you clear() a String (or Vec), the length goes to 0 but the capacity stays. The heap allocation is preserved.

So in a loop:

  • First few iterations might reallocate as the buffer grows
  • Once capacity stabilizes (usually quickly), zero allocations for remaining iterations

Compare to returning a new String each time:

// Allocates on EVERY iteration (THIS IS HYPOTHETICAL)
while let Ok(line) = reader.read_line_owned() { ... }
2 Likes