Question

Ignoring the sanity of doing what I’m describing, does using the std::move() function improve construction time when used to pass an argument to a base constructor?

struct Bar {
    Bar(std::string);

    std::string _s;
}

struct Foo : public Bar {
    Foo(std::string);
}


struct Bar(std::string bs) : _s(std::move(bs)) {
    // 1
}

struct Foo(std::string fs) : Bar(std::move(fs)) {
    // 2
}

So in this example, does the move() used in Foo‘s constructor prevent an additional copy of the string being made?

And for clarification, does this design mean no attempt should be made to use bs and fs at points // 1 and // 2, but using _s would be safe in both places?

Answer 1

To find out, I recoded your example with a fake String class like so:

#include <iostream>

struct String
{
    String() {}
    String(const String&) {std::cout << "String(const String&)\n";}
    String& operator=(const String&)
        {std::cout << "String& operator=(const String&)\n"; return *this;}
    String(String&&) {std::cout << "String(String&&)\n";}
    String& operator=(String&&)
        {std::cout << "String& operator=(String&&)\n"; return *this;}
};

struct Bar {
    Bar(String);

    String _s;
};

struct Foo : public Bar {
    Foo(String);
};


Bar::Bar(String bs) : _s(std::move(bs)) {
    // 1
}

Foo::Foo(String fs) : Bar(std::move(fs)) {
    // 2
}
int main()
{
    Foo f{String()};
}

For me this prints out:

String(String&&)
String(String&&)

But if I remove this std::move from the Foo constructor the printout changes to:

String(const String&)
String(String&&)

So assuming a String(String&&) is faster than a String(const String&), the former is faster. Otherwise, not.

And for clarification, does this design mean no attempt should be made
to use bs and fs at points // 1 and // 2, but using _s would be safe
in both places?

Correct.