C++ 两种不同类型的相同模板化类/结构的运算符重载？

我有一门方便的课，Vector。它实际上只是一个模板结构，包含3种内容。它们可以是浮点、双精度、整数等

即：

但是，如果我想这样做，该怎么办：

Vector<float> myFloatVec(0.2, 0.5, 0.95);
Vector<int> myIntVec(2, 5, 1);

Vector<float> result = myFloatVec + myIntVec; // cannot do this

Vector myFloatVec（0.2,0.5,0.95）；
载体myIntVec（2,5,1）；
向量结果=myFloatVec+myIntVec；//不能这样做

如果我以后想更改类型呢：

vector<int> result2 = static_cast<int>(result); // cannot do, this would be nice too

vector result2=static_cast（结果）；//不行，这也很好

< C++ >

有什么方法可以很容易地完成这类事情吗？

---

如果我能以某种方式将整数向量转换成浮点向量，那么我就可以让普通操作符重载接管。遗憾的是，我不知道有什么方法可以重载静态强制转换在类型上的工作方式。

您可以执行以下操作

#include <iostream>
#include<type_traits>

template <typename T>
struct Vector 
{
    T x;
    T y;
    T z;
};

template <typename T1, typename T2>
auto operator +( const Vector<T1> &v1, const Vector<T2> &v2 ) -> Vector<typename std::common_type<T1, T2>::type>
{
    return { v1.x + v2. x, v1.y + v2.y, v1.z + v2.z };  
}

int main() 
{
    Vector<int> v1 = { 1, 2, 3 };
    Vector<float> v2 = { 1.1f, 2.2f, 3.3f };

    Vector<float> v3 = v1 + v2;

    std::cout << "v3.x = " << v3.x 
              << ", v3.y = " << v3.y
              << ", v3.z = " << v3.z 
              << '\n';

    return 0;
}

---

它似乎确实在正确的轨道上，不知何故错过了它。虽然答案有点让人困惑，因为它实际上似乎没有执行“`+=`”，但不确定我是否遗漏了什么。您的代码没有

+=

，因此我看不出问题所在。您可以为特定类型的向量添加另一个重载，即

向量运算符+（const vector&rhs）

甚至

向量运算符+（土木工程及右岸）

。虽然老实说，我不认为我会涉及模板，但可能会有两个单独的类型，而不是显式命名的函数，任何转换都必须发生。@TylerShellberg很公平。可能是回答者的错别字。但问题是一样的。无论是

+

，

+=

，

-

，都是，或者

%=

，您的问题在于您的声明，而不是函数的实际内容。@Chipster:回答者方面没有问题；原始问题的示例代码也没有执行类似

+=

的操作。但是

+=

的主体基本上是不相关的；您以任何合理的方式实现它。那么

vector result2=static_cast（result）；

？为了处理任何其他奇怪的重载，我可能还会使用

std:：typeof（std:：declval（）+std:：declval（））

而不是

common_type

（又名

vector

@MooingDuck在本例中，例如需要模板转换构造函数。@VladfromMoscow此方法与仅使用一个参数模板化运算符重载（与人们链接的其他方法类似）之间的主要区别是什么？@TylerShellberg通常将二进制运算符声明为非cl屁股功能。

vector<int> result2 = static_cast<int>(result); // cannot do, this would be nice too

#include <iostream>
#include<type_traits>

template <typename T>
struct Vector 
{
    T x;
    T y;
    T z;
};

template <typename T1, typename T2>
auto operator +( const Vector<T1> &v1, const Vector<T2> &v2 ) -> Vector<typename std::common_type<T1, T2>::type>
{
    return { v1.x + v2. x, v1.y + v2.y, v1.z + v2.z };  
}

int main() 
{
    Vector<int> v1 = { 1, 2, 3 };
    Vector<float> v2 = { 1.1f, 2.2f, 3.3f };

    Vector<float> v3 = v1 + v2;

    std::cout << "v3.x = " << v3.x 
              << ", v3.y = " << v3.y
              << ", v3.z = " << v3.z 
              << '\n';

    return 0;
}

v3.x = 2.1, v3.y = 4.2, v3.z = 6.3