decltype does not resolve nested vectors. How can I use templates for nested vectors?

Question

I am trying to overload the + operator to deal with nested vectors. I thought the function would call itself until the nested vectors resolve to basic types, but instead I get a huge list of errors when I compile it. My vector operations that I have defined work for basic types, but not a variable amount of nested vectors. The only operation that does work for nested vectors is the << operator.

main.cpp

#include 
#include 
#include 

template
std::ostream& operator<<(std::ostream& stream, std::vector 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
auto operator+(const std::vector& l, const std::vector& r) 
-> std::vector{
    typedef decltype((l[0] + r[0])) type;
    std::vector ans;
    if(l.size() == std::max(l.size(),r.size()))
        std::transform(r.begin(), r.end(), l.begin(), std::back_inserter(ans), std::plus());
    else
        std::transform(l.begin(), l.end(), r.begin(), std::back_inserter(ans), std::plus());
    return ans;
};

int main(){

    std::vector> vecvec = {{1,2,3},{4,5,6},{7,8,9}};
    std::vector 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;
}

Now I am not able to do type promotion with nested vectors. I think I need std::plus T1 or std::plus T2 depending on promotion rules.

template 
struct Add : std::plus { };//<- Here

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

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

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

I tried this and got an output of 2 instead of 2.5.

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

Barry · Accepted Answer

My other answer on here explains why your approach failed and one possible approach for a solution. I just thought of a much, much simpler one that I thought was worth sharing.

The problem is that you can't use a trailing return type because the function name itself isn't in scope yet, so you can't use recursion in that way. However, there's nothing to stop you from writing a metafunction to determine what the return type should be. That metafunction is very simple:

template 
struct nested_common_type :std::common_type { };

template 
struct nested_common_type, std::vector> {
    using type = std::vector::type>;
};

template 
using vector_common_type_t = std::vector::type>;

And once we have the return type, we can just write one normal operator+:

template >
R operator+(const std::vector& l, const std::vector& 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 does not resolve nested vectors. How can I use templates for nested vectors?

Answers (2)

Related Questions