为什么在分配发生时调用Paramaterized构造函数？

Question

My question is for the last statement ie before return 0;

Why the parametrize constructor is being called when we are trying to assign an int value to an object.

My piece of code:

#include<iostream>
using namespace std;
class Test {
private:
    int i;
    public:
    Test(int s=0):i(s) {
            cout<<"param ctor: "<<i<<endl;
    }
};

int main()
{
    Test a;         //param ctor called
    Test b(5);      //param ctor called
    //b(a);         //error as we have not implemented copy ctor
    b=a;            //compiler provided assignment opr. called
    b=100;          //why param ctor called for this.??
    return 0;
}

OUTPUT:

  param ctor: 0
  param ctor: 5
  param ctor: 100

Answer 1

The reason is simple: every class X has a copy constructor (a consturctor taking X ) and a copy assignment operator (an assignment operator taking X ). If you don't declare these yourself, the compiler declares them for you implicitly. In some cases, they are defined as deleted (which means it is an error to use them), but they're always there.

So when you do this:

b = 100;

it's effectively translated to this:

b.operator=(100)

and the best matching overload of operator= is searched for. There's only one overload, actually: the implicitly declared copy-assignment operator Test& Test::operator=(const Test &) , so the compiler checks if it could convert the argument 100 to the assignment operator's parameter type const Test & . And it turns out that it can, thanks to the converting constructor Test::Test(int) , so that is what ends up called.

If you want to disable such behaviour, you can mark the constructor as explicit . This will prevent it from being used for implicit conversions, such as the one converting 100 to the type of the assignment operator's parameter.

Answer 2

Your constructor Test(int s=0) can be used as a conversion operator from int to Test . When b = 100 is evaluated, 100 is converted to Test , and than default assignment operator is invoked.

Answer 3

When you do b=100 what basically happens is that the compiler generates b.operator=(Test(100))

The constructor call you see is from that Test(100) .

If you make the constructor explicit then the compiler can't use the constructor to implicitly convert int values to Test objects, and you would get an error.

Answer 4

I am not sure on this but,

I came to know that compiler first searches for the matching function call for..

b=100;

ie an overloaded assignment operator function for class A which takes int as parameter and when It fails to find any suitable match it directs the call to parametrize constructor.

which in turn do the rest of the assignment job.

Please fill free to correct me if I am wrong or if I am missing any detail here.