Howard Hinnant

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

C++ has way way better ways to handle this. What you do instead is a std::vector with an allocator that has a fixed-size chunk of memory to cover your common, small case and falls back to malloc if the size becomes too large to fit into the internal allocation.

Then your VLA is stack allocated when small and heap allocated when large and works everywhere, even as a return value or other cases where alloca would fail.

Example: https://howardhinnant.github.io/stack_alloc.html