Indeed, thanks Josh, this is fixed now.

template

should be

template

(i.e., “typename” instead of “template”).

Sure, that would work in C++17, but my target right now is C++14. I hope to be able to “migrate” soon.

Is there any way to insert nicely formatted source code in Disqus? I just noticed it changed some of my T_ to t_ for some reason!

I see your point, interesting! Thanks for sharing.
Did you consider trying to remove the makeMyClass function, by using C++17 template argument deduction for class constructors?

I would like to avoid copy construction at all cost. So I want a member variable that, depending on the constructor, is either a string or a string&.

After many hours searching and experimenting, I think I’ve found the answer: universal references. I never understood them until now! Apparently, when using T&&, if T is used for template deduction, it becomes either an lvalue *reference* or an rvalue. I think this was exactly their point.

For example:
struct Large
{
Large() = default;
Large(const Large&) { cout << "copy ctor" << endl; };
Large(Large&&) { cout << "move ctor" << endl; };
};

template
class MyClass
{
public:
template
MyClass(T_&& x) : x_{std::forward(x)} {}

T x_;
};

template
auto makeMyClass(T&& f) -> MyClass
{
return {std::forward(f)};
}

Large get_Large()
{
return Large();
}

int main()
{
cout << "Should call move ctor:" << endl;
auto A = makeMyClass(get_Large());

cout << "nShould not call either copy ctor or move dtor:" << endl;
Large b;
auto B = makeMyClass(b);

return 0;
}

So the above NEVER calls a copy ctor of Large, which is what I wanted to avoid. And it's fine in both cases: in the first, it moves from get_Large(), and in the second it just stores a reference to b, but that's fine, since b is alive an well (it's an lvalue) and won't be destructed until B is.

How would you see the members of MyClass? A std::string an a std::string const&, or something like a variant?

Suppose I wanted to save, inside MyClass, either a copy if T is an rvalue (and move from it!), or just a reference if I’m passed an lvalue (since I know it still exists).

For example:

MyClass A(get_string()) <- moves into a member variable of type std::string
std::string s = "hello world";
MyClass A(s) <- copies into a member variable of type std::string const&

Is there a way to do the same without a macro?