Question

I’m changing an old routine that used to take an integer parameter so that it now takes a const reference to an object. I was hoping that the compiler would tell me where the function is called from (because the parameter type is wrong), but the object has a constructor that takes an integer, so rather than failing, the compiler creates a temporary object, passing it the integer, and passes a reference to that to the routine. Sample code:

class thing {   public:     thing( int x ) {         printf( 'Creating a thing(%d)\n', x );     } };  class X {   public:     X( const thing &t ) {         printf( 'Creating an X from a thing\n' );     } };   int main( int, char ** ) {     thing a_thing( 5 );     X an_x( 6 );     return 1; } 

I want the X an_x( 6 ) line to not compile, because there is no X constructor that takes an int. But it does compile, and the output looks like:

Creating a thing(5) Creating a thing(6) Creating an X from a thing 

How can I keep the thing( int ) constructor, but disallow the temporary object?

Answer 1

Use the explicit keyword in the thing constructor.

class thing { public:     explicit thing( int x ) {         printf( 'Creating a thing(%d)\n', x );     } }; 

This will prevent the compiler from implicitly calling the thing constructor when it finds an integer.