Question

我试图重载+运算符来处理嵌套向量。我认为函数会调用自己，直到嵌套向量解析为基本类型，但是当我编译它时，我得到了一个巨大的错误列表。我定义的向量操作适用于基本类型，但不适用于可变数量的嵌套向量。对嵌套向量起作用的唯一操作是＆lt;＆lt;操作

的main.cpp

#include <iostream>
#include <vector>
#include <algorithm>

template<typename T1>
std::ostream& operator<<(std::ostream& stream, std::vector<T1> r){
    if(r.size() == 0){
        return stream;
    }
    else{
        stream << "(";
        for(int i = 0; i < r.size(); i++){
            if(i < (r.size() - 1)){
                stream << r[i] << ", ";
            }
            else{
                stream << r[i] << ")";
            }
        }
    }
    return stream;
};

template<typename T1, typename T2>
auto operator+(const std::vector<T1>& l, const std::vector<T2>& r) 
-> std::vector<decltype((l[0] + r[0]))>{
    typedef decltype((l[0] + r[0])) type;
    std::vector<type> ans;
    if(l.size() == std::max(l.size(),r.size()))
        std::transform(r.begin(), r.end(), l.begin(), std::back_inserter(ans), std::plus<type>());
    else
        std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::plus<type>());
    return ans;
};

int main(){

    std::vector<std::vector<int>> vecvec = {{1,2,3},{4,5,6},{7,8,9}};
    std::vector<int> vec = {1,2,3};

    //Both output statements compile
    std::cout << vec    << std::endl;
    std::cout << vecvec << std::endl;

    //Does not compile 
    vecvec = vecvec + vecvec;

    //Does compile
    vec = vec + vec;

    return 0;
}

现在我无法使用嵌套向量进行类型提升。我想我需要std :: plus T1或std :: plus T2，具体取决于促销规则。

template <typename T1, typename T2>
struct Add : std::plus<T1> { };//<- Here

template <typename T1, typename T2>
struct Add<std::vector<T1>, std::vector<T2>>
{   
    auto operator()(const std::vector<T1>& l, const std::vector<T2>& r)
        -> std::vector<decltype(Add<T1,T2>{}(l[0], r[0]))>
    {
        using type = decltype(Add<T1,T2>{}(l[0], r[0]));
        std::vector<type> ans;

        if(l.size() == std::max(l.size(),r.size()))
            std::transform(r.begin(), r.end(), l.begin(), std::back_inserter(ans), Add<T1,T2>{});
        else
            std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), Add<T1,T2>{});
        return ans;
    };
};

template <typename T1, typename T2>
auto operator+(const std::vector<T1>& lhs, const std::vector<T2>& rhs)
    -> decltype(Add<std::vector<T1>, std::vector<T2>>{}(lhs, rhs))
{
    return Add<std::vector<T1>, std::vector<T2>>{}(lhs, rhs);
}

我试过这个并输出2而不是2.5。

int main(){
    p(int) e = {1};
    p(double) q = {1.5};
    std::cout << (e + q) << std::endl;
    return 0;
}

Answer 1

您遇到的问题与名称查找有关。您正在此处operator+进行无限制的名称查找：

template<typename T1, typename T2>
auto operator+(const std::vector<T1>& l, const std::vector<T2>& r) 
-> std::vector<decltype((l[0] + r[0]))> {
                        ^^^^^^^^^^^^^

来自[basic.scope.pdecl]：

名称的声明点紧跟在其完整的声明者（第8条）之后 初始化程序（如果有的话）

在该功能中，＆＃34;完整的声明者＆＃34;包括 trailing-return-type 。因此，在在声明符后，您的operator+模板才会在范围内。也就是{

另一个问题是std::plus。 std::plus永远不会找到您的operator+，因为在定义std::plus时它还不存在。

在C ++ 14中，最简单的解决方案是删除尾随返回类型（无论如何都要正确推导）并用简单的lambda替换std::plus：

auto plus = [](const type& lhs, const type& rhs) { return lhs + rhs; };

如果没有C ++ 14，您必须将所有内容转发给另一个函数，以便名称查找可以成功。您可以使用ADL技巧，但我认为模板更容易理解。这是一个有效的解决方案：

template <typename T1, typename T2>
struct Add : std::plus<T1> { };

template <typename T1, typename T2>
struct Add<std::vector<T1>, std::vector<T2>>
{   
    auto operator()(const std::vector<T1>& l, const std::vector<T2>& r)
        -> std::vector<decltype(Add<T1,T2>{}(l[0], r[0]))>
    {
        using type = decltype(Add<T1,T2>{}(l[0], r[0]));
        std::vector<type> ans;

        if(l.size() == std::max(l.size(),r.size()))
            std::transform(r.begin(), r.end(), l.begin(), std::back_inserter(ans), Add<T1,T2>{});
        else
            std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), Add<T1,T2>{});
        return ans;
    };
};

template <typename T1, typename T2>
auto operator+(const std::vector<T1>& lhs, const std::vector<T2>& rhs)
    -> decltype(Add<std::vector<T1>, std::vector<T2>>{}(lhs, rhs))
{
    return Add<std::vector<T1>, std::vector<T2>>{}(lhs, rhs);
}

Answer 2

此处的other answer解释了您的方法失败的原因以及解决问题的可能方法。我只是想到了一个我认为值得分享的更简单的方法。

问题是你不能使用尾随返回类型，因为函数名本身不在范围内，所以你不能以这种方式使用递归。但是，没有什么可以阻止你编写元函数来确定返回类型应该是什么。这个元函数非常简单：

template <typename T1, typename T2>
struct nested_common_type :std::common_type<T1, T2> { };

template <typename T1, typename T2>
struct nested_common_type<std::vector<T1>, std::vector<T2>> {
    using type = std::vector<typename nested_common_type<T1,T2>::type>;
};

template <typename T1, typename T2>
using vector_common_type_t = std::vector<typename nested_common_type<T1,T2>::type>;

一旦我们有了返回类型，我们就可以写一个普通的operator+：

template <typename T1, typename T2,
          typename R = vector_common_type_t<T1,T2>>
R operator+(const std::vector<T1>& l, const std::vector<T2>& r)
{
    R ans;
    std::transform(l.begin(),
                   l.begin() + std::min(l.size(), r.size()),
                   r.begin(),
                   std::back_inserter(ans),
                   [](const T1& lhs, const T2& rhs){ return lhs + rhs; });
    return ans;
}

decltype不解析嵌套向量。如何使用嵌套向量的模板？

2 个答案: