0

I'm trying to create an overloaded method, where both are templated. One takes 4 arguments, and one takes 5. However I get an error along the lines of 

Error C2780 ... OutOfPlaceReturn ... : expects 4 arguments - 5 provided.

... A bunch of template parameters ...

See declaration of ' ... ::OutOfPlaceReturn'

which references the line of the 4 argument method definition

In this case I'm trying to call the overload with 5 arguments, so I don't understand why the compiler thinks I want to call the function which only takes 4 arguments.

The full context is too complex to give the full code example, but suffice it to say this all takes place inside of a class template, which has lots of local typedefs, including samp_type, const_samp, samp_vec, etc. These are all either typedefs of a template argument which holds a POD type, or a std::array of one of these POD types

typedef int_fast16_t                                fast_int;
typedef typename std::add_const< fast_int >::type   const_fast_int;

typedef samp_type (*func_type)(const_samp, const_samp);

template<func_type operation, const_fast_int strideA, const_fast_int strideB, const_fast_int strideOut>
static inline samp_vec OutOfPlaceReturn(const std::array<samp_type, strideA * vectorLen> &a,
                                        const_fast_int strideA,
                                        const std::array<samp_type, strideB * vectorLen> &b,
                                        const_fast_int strideB,
                                        const_fast_int strideOut)
{
    std::array<samp_type, vectorLen * strideOut> output;
    for(fast_int i = 0; i < vectorLen; ++i)
        output[i * strideOut] = operation(a[i * strideA], b[i * strideB]);
    return output;
}
template<func_type operation, const_fast_int strideA, const_fast_int strideOut>
static inline samp_vec OutOfPlaceReturn(const std::array<samp_type, strideA * vectorLen> &a,
                                        const_fast_int strideA,
                                        const_samp_ref b,
                                        const_fast_int strideOut)
{
    std::array<samp_type, vectorLen * strideOut> output;
    for(fast_int i = 0; i < vectorLen; ++i)
        output[i * strideOut] = operation(a[i * strideA], b);
    return output;
}

If I understand correctly, when calling a template function, you don't need to provide the template parameters which the compiler can deduce through function arguments, so the call looks like this

static samp_vec subtract(const_vec_ref a, const_fast_int strideA, const_vec_ref b, const_fast_int strideB, const_fast_int strideOut)
{   return OutOfPlaceReturn<MathClass::subtract>(a, strideA, b, strideB, strideOut);    }

So, is there something wrong with the way I'm calling these template methods? Is there something wrong with the way I'm expecting the compiler to resolve overloads?

Edit

I'm using VS2010. So far it's been pretty good with templates and C++11 data-types. Not sure if my compiler is acting sub-par

xaviersjs
  • 1,579
  • 1
  • 15
  • 25
  • Don't think it explains the error, but it's not a great idea to have a template parameter `strideA` and a function parameter `strideA`. You could probably ditch the function parameters and just use the template parameters inside the definitions. – aschepler Feb 10 '14 at 12:54
  • I tried removing strideA, strideB and strideOut from the function argument. The compiler still complains but this time a little differently: `too many template arguments`. This seems to me to be fundamentally the same problem: The compiler can't figure out which template method I mean. – xaviersjs Feb 10 '14 at 13:34
  • You seem to be confused about how template parameters work. You try to use non-type template, then redeclare them in the argument list and then don't pass them in the call. This is all very odd. – pmr Feb 10 '14 at 13:49
  • I seem to understand fundamentally how template parameters work. What I don't have is experience using them. I was trying to apply the constraint that the stride values be known at compile-time. I see how putting that information directly into the template parameters without removing them from the function signature is a little strange. Is that what was odd about it, or is there something else too? I can take any advice on better ways to do what I'm trying to do. – xaviersjs Feb 10 '14 at 14:29

1 Answers1

1

Overload resolution is done only for templates that can be instantiated. This is part of why SFINAE works.

In your case, your 5 arg overload has an ambiguous strideOut. Is that a template parameter or not?

MSalters
  • 173,980
  • 10
  • 155
  • 350
  • Actually the function parameter declarations of `strideOut` (it's there in both) are invalid, because the name of a template parameter shall not be redeclared within the template. – Potatoswatter Feb 10 '14 at 13:01
  • @Potatoswatter: Now that I look at it, so is `strideA` and `strideB`. And the 4-arg version has pretty much the same problems with `strideOut` and `strideA`. I guess the compiler just gave up. – MSalters Feb 10 '14 at 13:26
  • Also he appears to want `strideA * vectorLen` to be deduced, perhaps by implicit division. Best advice might be to take it one step at a time :) – Potatoswatter Feb 10 '14 at 13:28
  • vectorLen is a template argument for the class that contains all these methods. @MSalters why is strideOut ambiguous? – xaviersjs Feb 10 '14 at 13:39
  • @xaviersjs: You're trying to pass `strideOut` both as a template parameter and as a regular parameter. – MSalters Feb 13 '14 at 10:00