C++ to Rust Cheat-Sheet

fn add(first: i32, second: i32) -> i32 {
    first + second
}

int add(int first, int second) {
    return first + second;
}

fn add(a: i32, b: i32) -> i32 { a + b }

auto add(int a, int b) -> int { return a + b; }

struct Person {
    id: u32,
    health: i32
}

struct Person {
    unsigned int id;
    int health;
};

impl MyClass {
    fn new(name: &String, data: &Vec) -> Self {
        // ...
    }
}

// Usually split between header (.h) and implementation (.cpp)
// Header:
class MyClass {
public:
    MyClass(const string& name, 
            const vector& data);
};
// Implementation:
MyClass::MyClass(const string& name, 
                const vector& data) {
    // ...
}

fn get_name(&self) -> String {
    self.name.clone()
}

string get_name() const {
    return name; // 'this' is implicit in C++
}

trait Shape {
    fn get_area(&self) -> f64;
}

class Shape {
public:
    virtual double get_area() const = 0;
};

impl Shape for Circle {
    fn get_area(&self) -> f64 {
        // ...
    }
}

class Circle : public Shape {
public:
    double get_area() const override {
        // ...
    }
};

fn generic_call(gen_shape: &T) {
    // ...
}

template
void generic_call(const T& gen_shape) {
    // ...
}

trait Shape {
    type InnerType;
    fn make_inner(&self) -> Self::InnerType;
}

// C++20 concepts approach
template
concept Shape = requires(T t) {
    typename T::InnerType;
    { t.make_inner() } -> 
        std::convertible_to;
};

enum MyShape {
    Circle(f64),
    Rectangle(f64, f64)
}

// Must specify contained types
std::variant my_shape;
// Uses integer tags rather than named variants

match shape {
    MyShape::Circle(r) => // ...,
    MyShape::Rectangle(w, h) => // ...
}

std::visit(overloaded {
    [](const Circle& c) { /* ... */ },
    [](const Rectangle& r) { /* ... */ }
}, my_shape);

// Manual allocation
let boxed = Box::new(value);
// Explicit non-trivial copies
let s = String::from("text");
let owned = borrowed.to_owned();
let cloned = original.clone();

// Manual allocation
auto* ptr = new T();
// Smart pointers
auto unique = std::make_unique();
auto shared = std::make_shared();
// Implicit non-trivial copies when passing by value
auto copy = original; // May implicitly copy

impl Drop for MyType {
    fn drop(&mut self) {
        // cleanup
    }
}

~MyType() {
    // cleanup
}

u8, u16, u32, u64, u128, usize

uint8_t, uint16_t, uint32_t, uint64_t, 
__uint128, uintptr_t/size_t

i8, i16, i32, i64, i128, isize

int8_t, int16_t, int32_t, int64_t, 
__int128, intptr_t/ptrdiff_t