Question

我的目标是能够在std :: vector上使用算术运算符。请考虑以下示例：

#include <vector>

using namespace std;

template <class S, class T, class U> vector<U> operator+(const vector<S> &a, const vector<T> &b){
    vector<U> result;
    result.reserve(a.size());
    for(int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

int main(int argc, char** argv) {
    vector<double> bla;
    bla = bla + bla;
    return 0;
}

此代码无法编译，因为编译器无法推导出模板参数U（它不是MWE，但我试图提供一个有意义的示例）。为什么会这样？我知道在这里使用三个模板参数可能没有意义。我的想法是，在类型S和T都提供匹配的“+” - 具有不同返回类型的实现的情况下，我可以同时处理这两种情况。或者是歧义问题？我只是想知道编译器是否应该无法推断出U.当然下面的代码工作正常：

#include <vector>

using namespace std;

template <class S, class T> vector<S> operator+(const vector<S> &a, const vector<T> &b){
    vector<S> result;
    result.reserve(a.size());
    for(int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

int main(int argc, char** argv) {
    vector<double> bla;
    bla = bla + bla;
    return 0;
}

Answer 1

您可以使用common type

来完成此操作

#include <vector>
#include <type_traits>

using namespace std;

template <class S, class T> 
vector<typename std::common_type<S, T>::type> operator+(const vector<S> &a, const vector<T> &b)
{
    vector<typename std::common_type<S, T>::type> result;
    result.reserve(a.size());
    for(unsigned int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

int main() {
    vector<double> bla;
    bla = bla + bla;
    return 0;
}

Live Example

编辑：正如Jarod42建议的那样，您也可以使用vector<decltype(a[0] + b[0])>作为另一种可能的返回类型（可能与common_type不同）。请记住，后者需要尾随返回类型或std::declval（C ++ 11）

Answer 2

Marco A.的解决方案很好，我想提供更多细节，并说明为什么Macro A的答案更好。

解决方案1： 当你将operator +的返回类型作为第3个参数时，所以当explicity声明模板参数时，我们必须指定所有三个参数，如下所示：

#include <iostream>     // std::cout
#include <iterator>     // std::ostream_iterator
#include <vector>       // std::vector
#include <algorithm>    // std::copy

// declare return type as the 3rd parameter
template <class S, class T, class U> std::vector<U> operator+(const std::vector<S> &a, const std::vector<T> &b){
    std::vector<U> result(a.size());
    for(int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

int main(int argc, char** argv) {
    std::vector<double> bla;
    bla.push_back(3.14);
    bla.push_back(2.7);

    // explicity specify three  template parameter
    bla = ::operator+<double,double,double>(bla,bla); 

    // print results   
    std::ostream_iterator<double> os_it(std::cout," ");
    std::copy(bla.begin(),bla.end(),os_it);
    std::cout << std::endl;

    return 0;
}

输出为：

6.28 5.4

解决方案2：你可以将返回类型转换为第一个参数，然后我们只需要指定返回类型，另外两个参数可以由编译器推导出来。

#include <iostream>     // std::cout
#include <iterator>     // std::ostream_iterator
#include <vector>       // std::vector
#include <algorithm>    // std::copy

//decalre return type as first template parameter
template <class U, class S, class T> std::vector<U> operator+(const std::vector<S> &a, const std::vector<T> &b){
    std::vector<U> result(a.size());
    for(int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

int main(int argc, char** argv) {
    std::vector<double> bla;
    bla.push_back(3.14);
    bla.push_back(2.7);

    // only explicity specify the return type 
    bla = ::operator+<double>(bla,bla);

    // print results   
    std::ostream_iterator<double> os_it(std::cout," ");
    std::copy(bla.begin(),bla.end(),os_it);
    std::cout << std::endl;

    return 0;
}

输出为：

6.28 5.4

解决方案3：正如Macro A.所给出的，这比上述两种解决方案更好。我们不需要明确指定返回类型。作为一个完整的例子，我也把我的runnable示例代码放在这里：

//Note:  This file should be compiled with c++11

#include <iostream>     // std::cout
#include <iterator>     // std::ostream_iterator
#include <vector>       // std::vector
#include <algorithm>    // std::copy
#include <type_traits>  // std::common_type c++11

//using std::common_type 
template <class S, class T> std::vector<typename std::common_type<S, T>::type> operator+(const std::vector<S> &a, const std::vector<T> &b){
    std::vector<typename std::common_type<S, T>::type> result(a.size());
    for(int i = 0; i < a.size();++i){
        result[i] = a[i] + b[i];
    }
    return result;
}

// print results   
template <typename T>
void printData(const std::vector<T>& bla) {
    std::ostream_iterator<double> os_it(std::cout," ");
    std::copy(bla.begin(),bla.end(),os_it);
    std::cout << std::endl;
}


int main(int argc, char** argv) {
    std::vector<double> dvec;
    dvec.push_back(3.14);
    dvec.push_back(2.7);

    std::vector<int> ivec;
    ivec.push_back(1);
    ivec.push_back(2);

    // we need not to  explicity specify template parameter 
    printData(dvec+dvec);
    printData(dvec+ivec);
    printData(ivec+ivec); 

    return 0;
}

输出为：

6.28 5.4 
4.14 4.7 
2 4

Answer 3

编译器如何推断U？没有提供任何关于U的信息。

将其更改为S和T，并使返回类型取决于S和T之间的某种关系。

例如。

template<typename S, typename T>
auto operator+(vector<S> const &a, vector<T> const &b) -> vector< foo<S,T> >

Answer 4

该标准已经提供了基于算术的数组类std::valarray：

std::valarray<double> bla{2.0, 4.0, 6.0};
bla = bla + bla;

C ++ - 模板参数推导/替换失败

4 个答案: