Compiler Explorer

Source code

// Hypothetical Rust-like owner / borrow wrappers in C++
// This wraps types with data which is compiled away in release
// It is not possible to static_assert, so this uses static ints to count errors.
#include <utility>

// Statics to track errors. Ideally these would be static_asserts
// but they depen on Owner::has_been_moved which changes during compilation.
static int owner_already_moved = 0;
static int owner_use_after_move = 0;
static int owner_already_borrowed = 0;

// This method exists to ensure static errors are reported in compiler explorer
int get_fault_count() {
    return owner_already_moved + owner_use_after_move + owner_already_borrowed;
}

// Storage for ownership of a type T.
// Equivalent to mut usage in Rust
// Disallows move by value, instead ownership must be explicitly moved.
template <typename T>
struct Owner {
    Owner(T v) : value(v) {}
    Owner(Owner<T>& ov) = delete;
    Owner(Owner<T>&& ov) {
        if (ov.has_been_moved) {
            owner_already_moved++;
        }
        value = std::move(ov.value);
        ov.has_been_moved = true;
    }

T& operator*() {
        if (has_been_moved) {
            owner_use_after_move++;
        }
        return value;
    }

T value;
    bool has_been_moved{false};
};

// Safely borrow a value of type T
// Implicit constuction from Owner of same type to check borrow is safe
template <typename T>
struct Borrower {
    Borrower(Owner<T>& v) : value(v.value) {
        if (v.has_been_moved) {
            owner_already_borrowed++;
        }
    }

const T& operator*() const {
        return value;
    }

T value;
};

// Example of function borrowing a value, can only read const ref
static void use(Borrower<int> v) {
    (void)*v;
}

// Example of function taking ownership of value, can mutate via owner ref
static void use_mut(Owner<int> v) {
    *v = 5;
}

int main() {
    // Rather than just 'int', Owner<int> tracks the lifetime of the value
    Owner<int> x{3};

// Borrowing value before mutating causes no problems
    use(x);

// Mutating value passes ownership, has_been_moved set on original x
    use_mut(std::move(x));

// Uncomment for owner_already_borrowed = 1
    //use(x);

// Uncomment for owner_already_moved = 1
    //use_mut(std::move(x));

// Uncomment for another owner_already_borrowed++
    //Borrower<int> y = x;

//Uncomment for owner_use_after_move = 1;
    //return *x;
}