C++ Copy Constructor
I have a question about this syntax regarding initialization.

Quoted from http://en.wikipedia.org/wiki/Copy_constructor

    X a = X();     
// valid given X(const X& copy_from_me) but not valid given X(X& copy_from_me)               
// because the second wants a non-const X&               
// to create a, the compiler first creates a temporary by invoking the default constructor               
// of X, then uses the copy constructor to initialize a as a copy of that temporary.                
// However, for some compilers both the first and the second actually work.

    #include <iostream>

    class Foo
    {
    public:
    Foo()
    {
      std::cout << "Default Constructor called" << std::endl;
    }

    Foo(const Foo& other)
    {
    std::cout << "Copy constructor called" << std::endl;
    }

    Foo& operator=(const Foo& rhs)
    {
    std::cout << "Assignment operator called" << std::endl;
    }

    };

    int main()
    {
   
    Foo b = Foo(); //case 1:default 
    Foo c = Foo(a); //case 2: copy constructor
    }

Case 1:
Upon changing the parameter from const to non const in the copy constructor, case 1 won't compile as expected from wikipedia. However, when ran using the proper copy constructor, it only calls the default constructor. Why doesn't it also call the copy constructor? Is this an optimization done at compile-time?

Case 2:
The answer to case 1 will probably answer case 2 for me, but why does this only call the copy constructor once?


C++ Copy Constructor
===

I have a question about this syntax regarding initialization.

Quoted from http://en.wikipedia.org/wiki/Copy_constructor

    X a = X();     
// valid given X(const X& copy_from_me) but not valid given X(X& copy_from_me)               
// because the second wants a non-const X&               
// to create a, the compiler first creates a temporary by invoking the default constructor               
// of X, then uses the copy constructor to initialize a as a copy of that temporary.                
// However, for some compilers both the first and the second actually work.

    #include <iostream>

    class Foo
    {
    public:
    Foo()
    {
      std::cout << "Default Constructor called" << std::endl;
    }

    Foo(const Foo& other)
    {
    std::cout << "Copy constructor called" << std::endl;
    }

    Foo& operator=(const Foo& rhs)
    {
    std::cout << "Assignment operator called" << std::endl;
    }

    };

    int main()
    {
   
    Foo b = Foo(); //case 1:default 
    Foo c = Foo(a); //case 2: copy constructor
    }

Case 1:
Upon changing the parameter from const to non const in the copy constructor, case 1 won't compile as expected from wikipedia. However, when ran using the proper copy constructor, it only calls the default constructor. Why doesn't it also call the copy constructor? Is this an optimization done at compile-time?

Case 2:
The answer to case 1 will probably answer case 2 for me, but why does this only call the copy constructor once?

