Question

For an exercise for my C++ class (which hasn’t covered Boost yet), I am having trouble writing a templated method to accept two iterators for summing numeric values in an STL container.
Consider the following example:

#include <iostream>
#include <iterator>
#include <vector>

template<typename T>
double Sum(const T & c) {
    return 42.0;    // implementation stubbed
}

// need help writing this method signature to accept two iterators
template<typename T>
double Sum(const typename T::const_iterator & begin,
           const typename T::const_iterator & end) {
    return 43.0;    // another implementation stub
}

int main() {
    std::vector<double> v;
    v.push_back(3.14);
    v.push_back(2.71);
    v.push_back(1.61);    // sums to 7.46

    std::cout << Sum(v) << ' '              // line 23
              << Sum(v.begin(), v.end())    // line 24
              << '\n';
}

I expect this code to output 42 43, but it fails to compile.
The error g++ gives me is:

test_exercise2.cpp: In function ‘int main()’:
test_exercise2.cpp:24: error: no matching function for call to ‘Sum(__gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >)’

If I comment out line 24, I get 42 as the output, as expected.
I get the same error message whether or not the second templated method is present or not, so for some reason, it’s not able to resolve the call on line 24 to the second method I wrote.

What signature must I have for the method that accepts two iterators?

---

The reason why I’m stuck on this is because I need to support summing over the second element of std::map<K, V>. This will require two more overloads to call ->second instead of dereferencing the iterator:
1. template<typename K, typename V> double Sum(const std::map<K, V> & m); (I’m okay with this one)
2. and another one involving iterators over the map.

I feel like I’ll be able to write the methods for std::map if I can figure out how to specify the passing of iterators for std::list and std::map. I’m okay with solutions that use template-templates.

---

EDIT: The precise wording of problem (omitting non-contributory sentences).
The containers from “the previous exercise” were std::vector<double>, std::list<double>, std::map<std::string, double>.

Create a template function called Sum() that accepts the template
argument T as input and returns a double. The template argument will
be a container.

• In the implementation get an iterator (T::const_iterator) for the end. Then create a loop that iterates the container T and adds all
  values. Finally return the sum.
• In the main program, call the Sum() function for the different container from the previous exercise.

The Sum() function created calculates the sum of the complete
container. Also create a Sum() function that calculates the sum
between two iterators. The function then uses the template argument
for the iterator type and accepts two iterators, the start and end
iterator.

Answer 1

As DeadMG said, the simple way is to template on the type of the iterator. The common convention is, on the other hand, to pass iterators by value:

template <typename Iterator>
double Sum( Iterator begin, Iterator end );

As to why the original code was not working, the problem is that the type of the container is not deducible:

template <typename T>
double Sum( T::const_iterator begin, T::const_iterator end );
Sum( v.begin(), v.end() );        // [*] Assume v == const std::vector<double>&

When the compiler tries to infer the type of the arguments to Sum it only sees the type returned by v.begin() and v.end(), which are the iterator. From that type, it cannot guess the type of the container. To be able to determine what the type T is, it would have to test all non template types, and generate all infinite possible instantiations of template types to look whether they have a nested type const_iterator that matches the type of v.begin() and v.end(). Because that would be impossible, to achieve, the language forbids it in the first place.

Beyond that, and related to the comment ^[*], even if the type would be deducible, overload resolution is performed on the arguments to the function, and not how the expression is later use. In your program, the argument to .begin() is a std::vector<double> non-const lvalue. Because it is not const, the overload selected will yield a non-const iterator (even if in the function you want to call, there is no need to read it).