Remember my suggestion from “The Superconstructing Super Elider” (2018-03-29) that maybe our containers ought to have a “directly-emplacing, never-moving” facility like this?

template<class F> T& emplace_back_with_result_of(const F& factory_fn) { assert(size_ < Cap); T *p = new ((void*)buffer_[size_]) T(factory_fn()); size_ += 1; return *p; }

Well, today I learned that Andrzej Krzemieński knows how to get this effect without modifying the container. The trick is that when we write

new (voidptr) T(some_value)

we aren’t just invoking T ’s constructor; we might also be invoking some implicit conversion on some_value . And we can overload the behavior of that implicit conversion! Thus:

template<class F> class with_result_of_t { F&& fun; public: using T = decltype(std::declval<F&&>()()); explicit with_result_of_t(F&& f) : fun(std::forward<F>(f)) {} operator T() { return fun(); } }; template<class F> inline with_result_of_t<F> with_result_of(F&& f) { return with_result_of_t<F>(std::forward<F>(f)); }

Notice the overloaded operator T . Now we can write:

std::vector<Widget> vec; vec.emplace_back(Widget::make()); // A vec.emplace_back(with_result_of([]{ return Widget::make(); })); // B

Line A produces an extra move-construction of Widget . Line B constructs the return value of Widget::make() directly into its final place in the vector; there is no extra movement at all.

This mechanism is super clever. But I must note that it is not 100% foolproof. It works more or less because overload resolution finds Widget(Widget) to be the best match for construction from with_result_of_t<F> . If Widget were to have a constructor that were a better match for with_result_of_t<F> , then the mechanism would fail:

struct Widget { int value_; explicit Widget(int i) : value_(i) { puts(" construct from int"); } Widget(Widget&&) noexcept { puts(" move-ctor"); } ~Widget() { puts(" destructor"); }; static Widget make() { return Widget(42); } template<class U> explicit Widget(U&&) : value_(0) { printf(" %s -- OOPS!

", __PRETTY_FUNCTION__); } };

So this trick does have at least one sharp edge. But it’s pretty cool that you can get this effect if you need it, even without abandoning the standard containers!