模板重载解析和隐式转换

Question

想尝试一下，我最近决定尝试在 C++ 中实现一个模板化的复数类。作为参考，我使用了 C++ 11 标准库实现，我发现该实现与我的实现之间存在差异。它指的是他们如何在他们的类中重载 += 运算符。

我基本上只有一个 += 方法，可以同时处理 Complex<T> += Complex<U> 和 Complex<T> += whatever other type that implicitly converts to T and thus Complex<T>。为了澄清，这里是类声明：

template <typename T>
class Complex {
    public:
        constexpr Complex (T=T(), T=T()); // added for clarity

        template <typename U>
        constexpr Complex (const Complex <U>&);
        template <typename U>
        constexpr Complex (Complex <U>&&);
        template <typename U>
        Complex <T>& operator= (const Complex <U>&);
        template <typename U>
        Complex <T>& operator= (Complex <U>&&);

        Complex& operator+= (const Complex<T>&);
        Complex& operator-= (const Complex<T>&);
        Complex& operator*= (const Complex<T>&); 
        Complex& operator/= (const Complex<T>&); 
        Complex& operator++ (void);
        Complex operator++ (int);
        Complex& operator-- (void);
        Complex operator-- (int);

        std::string to_string (void) const;

        constexpr T real (void);
        constexpr T img (void);
        void real (const T&);
        void img (const T&);

    private:
        T _m_real, _m_img;
        template <typename U>
        friend class Complex;
};

但是在标准库实现中，它们为operator+= 使用了2 个重载，一个采用Complex<U>，另一个采用T。就我测试而言，这两种实现似乎都产生了相同的行为：任何两个复杂类型之间的加法，或者一个复杂类型和另一个隐式转换为复杂内部类型的类型之间的加法。

所以，我的问题是：除了优化临时复合体以及如果所有其他复合体类型都隐式转换为 Complex 时为什么要使用嵌套 template <typename U> 之外，还有什么理由需要单独的 operator+=(T)？

Answer 1

struct Foo {
  operator int()const {
    return 7;
  }
};`

您将遇到递增Foo 的问题，因为只会调用一个用户定义的转换。

举个例子：

Complex<double> d;
Foo f;
d += f; // fails to compile with your version, compiles with C++ standard one

还有一个区别。如果我们有一个类Bar 有一个operator Complex<double>() const，它将无法使用C++ 标准版本。

使用您的版本，如果 T 恰好是 double，则它可以工作。

简而言之，您的参数可隐式转换为/从特定类型转换与采用该类型的参数不同。只能尝试一种用户定义的转换，因此如果您采用可以转换为 int 的类型，则可以接受 int，并且如果您采用可以从 int 进行的类型，则并非所有类型都可以转换为 @ 987654331@可以接受。

非用户定义的转换不受同样的限制。

Answer 2

您要比较的两个接口实际上是：

// 1
Complex<T>& operator+=(const Complex<T>&);

// 2
template <typename X>
complex<T>& operator+=(const complex<X>&);
complex<T>& operator+=(const T&);

两个不同之处在于，在 2 中，采用 complex 的重载是根据参数的类型模板化的，并且有一个显式的重载直接采用 T。由于现有的（假设您添加了缺少的构造函数 [*]）转换，这两种方法基本上都允许编译相同的代码，但需要额外的成本。

如果你只想给复数的实部加一个值，第一个设计需要创建一个Complex<T>（假设你有那个构造函数，没有显示），而在第二种情况下不需要创建临时对象。

同样，给定 complex 类型的不同实例化作为参数，隐式转换将在 1 中用于创建一个临时值，然后将其添加，而在第二种方法中，参数将直接绑定而无需暂时的。

虽然这对于基本类型并不重要，但如果用于实例化模板的类型是用户定义的并且构造/复制成本很高，则可能会如此。例如，考虑一个动态分配内存的BigNum 类型。临时会导致内存分配和释放。

[*] 不允许默认构造或带有单个参数的构造。