Resolving ambiguous call in template argument deduction

Question

A typical function template signature:

template<typename Iterator, typename T>
T fn(Iterator first, Iterator last, T init)
{
    T result;
    // ...
    return result;
}

The problem is, when I call it like this:

std::vector<long> data(1000,1);
fn(data.begin(), data.end(), 0);

or any other way without explicitly calling

fn<std::vector<long>::iterator, long>(data.begin(), data.end(),0);

then the type of T is an int, and there is a risk of overflow and bad results in fn.

So how do I specialize fn so that the call to

fn(data.begin(), data.end(), 0);

is unambigous and results in T to be set to Iterator::value_type? The choice

template<Iterator>
typename iterator_traits<Iterator>::value_type fn(Iterator first, Iterator last, typename iterator_traits<Iterator>::value_type init)
{
    //...
}

results in an ambiguous call error from g++/clang++.

EDIT:

I see my mistake now and the above code works with @Lightness Races suggestion below. Thanks for the help.

Note: forcing the type `T` to the value_type of the iterator may also result in overflow. Think about `std::accumulate` with `std::vector::iterator`, if we use `init` as '\0' versus `0`... — Jarod42, Jan 09 '14 at 16:53
@Jarod42: Yeah, you can't get around that by guessing with types. If the function body does something like `std::accumulate` then it should (somehow) ensure that it's got enough room to work with regardless. A specialisation for integral types that performs promotion would probably do. — Lightness Races in Orbit, Jan 09 '14 at 17:19

Lightness Races in Orbit · Accepted Answer · 2014-01-09T16:33:15.370

2

Why not simply pass a long?

fn(data.begin(), data.end(), 0L);

Beyond that you could probably do something like this:

#include <type_traits>

template<typename Iterator>
typename std::iterator_traits<Iterator>::value_type fn(
   Iterator first,
   Iterator last,
   typename std::iterator_traits<Iterator>::value_type init
);

Live demo

I don't really see how you're at risk of an overflow, though.

edited Jan 09 '14 at 16:33

answered Jan 09 '14 at 16:26

Lightness Races in Orbit

378,754
76
643
1,055

@Jarod42: I suggest to use a better font. – Lightness Races in Orbit Jan 09 '14 at 16:29
For the overflow, think about `std::accumulate` with 'big' `int`. – Jarod42 Jan 09 '14 at 16:38
@Jarod42: I suppose you increase the risk of overflow inside `fn`, but you can't get rid of that – Lightness Races in Orbit Jan 09 '14 at 16:38
Right - that will cause overflow. – Charles Pehlivanian Jan 09 '14 at 16:39
@Lightness Races: Yes, this works (the second suggestion). I had stupidly used `Iterator::value_type` instead of `iterator_traits::value_type` and should have caught my error before the post. Thanks! – Charles Pehlivanian Jan 09 '14 at 16:58

Jarod42 · Answer 2 · 2014-01-09T16:46:53.267

1

As:

0 is an int
0L is a long

You just have to call the method with the correct argument:

Use directly the correct literal

as:

fn(data.begin(), data.end(), 0L);

Or, you may use an intermediate variable

as:

long init = 0; // result in 0L

fn(data.begin(), data.end(), init);

or you may cast the value:

as:

fn(data.begin(), data.end(), static_cast<long>(0));

One way to write fn to avoid to call it correctly is

template<typename Iterator>
auto fn(Iterator first, Iterator last, typename std::decay<decltype(*first)>::type init)
    -> typename std::decay<decltype(*first)>::type;

edited Jan 09 '14 at 16:46

answered Jan 09 '14 at 16:18

Jarod42

203,559
14
181
302

Ok but I want to kind of prevent this from happening to myself or someone else. The real problem to me is that I can't specialize to make a proper `fn` now that this one is defined. The second template parameter is completely superfluous - the writer inteneded it always to be a `Iterator::value_type` , and I want to get rid of it. – Charles Pehlivanian Jan 09 '14 at 16:31

Resolving ambiguous call in template argument deduction

2 Answers2

Live demo