Why is this move constructor not working

Question

I have the following code snippet. Does anyone know why this move constructor is not called for all cases in the main function? Why does it compile anyway? Assignment operator is private? Here the link: http://ideone.com/bZPnyY

#include <iostream>    
#include <vector>

class A{
public:
    A(int i){
        std::cout << "Constructor "<< i <<std::endl;
        for(int l = 0; l<i;l++){
            vec.push_back(l);
        }
    };

    A(A && ref): vec(std::move(ref.vec))
    {
       std::cout << "Move constructor"<<std::endl;
    }

    A & operator=(A && ref){
       if(this != &ref){
            vec = std::move(ref.vec);
       }
       std::cout << "Move assignment"<<std::endl;
       return *this;

    }

    std::vector<int> vec;

private:
    A(const A & ref);
    A(A & ref);
    A & operator=(A & ref);
};


A makeA(){
    A a(3);
    return a;
}

int main(){
    A b1(makeA()) ;
    A b2 = makeA();
    A b3 = A(3);
    A b4(A(3));
    std::cout << b4.vec[2] << std::endl;
};

Output:
Constructor 3
Constructor 3
Constructor 3
Constructor 3
2

Some Additions to the responses: When I add

 std::pair<int,A> a(3,A(3));

Then the move constructor gets called (so no NRVO hopefully)

Possible duplicate of [What are copy elision and return value optimization?](https://stackoverflow.com/questions/12953127/what-are-copy-elision-and-return-value-optimization) — underscore_d, Apr 17 '18 at 10:26

Andrew Tomazos · Accepted Answer · 2013-09-17T13:03:20.447

What you are seeing is called copy elision and is documented in 12.8.31.

A makeA(){
    A a(3);
    return a;
}

A b1(makeA()) ;
A b2 = makeA();

Here, the a local variable in makeA is emplaced directly in the return value of makeA, and in turn the temporary return value of makeA is emplaced directly in the storage of b1 and b2. (two copy elisions in a row)

A b3 = A(3);
A b4(A(3));

The temporary created with A(3) is constructed directly in b3 and b4. (one copy elision)

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the constructor selected for the copy/move operation and/or the destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.122 This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies):

This is the first part of the b1 and b2 case:

in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv- unqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function’s return value

This is the second part of the b1 and b2 case, as well as the whole part of the b3 and b4 case:

when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

There are also two other copy elision allowed cases to do with throwing and catching exceptions.

so it thought -> ``A b3 = A(3);`` --> A(3) is a temporary and so the move constructor will match? — Gabriel, Sep 17 '13 at 12:53
@Gabriel: Yes: a temporary is an *rvalue*, so can bind to an *rvalue* reference. In particular, it can be passed directly to a move constructor. — Mike Seymour, Sep 17 '13 at 13:10
Without copy elision it would be a move construction from a temporary. But, because of copy elision `b3` is constructed in-place the same as `A b3(3);` (at least with your compiler). — Andrew Tomazos, Sep 17 '13 at 13:11

score 1 · Answer 2 · edited May 23 '17 at 12:05

1

Nowhere does copy assignment operator even come in to play, don't confuse the presence of = token with assignment (that would be b1 = b2;, for instance).

A b1(makeA()) ;  // direct initialization
A b2 = makeA();  // copy-initialization
A b3 = A(3);     // copy-initialization
A b4(A(3));      // direct initialization

While copy-initiliazation to be well formed requires either copy- or move-constructor to be accessible, the compiler is free to elide it and initialize the object directly. There are subtle differences as to which constructor is eligible for each one, read more about this here.

If you're using GCC, try compiling with -fno-elide-constructors and see the difference.

edited May 23 '17 at 12:05

Community

1
1

answered Sep 17 '13 at 12:52

jrok

54,456
9
109
141

Red herring I think, there is no distinction between direct and copy initialization in the cases in the OP. – Andrew Tomazos Sep 17 '13 at 13:10
@user1131467 Not in OP's case, no, but I doesn't hurt to know. – jrok Sep 17 '13 at 13:12
Sure, it comes into play only with classes and only if "the cv-unqualified version of the source type is not the same class as, and not a derived class of, the class of the destination". In such cases there is a distinction between copy and direct initialization. – Andrew Tomazos Sep 17 '13 at 13:14
@user1131467 Also, with `explicit` constructors. – jrok Sep 17 '13 at 13:17
what do you mean with OP. (operator) ? sorry for the dumb question – Gabriel Sep 17 '13 at 15:43
1

@Gabriel OP = original post/poster. – jrok Sep 17 '13 at 15:44

Why is this move constructor not working

2 Answers2