c++ - 模板的类型转换

Question

我有一个包装类模板，并希望隐式转换为包装类型以便使用现有的库函数:

#include <complex>

double f(double x) { return 1.; }

template <typename T>
std::complex<T> f(std::complex<T> x) { return std::complex<T>(); }

template <typename T>
class A {
  T _x;
public:
  A(const T& x) : _x(x) {}
  operator T() { return _x; }
};

int main() {
  A<double> da(1.);
  A<std::complex<double>> ca({1.,1.});
  f(da); // OK                                                                                                                  
  f(ca); // error                                                                                                               
  return 1;
}

f(std::complex<T>)不用于 f(ca)因为在模板参数推导期间不考虑隐式转换(请参阅生成的错误消息。here)。

在真实代码中f(...)被库函数取代，例如来自 <complex> header ，因此无法修改。

如果我继承A来自 T (如错误消息所建议)然后 f(ca)编译。但是然后 A没有为内置类型定义(您不能从它们继承)。此外，这将提供 complex<double> 的所有功能。至 A<complex<double>>我想避免这种情况。

有什么解决方法吗？

Answer 1

要解决“不适用于内置类型”的问题，您可以使用模板特化。 std::complex<>版本使用继承。

template <typename T>
class A {
  T _x;
public:
  A(const T& x) : _x(x) {}
  operator const T &() const { return _x; }
  operator T &() { return _x; }
};

template <typename D>
class A<std::complex<D>> : public std::complex<D> {
  typedef std::complex<D> T;
public:
  A(const T& x) : T(x) {}
};

如果继承是 Not Acceptable ，我知道的唯一方法是定义采用 A<> 的函数作为论据。但是，您可以通过在 A<> 中定义函数来简化任务。本身，从而利用模板参数的简化语法，以及函数调用调用的参数依赖查找。

template <typename T>
class A {
  T _x;
  friend A f(A x) { return f(x._x); }
public:
  A(const T& x) : _x(x) {}
  operator const T &() const { return _x; }
  operator T &() { return _x; }
};