通过模板化运算符重载将 std::complex<T> 乘以双倍

Question

假设T operator*(const T &t, double d) 已定义，我想将std::complex<T> 与double 进行多重播放。由于我需要为 3 种不同类型 T 执行此操作，因此我尝试为操作员编写模板函数。这是T=float 的示例。

#include <iostream>
#include <complex>

template <typename T>
std::complex<T> operator*(const std::complex<T> &cd, double d) {
    return std::complex<T>(cd.real() * d, cd.imag());
}

int main() {
    std::complex<float> cf(1.0, 1.0);
    std::complex<double> cd(1.0, 1.0);
    double d = 2.0;

    std::cout << cf * d << std::endl;
    std::cout << cd * d << std::endl;
}

这会导致编译器错误

error: ambiguous overload for ‘operator*’ (operand types are ‘std::complex<double>’ and ‘double’)

原因很清楚，因为对于T=double，我的重载与<complex> 中的实现发生冲突。首先将右侧转换为T（即上例中的cf * float(d)）不是一种选择，因为这会给我的一些数据类型带来很大的开销。

有什么方法可以告诉编译器它应该忽略我对T=double 的重载？

Answer 1

有什么方法可以告诉编译器它应该忽略我的 T=double 重载？

您可能会使用 SFINAE：

template <typename T>
std::enable_if_t<!std::is_same<double, T>::value, std::complex<T>>
operator*(const std::complex<T> &cd, double d) {
    return std::complex<T>(cd.real() * d, cd.imag());
}

但您的实现与常规 operator* 不一致。

更安全的方法是引入您自己的类型来包装double，例如：

struct MyWrapper { double d; };

template <typename T>
std::complex<T> operator*(const std::complex<T> &cd, MyWrapper d) {
    return std::complex<T>(cd.real() * d.d, cd.imag());
}

Answer 2

std::complex 已经定义了一个operator *，格式为

template< class T >
std::complex<T> operator*( const std::complex<T>& lhs, const T& rhs);

这与您自己的 operator * 冲突，因为这两个函数都解析为采用 std::complex<double> 和 double。

这意味着您实际上只需要为std::vector<float> 和double 定义一个operator *，这样您就可以将您的重载更改为

std::complex<float> operator*(const std::complex<float> &cd, double d) {
    return std::complex<float>(cd.real() * d, cd.imag());
}

然后

std::cout << cf * d << std::endl;
std::cout << cd * d << std::endl;

会起作用的。

如果您想将重载保留为模板函数，您可以使用 SFINAE 使其无法在您有 std::complex<double> 的情况下通过使用

template <typename T, std::enable_if_t<!std::is_same_v<double, T>, bool> = true>
std::complex<T> operator*(const std::complex<T> &cd, double d) {
    return std::complex<T>(cd.real() * d, cd.imag());
}