Is there any way to achieve move elision

Question

When running the following code:

struct Copy
{
    Copy() {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy(const Copy & other) {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy & operator=(const Copy & other) {std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this;}
    Copy(Copy && other) {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy & operator=(Copy && other) {std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this;}
    ~Copy() {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
};

char buffer[1024];

template <typename Type>
Type * push(Type value)
{
    return new(buffer) Type(std::move(value));
};

int main()
{
    push(Copy());

    return 0;
}

I get the following output:

Copy::Copy()
Copy::Copy(Copy &&)
Copy::~Copy()

Is there anyway to elide the move constructor?

I was hoping that with -O3, it would be constructed in place, but by my testing, that doesn't seem to be the case.

Answer 1

Is there anyway to elide the move constructor? [...] I was hoping that with -O3, it would be constructed in place,

Well, you're explicitly calling the move constructor... and the object is being constructed in-place in buffer. Why do you expect the move constructor call to be elided?

template <typename Type>
Type * push(Type value)
{ 
    //                 invokes `Type::Type(Type&&)`
    //                 vvvvvvvvvvvvvvvvvvvvvv
    return new(buffer) Type(std::move(value));
    //                      ^^^^^^^^^^^^^^^^
    //                      casts `value` to `Type&&`
};

---

Your question would make more sense if you were trying to construct Copy with a value of some other type. E.g.:

struct Copy
{
    Copy(int) { std::cout << "INT\n"; }
    // ... other ctors ...
};

template <typename Type, typename Arg>
Type * push(Arg x)
{
    return new(buffer) Type(std::move(x));
};

int main()
{
    push<Copy>(1);
}

The code above prints:

INT

No move/copy constructor is invoked.

live example on wandbox

Answer 2

I do not think you can do this. Because elision requires the compiler to have an intrinsic knowledge of where the objects are being constructed. And with that information, it can just avoid moves and copies and simply place the object where it needs to go. For example when you return something from the stack of one function back to another, the compiler can elide the move/copy.

But in your case placement new allows you to construct an object into any arbitrary buffer. And that buffer can really be anywhere, for example it can be on the stack (like in your case) or it can be allocated on the heap with new. So the compiler does not elide the move/copy here.

Strictly speaking, this can happen through some analysis of the code since the compiler already knows where the buffer is, but I doubt most compilers implement this.

---

Note note that you have declared an array of character pointers and not characters, so the buffer is more than 1024 bytes in length if that is what you were expecting

---

Note Also note that calling std::move explicitly can prevent elision

---

The best you can do in this case is make an in place constructor or a move constructor (as you have above) to construct that object into the buffer. An in place constructor would look something like this

template <typename... args>
void construct(std::in_place_t, Args&&... args) {
    new (buffer) Type{std::forward<Args>(args)...};
}

Answer 3

Use an emplace function with perfect argument forwarding. There are a few more things to say since you're about to embark on an adventure in placement new:

1. Use std::aligned_storage_t<> for the storage. It guarantees that your objects will be properly aligned.

2. Do read and use the return value of placement new. In simple cases it won't be different from the address you provide. However the standard allows it to be, and in complex class hierarchies it might be.

updated example:

#include <iostream>

struct Copy
{
    Copy() {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy(const Copy & other) {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy & operator=(const Copy & other) {std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this;}
    Copy(Copy && other) {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
    Copy & operator=(Copy && other) {std::cerr << __PRETTY_FUNCTION__ << std::endl; return *this;}
    ~Copy() {std::cerr << __PRETTY_FUNCTION__ << std::endl;}
};

std::aligned_storage_t<sizeof(Copy), alignof(Copy)> buffer[4];

template <typename Type, typename LegalStorage, typename...Args>
auto emplace(LegalStorage* buffer, Args&&...args) -> Type*
{

    return new(buffer) Type(std::forward<Args>(args)...);
};

int main()
{
    auto p1 = emplace<Copy>(buffer /* constructor arguments go here*/);
    auto p2 = emplace<Copy>(&buffer[1]/* constructor arguments go here*/);
    auto p3 = emplace<Copy>(buffer + 2/* constructor arguments go here*/);
    auto p4 = emplace<Copy>(buffer + 3/* constructor arguments go here*/);

    return 0;
}