I'm bored of all the Rust vs. C++ comparisons, when the C++ code is something you simply don't write with modern and idiomatic C++11 and C++14. Not that you could not write it, but seeing this would not pass me reviewing the code.

The add_one example, as simple as it is, is a horrible example.

Why not embrace value semantics and write it like:

    int add_one(int x) { return x + 1; }

There is simply no need for pointers or references. Write simple code first. To the heap allocation example:

    auto x = std::make_unique<int>(5);

Even if this is a silly example, just say no to unnecessary heap allocation. Why not:

    int x{5};

Now to the lifted example:

    void add_one(std::unique_ptr<int> num) {
        * num += 1;
    }

This mixes operations with lifetime management. The add_one function does not need to care about ownership. And it does not need to take ownership of its argument. Instead on the call site do:

    int add_one(int); // from above

    auto p = make_unique(5);
    auto six = add_one(*p); // <-

There are valid points in the blog post and I know that most snippets are meant as examples. But as someone writing C++14 you can't win me with those kinds of posts, even though I'm having a fun time playing with Rust in my spare time.

For more about modern practices see: http://klmr.me/slides/modern-cpp/

Also see Howard Hinnant's unique_ptr tutorial: http://howardhinnant.github.io/unique_ptr03.html