Rust vs C++

Package Manager

Cargo is Rust’s build system and package manager, https://crates.io/ is the registry.

C++ does not have an official package manager.

Standard Library

Both have a standard library, and used like std::

Memory Safety

Rust provides memory safety without using garbage collection: it uses a system of ownership, which enforces and improves its memory safety across the board. It essentially removes the need for any manual memory management procedures. Rust supplies the built-in features for management procedures while C++ leaves that to you.

Recent updates to C++ has had new features like RAII (Resource Acquisition is Initialization) to get rid of manual memory management.

Pointers and references

• C++: std::shared_ptr and std::unique_ptr can be used like smart pointers.
  • std::unique_ptr<T> is similar to Rust's Box<T>
• Rust:
  • has several smart pointers in its standard library, like the reference counting smart pointer type.
  • does not allow null or dangling pointers.
  • "borrow" = reference (e.g. r = &n), the word "borrow" signifies that it does not own the variable.
    • mutable: let r = &mut n
    • immutable: let r = &n

Lifetime and Scope

Lifetime vs Scope

• Scope: compile time concept, the block in which an identifier is defined.
• Lifetime: run time concept, the sequence of instruction executions.

Lifetime issues can be detected at compile time in Rust, e.g. Rust compiler will capture this use after move error:

let r;
{
  let n = 1;
  // r is a reference of n.
  r = &n;
}
// n is destroyed.
print!("{}", *r)
// Compiler error: `n` does not live long enough

While in C++ it can compile but can cause unpredicatable result at run-time.

int* r;
{
  int n = 1;
  r = &n;
}
cout << *r;

use and using

Rust use is similar to C++ using.

Strings

• Rust:
  • immutable string: let a: &str = "abcd"
  • mutable string: let mut a: String = "abcd".to_string();
• C++:
  • immutable string:
    • with const: const std::string
    • string view: std::string_view
  • mutable string: std::string

Rust &str is not a normal reference, it is a pointer plus a length. The pointer points to the beginning of the string buffer, length is the num of bytes (similar to C++ std::string_view). To get the size of &str: size_of_val(&&a).

Collections