Clarification on when constructor / Assignment Operator is used

[mpark4656]

I would like to know exactly which function is invoked when you declare an object in this fashion:

Object newObjectName = existingObject;

I've always thought that the above statement used Copy constructor. Some student in my class claimed that the above statement is a 2-step process - Default Constructor for creating newObjectName and then assignment operator to copy the value of existingObject. Is that true?

I created a test code below. When I delete the default assignment operator (Change default to delete), I do not get an error on Line 35, which tells me that Line 35 does not utilize the assignment operator. But if I delete the default copy constructor, I do get an error on Line 35. This test tells me that the copy constructor is being used for Line 35, but I'd like to know what you think.

Thank you.

//#include "std_lib_facilities.h"

#include <iostream>

class Foo
{
public:
    // Default Constructor / One Parameter Constructor
    Foo( int val = 0 ): _value{ val } {}

    // Default Copy Constructor
    Foo( const Foo &rhs ) = default;

    // Default assignment operator
    Foo & operator= ( const Foo &rhs ) = default;

    // Accessor
    int get_value() const
    { return _value; }

private:
    int _value;
};

std::ostream & operator<< ( std::ostream &out , const Foo &x )
{
    out << x.get_value();
    return out;
}

int main()
{
    Foo foo1 { 5 };     // This should invoke the one parameter constructor

    Foo foo2 = foo1;    // Does this invoke copy constructor or Default Constructor->Assignment Operator???

    Foo foo3 {};        // This should invoke the default constructor

    foo3 = foo1;        // This should invoke the assignment operator

    Foo foo4 { foo1 };   // This should invoke the default copy constructor

    // Check that all instances of foo have the same value
    std::cout << foo1 << " " << foo2 << " " << foo3 << " " << foo4;

    return 0;
}

[JLBorges]

The copy constructor

The copy constructor is called whenever an object is initialized from another object of the same type (unless overload resolution selects the move constructor as a better match), which includes

direct initialization T a(b);, where b is of type T;

copy initialization, including by-value function parameter passing, by-value returns, exception throwing and handling, and T a = b;, where b is of type T or derived from T.
http://en.cppreference.com/w/cpp/language/copy_constructor

[mpark4656]

Cool. Thank you!