C ++模板：没有匹配的调用函数

Question

I cannot understand why this program fails to compile both with g++ 7.3 or clang++ 5.0 using -std=c++14.

A can be initialized from a const int as shown. A const reference to A can also be create from a const int but call to f(const A &) with a const int fails. Why?

#include <iostream>

struct V {
  int i;
  template <class T>
  V(const T &t) : i{t} {}
};

struct A {
  int i;
  A(V v) : i{v.i} {}
};

void f(const A &) {}

int main() {
  const auto i = 42;
  const A a1{i};              // OK
  std::cout << a1.i << '\n';  // 42
  const A &a2 = A{i};         // OK
  std::cout << a2.i << '\n';  // 42
  f(i);                       // no matching function for call to 'f'
  return 0;
}

Answer 1

Converting i to an A for the purpose of the function call will require two user defined conversions ( int -> V -> A ). The standard places a hard limit of a single user defined conversion on each implicit conversion sequence.

The same would happen if you were to try and bind a2 to i "directly". So you need to do a functional style cast ( A{i} ) when giving an argument to f as well.

Answer 2

Given f(i); , copy initialization is applied. And i (with type const int ) needs to be converted to A , two user-defined conversions are required; from const int to V , and from V to A . But only one user-defined conversion is allowed in one implicit conversion sequence.

Bot const A a1{i}; and const A &a2 = A{i}; are direct initialization , only one implicit conversion from i (with type const int ) to the argument of A 's constructor (ie V ) is required, so they work fine.

Note the difference between copy initialization and direct initialization,

In addition, the implicit conversion in copy-initialization must produce T directly from the initializer, while, eg direct-initialization expects an implicit conversion from the initializer to an argument of T's constructor.

As a workaround, you can perform explicit conversion on i before passing it to f() .

Answer 3

You need two consecutive implicit type conversion here however C++ can do single conversion implicitley for you. If you want to let the compiler to generate the correct typed code for you, use template for the function f like following.

template <typename T>
void f(const T & x) { std::cout << x << std::endl;}

The reason why you need two type conversion is because of having only one constructor which takes type V in the struct. If you want to get rid of two type conversion as a second solution, you can add another constructor which takes int as a parameter like following

struct A {
    int i;
    A(V v) : i{v.i} {}
    A(int theI) : i{theI} { }
};

Answer 4

Two user defined conversions are not supported in copy initialization. Simple work around to the problem is to wrap i with A while passing to funtion f with f(A(i))