Why does it work to return an int in a method which should return an object?

Question

Why does it work to return an int in the method B minus if the method is supposed to return an object of type B ?

#include <iostream>

class B
{
public:
    int a;
public:
    B(int i=0)
    {
        a=i;
    }
    B minus()
    {
        return (1-a);
    }
};

int main()
{
    B x(18);
    x = x.minus();
    std::cout << x.a << '\n';
    return 0;
}

Answer 1

A constructor with a single argument is considered a converting constructor . When an argument of type X is needed, and a type Y is given instead, the compiler will look for a converting constructor (or a type conversion operator) from Y to X. In this case it finds one, using your B(int) constructor. In essence, your return (1-a); is changed to return B(1-a); .

As mentioned in several other (also correct) answers, if you do not wish the constructor to be considered a converting constructor, you should preface it with the explicit keyword.

Answer 2

The line

return (1-a);

calls the implicit conversion constructor

B(int i=0)
{
    a=i;
}

So it's the same as writing

return B(1-a);

_{Note that the copy constructor is still generated, unless you delete it.}

---

If you want to avoid that, write

   explicit B(int i=0)
// ^^^^^^^^
   {
       a=i;
   }

this will actually force a user to write

return B(1-a);

Answer 3

This is happening because single-argument constructor can be used as an implicit cast from argument type to object type.

In your case, you have a constructor which accepts an argument of type int , so this constructor can be used to convert int into B .

To prevent those constructors to be used in conversion, you should mark constructor explicit - and it's a good practice to do so for all single-argument constructors, since in practice those implicit conversions are more often undesired than desired.