Ownership expresses responsibility for values and resources, including transfer and cleanup; Rust combines it with borrowing to constrain invalid resource use statically.
Acquiring a resource creates a cleanup responsibility. Ownership associates that responsibility with program values or management objects, rather than leaving only addresses that can access the resource without a consistent release contract.
Rust’s introductory model gives each value an owner and drops the value when its owner leaves the applicable scope. For an owned String buffer, ownership and Drop behavior organize cleanup instead of requiring a handwritten release on every return path.
Assigning an owned Rust String to another binding moves ownership and prevents continued use through the former binding. This does not automatically deep-copy the buffer. An explicit clone creates another owned value, with behavior and cost determined by the type.
Borrowing provides access without transferring the owner’s cleanup responsibility. Shared references and exclusive mutable references have different constraints. Access, mutation, and responsibility for release are therefore distinct permissions.
Ownership does not forbid sharing. Rust’s Rc<T> represents multiple owners of one allocation through reference counting and cleans up the value when the strong count reaches zero. Its holders share a managed allocation rather than automatically duplicating its contents.
Rc is for single-threaded use and does not by itself permit unrestricted mutation of shared contents. Interior-mutability mechanisms such as RefCell enforce some borrowing rules dynamically. Shared ownership, thread safety, and mutation permissions still need separate explanations.