CODEWITHSUNDEEP
c++11constructorcopymoveimplicit
benj
benj

Reputation: 13

C++11 implicit copy constructor while implementing explicitly a constructor

I ran into a problem. I implemented a constructor for a class, but why are implicitly generated the other constructors, like the copy one? I thought, that if I define a constructor explicitly, then the compiler doesn't generates implicitly other ones. I'm really hoping, that this a VC++ specific thing, and that this code doesn't conforms to ISO:IEC C++11:

class Foo
{
    int bar;

public:
    Foo(int&& arg) : bar(arg) { cout << "RConstruction" << endl; }
};

int main(int, const char*[])
{
    Foo f = Foo(42);

    /* Create unused temporary on the stack */
    Foo::Foo(f); /* calling Foo::Foo(const Foo&): this shouldn't work... */

    return (0);
}

Please keep in mind, that this is a sample code, created exactly for this situation, for demonstration purposes, I expect answers only that strictly relate to this question.

Upvotes: 1

Views: 70

Answers (2)

Jonathan Wakely
Jonathan Wakely

Reputation: 171293

That's not a move constructor, so it doesn't suppress any implicit ones.

Just like Foo(const int&) isn't a copy constructor, Foo(int&&) isn't a move constructor, it's just a constructor taking an rvalue reference.

A move constructor looks like one of:

Foo(Foo&&)
Foo(const Foo&&)
Foo(volatile Foo&&)
Foo(const volatile Foo&&)

I thought, that if I define a constructor explicitly, then the compiler doesn't generates implicitly other ones.

If you define any constructor the compiler doesn't generate the default constructor, but it still generates the others. Define the as deleted if you don't want them:

Foo(const Foo&) = delete;
Foo& operator=(const Foo&) = delete;

Upvotes: 4

quantdev
quantdev

Reputation: 23793

You did not declare a move constructor, but a regular constructor : no implicit constructor will be deleted.

A move constructor would be of the form Foo(Foo&& arg) (with any cv-qualifier on the argument)

Also note that this statement is not valid C++ :

 Foo::Foo(f);

Maybe you meant :

Foo g = Foo(f);

Upvotes: 3

Related Questions