2

The following code throws compilation error:

#include <stdio.h>

class Option
{
    Option() { printf("Option()\n"); };
public:
    explicit Option(const Option& other)
    {
        printf("Option(const)\n");
        *this = other;
    }

    explicit Option(Option& other)
    {
        printf("Option(non-const)\n");
        *this = other;
    }

    explicit Option(const int&)
    {
        printf("Option(value)\n");
    }
};

void foo(Option someval) {};

int main()
{
    int val = 1;
    Option x(val);
    foo(x);
}

The error thrown is:

main.cpp:31:10: error: no matching function for call to ‘Option::Option(Option&)’
     foo(x);
          ^
main.cpp:5:5: note: candidate: ‘Option::Option()’
     Option() { printf("Option()\n"); };
     ^~~~~~
main.cpp:5:5: note:   candidate expects 0 arguments, 1 provided
main.cpp:25:6: note:   initializing argument 1 of ‘void foo(Option)’
 void foo(Option someval)

The error goes away if I remove the explicit keyword from explicit Option(const Option& other)

Can someone explain to me what is the cause of compilation error? Also, if there a difference between explicit Option(const Option& other) and explicit Option(Option& other)?

Saksham Jain
  • 537
  • 3
  • 14
  • 1
    It is typical to see an `explicit` constructor to protect against unwanted implicit conversions, but an `explicit` copy constructor is very odd. – Cory Kramer Mar 27 '20 at 23:00
  • 1
    For the explicit keyword [there](https://stackoverflow.com/questions/121162/what-does-the-explicit-keyword-mean) is a good description. In this particular case, the explicit keyword prevents copying x when you call the foo function. [Here](https://stackoverflow.com/questions/36310944/usage-of-explicit-keyword-for-constructors) is a good discussion about when to use explicit constructors. The difference between the two copy ctor is with the non const version, you cannot copy const objects. In general the const version of copy constructor is enough, you don't have to specify both of them. – János Benjamin Antal Mar 27 '20 at 23:05
  • Inside the function `explicit Option(const Option& other);`, what is `*this = other;` supposed to call? – Ted Lyngmo Mar 27 '20 at 23:06
  • @TedLyngmo it calls the [implicitly-declared copy assignment operator](https://en.cppreference.com/w/cpp/language/copy_assignment). – János Benjamin Antal Mar 27 '20 at 23:09
  • @JánosBenjaminAntal There is none - it's implicitly deleted since there's a user defined copy constructor. – Ted Lyngmo Mar 27 '20 at 23:09
  • @TedLyngmo if you check the page I linked, there is no mention that the copy constructor prevents the generation of copy assignment operator. Also check Item 17 in Modern Effective C++ from Scott Meyers, it explain this further. – János Benjamin Antal Mar 27 '20 at 23:20
  • @JánosBenjaminAntal From _Item 17:_ "_[...] C++11 deprecates the automatic generation of copy operations for classes declaring copy operations or a destructor_". Clear enough? – Ted Lyngmo Mar 27 '20 at 23:30
  • Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/210471/discussion-between-janos-benjamin-antal-and-ted-lyngmo). – János Benjamin Antal Mar 27 '20 at 23:31
  • Just to clarify things: it just deprecated, not reomved. It compiles with `-Wall -Werror -pedantic` with gcc 9.3 and clang 10.0.0. With clang, you need `-Weverything` beside `-Werror` to make the compilation fail – János Benjamin Antal Mar 27 '20 at 23:45

1 Answers1

2

In the call foo(x), a new Option has to be created, which will become someVal during the execution of foo's body. That is, x needs to be copied into someVal. The compiler essentially tries to initialize Option someVal(x); (trying first Option(Option&), then Option(Option const&)), but it cannot, because you said that both of those constructors are explicit and should not be implicitly called. With C++17, you can explicitly insert the missing constructor call to make it work: foo(Option(x)). Before C++17, it is impossible to call foo, because the compiler will keep trying to insert calls to a constructor to Option but none are available for insertion.

In the language of the standard, a function call like foo(x) calls for the parameter someVal to be copy-initialized from x. Copy-initializing an object of a certain class from an object of that class or a derived class considers only the converting constructors of that destination class. "Converting constructor" is just a fancy name for "constructor that isn't explicit". The best constructor out of these is then selected by normal overload resolution. Since none of your constructors are not explicit, this always fails and foo is uncallable before C++17. Since C++17, when the argument is a prvalue (as in foo(Option(x))), the requirement to call a constructor can be sidestepped and foo becomes callable.

To your side question:

Also, if there a difference between explicit Option(const Option& other) and explicit Option(Option& other)?

Of course: the first one promises it will not modify its argument and the second one doesn't. You already know that they can be defined to do different things, and overload resolution will prefer one over the other, depending on context:

Option x(1);
Option const y(2);
Option a(x); // calls Option(Option&) if available, which may modify x; calls Option(Option const&) if not, which shouldn't modify x
Option b(y); // must call Option(Option const&) because that promises not to modify y; cannot call Option(Option&) because it may modify y
HTNW
  • 27,182
  • 1
  • 32
  • 60