Designing a Mini Library That Brings Rust-Like Safety to Modern C++

Rust is known for its unique safety model based on Ownership, Borrowing, and Mutable Borrowing, combined with strong guarantees against memory errors and data races in safe code.

C++, on the other hand, although powerful and flexible, does not provide these guarantees natively. However, because C++ is highly expressive and allows deep control over program design, we can build safety models through careful API design, without changing the language itself.

In this article, we present a practical, lightweight model for creating a mini library that brings a Rust-like safety style to C++. This model is small, understandable, and can be used immediately in modern C++ codebases.

We call the library:

safecpp

It is a simple header-only library that introduces clear rules for ownership, borrowing, and safe concurrency.

1. Why Use This Approach?

The goal is not to recreate Rust’s compiler-level guarantees—because Rust’s Borrow Checker is deeply integrated into the language.

Instead, the aim is to achieve:

1. More predictable memory management

2. Clear separation between ownership and borrowing

3. Safer mutation patterns

4. Thread-safe state without data races

5. Cleaner APIs that reveal intent

This approach dramatically reduces errors while keeping full compatibility with Modern C++ (C++17/20/23/26).

2. Core Components of the Library

safecpp contains three essential parts:

A) owner<T> — Explicit and Unique Ownership

A thin wrapper over std::unique_ptr<T> with a clearer semantic name.

B) borrow<T> and borrow_mut<T> — Borrowing Models

They mimic Rust’s &T and &mut T at the API level.

C) ts_value<T> — Safe Concurrent Value

A synchronized wrapper that exposes data only through controlled read and write operations.

3. Library Design

3.1. File: safecpp/memory.hpp

Defines ownership and borrowing:

#pragma once
#include <memory>
#include <utility>
#include <cassert>

namespace safecpp {

// Unique ownership
template <typename T>
class owner {
public:
    owner() = default;
    explicit owner(T* ptr) noexcept : ptr_(ptr) {}

    owner(owner&&) noexcept = default;
    owner& operator=(owner&&) noexcept = default;

    owner(const owner&) = delete;
    owner& operator=(const owner&) = delete;

    T* get() noexcept { return ptr_.get(); }
    const T* get() const noexcept { return ptr_.get(); }

    T& operator*() noexcept { return *ptr_; }
    const T& operator*() const noexcept { return *ptr_; }

private:
    std::unique_ptr<T> ptr_;
};

template <typename T, typename... Args>
owner<T> make_owner(Args&&... args) {
    return owner<T>{new T(std::forward<Args>(args)...)};
}

// Immutable borrow
template <typename T>
class borrow {
public:
    borrow(const T& ref) noexcept : ptr_(&ref) {}
    const T& get() const noexcept { return *ptr_; }

private:
    const T* ptr_;
};

// Mutable borrow
template <typename T>
class borrow_mut {
public:
    borrow_mut(T& ref) noexcept : ptr_(&ref) {}
    T& get() const noexcept { return *ptr_; }

private:
    T* ptr_;
};

} // namespace safecpp

3.2. File: safecpp/concurrency.hpp

A simple thread-safe wrapper:

#pragma once
#include <mutex>
#include <functional>

namespace safecpp {

template <typename T, typename Mutex = std::mutex>
class ts_value {
public:
    template <typename... Args>
    explicit ts_value(Args&&... args)
        : value_(std::forward<Args>(args)...) {}

    template <typename F>
    auto read(F&& f) const {
        std::scoped_lock lock(m_);
        return std::invoke(std::forward<F>(f), value_);
    }

    template <typename F>
    auto write(F&& f) {
        std::scoped_lock lock(m_);
        return std::invoke(std::forward<F>(f), value_);
    }

private:
    mutable Mutex m_;
    T value_;
};

} // namespace safecpp

4. Full Practical Example

This example combines ownership, borrowing, and thread-safe state:

#include "safecpp/memory.hpp"
#include "safecpp/concurrency.hpp"

#include <string>
#include <thread>
#include <vector>
#include <iostream>

using namespace safecpp;

struct Stats {
    int requests = 0;
    int errors = 0;
};

void process_request(ts_value<Stats>& stats, borrow<const std::string> user) {
    stats.write([&](Stats& s) {
        ++s.requests;
        if (user.get() == "bad") {
            ++s.errors;
        }
    });
}

int main() {
    auto user = make_owner<std::string>("Ayman");
    ts_value<Stats> stats{};

    std::vector<std::thread> workers;

    for (int i = 0; i < 4; ++i) {
        workers.emplace_back([&] {
            for (int j = 0; j < 1000; ++j) {
                process_request(stats, borrow<const std::string>(*user));
            }
        });
    }

    for (auto& t : workers) t.join();

    stats.read([](const Stats& s) {
        std::cout << "requests = " << s.requests
                  << ", errors = " << s.errors << "\n";
    });
}

5. Why This Design Works

This mini library does not enforce Rust’s guarantees, but it achieves several strong goals:

1. Clear ownership semantics

   • owner<T> → sole resource owner

   • borrow<T> → read-only borrow

   • borrow_mut<T> → write-only borrow without ownership

2. Reduced pointer-related errors

3. Safe concurrent state All shared data goes through ts_value<T> with strict access rules.

4. Excellent compatibility with Modern C++ Works naturally with:

   • C++20 Concepts

   • Ranges

   • Coroutines

   • Modules

5. Works with sanitizers ASan, MSan, TSan improve safety even further.

6. Conclusion

With this simple design, C++ developers can bring a Rust-like mindset to their projects:

• safer memory management

• intentional ownership and borrowing

• protected shared state

• fewer logic mistakes

• clearer API contracts

All achieved without changing the C++ language, and without any compiler extensions.

This is an excellent foundation for building larger frameworks—or for including as part of a Modern C++ Encyclopedia or teaching material.