Error: no matching function for call to 'A::A(A)'

Question

I have coded a very basic class

class A
{
 int n;
 public:
 A(int& val){val=n;}
 A(const int& val=0){n=val;}
 A(A& val){n=val.n;}//work without this constructor
};

int main()
{
 A a=3;//want to call A::A(const int&)
 return 0;
}

I don't want to create a constructor with a copy from an instance of A (for a future use) What's wrong with this simple code?

Error message :

...\main.cpp||In function 'int main()':|
...\main.cpp|16|error: no matching function for call to 'A::A(A)'|
...\main.cpp|16|note: candidates are:|
...\main.cpp|11|note: A::A(A&)|
...\main.cpp|11|note:   no known conversion for argument 1 from 'A' to 'A&'|
...\main.cpp|10|note: A::A(const int&)|
...\main.cpp|10|note:   no known conversion for argument 1 from 'A' to 'const int&'|
...\main.cpp|9|note: A::A(int&)|
...\main.cpp|9|note:   no known conversion for argument 1 from 'A' to 'int&'|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

It seems 3 is considered as an instance of A?

If I add A(const A& val){n=val.n;} the constructor A(const int&) is chosen.

What can I do to compile successfully without A(const A& val)?

Answer 1

The issue is your copy constructor: A(A& val) { n=val.n; }.

Given this line A a = 3; one possibility is to use A a = A(3) which in turn will use the copy constructor. However, it is against the standard to bind a temporary to non-const. A proper copy constructor will solve the problem.

Example Code

#include <iostream>

class A
{
    int n;

public:
    A(int& val) : n(val) { std::cout << "A(int&)\n"; }
    A(const int& val=0) : n(val) { std::cout << "A(const int&)\n"; }
    A(const A& val) : n(val.n) { std::cout << "A(const A&)\n"; }
};

int main()
{
    A a = 3;
    return 0;
}

Example Output

A(const int&)

Live Example

Note:

• The above code makes proper use of the initialization lists
• The output shows the copy constructor is not actually invoked

Answer 2

The line of code;

A a = 3;

Is using copy initialisation to work. For that to work, a copy of A is needed and is duly made. You have two constructors taking an int as an argument (and neither are explicit).

The copy cannot bind to A(A& val) because normal references don't bind to temporary values.

Possible solutions, direct initialisation;

 A a { 3 };

Add or change the copy constructor to a move constructor;

A(A&& val);

Add a const to the copy constructor (although this is not what you wanted, but it does work);

A(A const& val);

---

Note both clang and g++ reject the original code correctly, but VC++ accepts it.

Answer 3

In this statement

A a=3;//want to call A::A(const int&)

there is created a temporary object of type A using constructor

A(const int& val=0){n=val;}

However a temporary object can be bound to a constant reference. So the compiler need that the copy constructor

A( const A& val){n=val.n;}//work without this constructor
   ^^^^^

would be at least accessible (even if it will not be called due to the copy constructor elision). But the class does not has this constructor and the compiler issues an error.

On the other hand when you comment this constructor then the compiler itself implicitly defines this constructor and the code is compiled.

Take into account that this constructor

A(int& val){val=n;}
            ^^^^^^

does not make sense.:)