Question

With this sample:

// test.cpp

#include <iostream>
#include <vector>
#include <utility>

using namespace std;

class mystring : public string { public:
    mystring() = default;

    mystring(const char* c) : string(c) {}

    mystring(mystring& m) : string(m) { cout << "Reference" << endl; }
    mystring(mystring const & m) : string(m) { cout << "Const reference" << endl; }
    mystring(mystring&& m) : string(move(m)) { cout << "Move" << endl; }
};

int main() {
    mystring a;

    vector<mystring> v{ a };
}

The ouput is:

$ g++ --version | grep "g++"
g++ (Ubuntu/Linaro 4.7.2-2ubuntu1) 4.7.2
$ g++ -std=c++11 -fno-elide-constructors test.cpp
$ ./a.out
Reference
Move
Const reference

But, if I initialice v with a r-value:

vector<mystring> v{"hello"};

the output is:

$ g++ -std=c++11 -fno-elide-constructors test.cpp
$ ./a.out
Const reference

that means, no copies. With a r-value:

vector <mystring> v{mystring()};

output:

$ g++ -std=c++11 -fno-elide-constructors test.cpp
$ ./a.out
Move
Move
Const reference

I don’t understand two things:

• Why with no-raw strings a second move (before the first copy/move) is performed?
• Why with raw strings, no copies of “mystring” are performed?

Answer 1

N.B. raw strings means something different in C++11, I think you mean string literal if you’re talking about "hello"

• Why with raw strings, no copies of “mystring” are performed?

Eh? There’s one copy, that’s why it prints Const Reference.

vector<mystring> v{"hello"};

The braced-init-list initializes the std::initializer_list<mystring> constructor parameter with a single element, which is constructed using the mystring(const char* c) constructor, then that element is copied into the vector using the mystring(const mystring&) constructor, which prints Const Reference. Pretty simple.

• Why with no-raw strings a second move (before the first copy/move) is performed?

How can the second move be before the first move?! 🙂

It is an implementation detail of how the initializer_list is constructed, which normally wouldn’t matter because the extra moves would be elided.

vector <mystring> v{mystring()};

This creates a temporary mystring using the default constructor, then creates std::initializer_list<mystring> with a single element, which is constructed using the mystring(mystring&&) constructor with the temporary as its argument. That move construction prints Move. There’s another move done internally, printing Move again. Then the initializer_list element is copied into the vector as before, printing Const Reference.

To answer your comment:

The extra move you see also happens in the first case, but in that case the type being moved is const char* so it doesn’t print Move i.e. the statement std::vector<mystring>{ expr }; can be thought of as:

auto tmp = expr;
mystring tmparray[] = { std::move(tmp) };
std::initializer_list<mystring> init_list( tmparray, 1 };
std::vector<mystring> v(init_list);

When expr is a (which is a non-const lvalue) creating tmp prints Reference then creating tmparray prints Movethen copying tmparray[0] into the vector prints Const Reference.

when expr is "hello" creating the elements of tmp doesn’t print anything, and creating tmparray calls mystring(const char*) which doesn’t print anything, then copying tmparray[0] into the vector prints Const Reference.

When expr is mystring() creating tmp prints Move then creating tmparray prints Move then copying tmparray[0] into the vector prints Const Reference

With a two element braced-init-list like { expr1, expr2 } it can be though of as:

auto tmp1 = expr1;
auto tmp2 = expr2;
mystring tmparray[] = { std::move(tmp1), std::move(tmp2) };
std::initializer_list<mystring> init_list( tmparray, 2 };
std::vector<mystring> v(init_list);

So if you use { "hello", mystring() } you get Move printed once by tmp2 and Move printed once by tmparray and Const Reference printed twice by the elements of v.

Of course normally all of this would be elided away, so there are no unnecessary copies or moves. -fno-elide-constructors is not really useful except for finding out what would happen, but doesn’t actually happen!