Rust Interview Questions and Answers

Ownership is Rust's compile-time memory management model. Every value has exactly one owner, and when the owner goes out of scope the value is dropped and its memory freed. There is no garbage collector.

The three rules are: each value has a single owner, there can only be one owner at a time, and when the owner goes out of scope the value is dropped.

fn main() {
    let s = String::from("hello");
    let t = s;              // s is moved into t
    // println!("{}", s);   // error: borrow of moved value
    println!("{}", t);
}

Simple types such as integers implement Copy and are copied rather than moved. Moving prevents double frees and use-after-free at compile time. When you genuinely need multiple owners, reach for reference counting with Rc or Arc. Functions can take ownership, borrow with &, or return ownership. This discipline is why Rust can guarantee memory safety without a runtime manager, at the cost of thinking about ownership in every API.

String is an owned, growable, heap-allocated UTF-8 string (essentially a Vec<u8>) that you can mutate and extend. &str is a borrowed string slice: a pointer plus a length into UTF-8 data that may live in the binary, on the stack, or inside a String. It is immutable.

let owned: String = String::from("hi");
let slice: &str = &owned;       // borrow
let literal: &str = "static";   // &'static str

fn greet(name: &str) {
    println!("{name}");
}
greet(&owned);                  // deref coercion String -> &str

Prefer &str for function parameters because it accepts both String (through deref coercion) and string literals, making the API more flexible. Use String when the function must own or modify the data. Concatenation with + consumes the left-hand String, and format! is often clearer. &String can be coerced to &str, but &str cannot become &String, which is why libraries expose slices.

Cargo is Rust's build system and package manager. It handles dependency resolution, compilation, testing, documentation, benchmarking and publishing, which keeps projects consistent.

• Cargo.toml declares the package: name, version, edition, dependencies, features and build profiles.
• Cargo.lock pins exact dependency versions for reproducible builds. Commit it for binaries, not necessarily for libraries.
• src/main.rs builds a binary crate; src/lib.rs builds a library crate. Dependencies come from crates.io, a git URL or a local path.

[package]
name = "demo"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1", features = ["derive"] }

Common commands are cargo build, cargo run, cargo test, cargo clippy for lints, cargo fmt and cargo doc. Workspaces let several crates share one lockfile and target directory. This tooling is a major reason Rust projects look uniform across teams.