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>标题，因此无法修改。

如果我从A继承T（如错误消息所示），则f(ca)编译。但是后来没有为内置类型定义A（你不能从它们继承）。此外，这将提供我想避免的complex<double>到A<complex<double>>的所有功能。

这有什么解决方法吗？

Answer 1

解决＆＃34;对于内置类型＆＃34;不起作用问题，你可以使用模板专业化。 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) {}
};

如果继承是不可接受的，我所知道的唯一方法是定义以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; }
};

模板的类型转换

1 个答案: