STL Iterators

#include <iostream>
#include <vector>
#include <map>
 
template<typename Iterator>
double get_el(Iterator i, const typename Iterator::value_type&)
{
   return *i;
}
 
template<typename T, typename T2, typename Iterator>
double get_el(Iterator i, const std::pair<const T, T2>&)
{
   return i->second;
}
 
template<typename Container>
double sum(const Container& cnt)
{
   typedef typename Container::const_iterator c_iter;
   double sum = 0;
   for (c_iter i = cnt.begin();
        i != cnt.end();
        ++i)
   {
      sum += get_el(i, *i);
   }
   return sum;
}
 
int main()
{
   std::vector<double> v = {1,2};
   std::cout << sum(v) << std::endl;
   std::map<int, double> m = 
   {
     std::make_pair(1, 1.0),
     std::make_pair(2, 2.0)
   };
   std::cout << sum(m) << std::endl;
}

#include <iostream>
#include <utility>
#include <map>
 
// велосипед для std::plus
struct binaryOperationSum {
  template <class T>
  T operator()(const T &a, const T &b) {
    return a + b;
  }
};
 
// функтор для сложения второго значения у std::pair
struct binaryOperationSumOfPair {
  template <class T>
  double operator()(double &a, const T &b) {
    return a + b.second;
  }
};
 
// велосипед для std::sum
template <class StartIterator, class FinishIterator, class T,
  class BinaryOperation>
T sum(StartIterator begin, FinishIterator end,
  T initialValue, BinaryOperation operation) {
  while (begin != end)
    initialValue = operation(initialValue, *begin++);
  return initialValue;
}
 
// велосипед для std::sum с дефолтной бинарной операцией 
template <class StartIterator, class FinishIterator, class T>
T sum(StartIterator begin, FinishIterator end, T initialValue) {
  return sum(begin, end, initialValue, binaryOperationSum());
}
 
int main(int argc, char **argv) {
  std::map<int, double> a;
  a[0] = 1.25;
  a[1] = 0.75;
  a[2] = 0.23;
  std::cout << sum(a.begin(), a.end(), 0.0, binaryOperationSumOfPair());
  return 0;
}

вот это походу если я правильно понимаю 
 
// велосипед для std::sum с дефолтной бинарной операцией 
    template <class StartIterator, class FinishIterator, class T>
    T sum(StartIterator begin, FinishIterator end, T initialValue) 
        {
          return Sum(begin, end, initialValue, binaryOperationSum());
        }
 
-> 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.

#include <iostream>
 
#include <vector>
#include <list>
#include <deque>
 
 
template <typename Iterator>
double
Sum( Iterator first, Iterator last )
{
    double ret = 0.0;
 
    while( first != last )
        ret += *first++;
 
    return ret;
}
 
 
int
main()
{
    // typedef std::vector< double > double_container_t;
    // typedef std::list< double > double_container_t;
    typedef std::deque< double > double_container_t;
 
    double_container_t nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -10 };
 
    std::cout << "sum = " << Sum( nums.begin(), nums.end() ) << '\n';
 
    return 0;
}

#include <iostream>
#include <vector>
#include <map>
 
template<typename Iterator>
double get_el(Iterator i, const typename Iterator::value_type&)
{
   return *i;
}
 
template<typename T, typename T2, typename Iterator>
double get_el(Iterator i, const std::pair<const T, T2>&)
{
   return i->second;
}
 
template<typename Container>
double sum(const Container& cnt)
{
   typedef typename Container::const_iterator c_iter;
   double sum = 0;
   for (c_iter i = cnt.begin(); i != cnt.end();  ++i)
       {
          sum += get_el(i, *i);
       }
   return sum;
}
 
int main()
{
 
 
    std::vector <int> My_TestSum_Vector;
 
            for (int i=0;i<10;i++) 
                {
                    My_TestSum_Vector.push_back(i);
                }
 
            
 
         std::map<int, double> My_SumTest_Map = 
                           {
                             std::make_pair(1, 1.0), std::make_pair(2, 2.0)
                           };
  
   std::cout << "vector" << sum(My_TestSum_Vector) << std::endl;
 
  
   std::cout <<"map sum " << sum(My_SumTest_Map) << std::endl;
}

#include <iostream>
 
#include <vector>
#include <list>
#include <map>
 
 
template <typename Iterator>
double
Sum( Iterator first, Iterator last )
{
    double ret = 0.0;
 
    while( first != last )
        ret += *first++;
 
    return ret;
}
 
 
int
main()
{
    // typedef std::vector< double > double_container_t;
    // typedef std::list< double > double_container_t;
    typedef std::map< double,double > double_container_t;
 
     double_container_t MyContainer;
 
            for (int i=0;i<10;i++) 
                {
                    //MyContainer.push_back(i);
                    MyContainer[i] = i*10; 
                }
 
    std::cout << "sum = " << Sum( MyContainer.begin(), MyContainer.end() ) << '\n';
 
    return 0;
 
}

#include <iostream>
 
#include <vector>
#include <list>
#include <map>
 
template <typename Iterator>
double
Sum( Iterator first, Iterator last )
{
    double ret = 0.0;
 
    while( first != last )
        ret += *first++;
 
    return ret;
}
 
template <class T1, class T2>
class MapAdapter {
  typename std::map<T1, T2>::iterator iterator;
public:
  MapAdapter(const typename std::map<T1, T2>::iterator &iterator_):
    iterator(iterator_) {}
 
  MapAdapter<T1, T2>& operator++()
  {
    iterator++;
    return this;
  }
 
  MapAdapter<T1, T2> operator++(int bork)
  {
    return MapAdapter<T1, T2>(++iterator);
  }
 
  T2 operator*()
  {
    return (*iterator).second;
  }
 
  bool operator==(const MapAdapter<T1, T2> &other)
  {
    return this->iterator == other.iterator;
  }
 
  bool operator==(const typename std::map<T1, T2>::iterator &other)
  {
    return this->iterator == other;
  }
 
  bool operator!=(const MapAdapter<T1, T2> &other)
  {
    return !MapAdapter<T1, T2>::operator==(other);
  }
 
  bool operator!=(const typename std::map<T1, T2>::iterator &other)
  {
    return !MapAdapter<T1, T2>::operator==(other);
  }
};
 
int
main()
{
    // typedef std::vector< double > double_container_t;
    // typedef std::list< double > double_container_t;
    typedef std::map< double,double > double_container_t;
 
     double_container_t MyContainer;
            for (int i=0;i<10;i++) 
                {
                    MyContainer[i] = i*10; 
                }
 
    std::cout << "sum = " << Sum(MapAdapter<double, double>(MyContainer.begin()), MapAdapter<double, double>(MyContainer.end())) << '\n';
    return 0;
}

std::pair<const Key, Value>

#include <iostream>
#include <vector>
#include <map>
 
template<typename Iterator>
double get_el(Iterator i, const typename Iterator::value_type&)
{
   return *i;
}
 
template<typename T, typename T2, typename Iterator>
double get_el(Iterator i, const std::pair<const T, T2>&)
{
   return i->second;
}
 
template<typename Container>
double sum(const Container& cnt)
{
   typedef typename Container::const_iterator c_iter;
   double sum = 0;
   for (c_iter i = cnt.begin();
        i != cnt.end();
        ++i)
   {
      sum += get_el(i, *i);
   }
   return sum;
}
 
int main()
{
   double array[] = {1, 2};
   std::vector<double> v(array, array + sizeof(array) / sizeof(*array));
   std::cout << sum(v) << std::endl;
   std::pair<int, double> map[] = 
   {
     std::make_pair(1, 1.0),
     std::make_pair(2, 2.0)
   };
   std::map<int, double> m(map, map + sizeof(map) / sizeof(*map));
   std::cout << sum(m) << std::endl;
}

template <typename FirstSummandContainer,typename SecondSummandContainer>
            double Sum (FirstSummandContainer& ObjFirstSummandContainer, 
                SecondSummandContainer& ObjSecondSummandContainer)
                {
                    return Sum(ObjFirstSummandContainer) + Sum(ObjSecondSummandContainer);
                }

#include <iostream>
#include <vector>
#include <map>
 
template<typename T>
T get_el(const T& value)
{
    return value;
}
 
template<typename T, typename T2>
T2 get_el(const std::pair<const T, T2>& value)
{
    return value.second;
}
 
template<typename Container>
double sum(const Container& cnt)
{
   typedef typename Container::const_iterator c_iter;
   double sum = 0;
   for (c_iter i = cnt.begin();
        i != cnt.end();
        ++i)
   {
      sum += get_el(*i);
   }
   return sum;
}
 
template<typename Iterator>
double sum(Iterator first, Iterator last)
{
    double sum = 0;
    for (; first != last; ++first)
    {
        sum += get_el(*first);
    }
    return sum;
}
 
int main()
{
   double array[] = {1, 2};
   std::vector<double> v(array, array + sizeof(array) / sizeof(*array));
   std::cout << sum(v) << std::endl;
   std::pair<int, double> map[] = 
   {
     std::make_pair(1, 1.0),
     std::make_pair(2, 2.0)
   };
   std::map<int, double> m(map, map + sizeof(map) / sizeof(*map));
   std::cout << sum(m) << std::endl;
   std::cout << "By iters " << sum(m.begin(), m.end()) << std::endl;
}

#include <iostream>
#include <string>
#include <stdexcept>
#include <utility>
#include <vector>
#include <map>
 
// предикат, общий для простых типов и для std::pair<K, V>
struct PredicateCommon {
  // обычно возвращает собственно значение
  template <class T>
  T operator()(const T &value) { return value; }
  // в случае класса std::pair возвращает поле second
  template <class K, class V>
  V operator()(const std::pair<K, V> &value) { return value.second; }
};
 
// бинарная операция суммирования, велосипед для std::sum
// можно заменить плюсом
struct BinaryOperationSum {
  template <class T>
  T operator()(const T &a, const T &b) { return a + b; }
};
 
// общая функция, похожая на std::accumulate
// принимает бинарную функцию и предикат для элементов контейнера
template <class InputIterator, class T,
  class BinaryOperation, class Predicate>
T accumulate(InputIterator first, InputIterator last, T initialValue,
  BinaryOperation binaryOperation, Predicate predicate) {
  while (first != last)
    // выполняет бинарную операцию надо всеми элементами с применением
    // предиката
    initialValue = binaryOperation(initialValue, predicate(*first++));
  return initialValue;
}
 
// частный случай accumulate -- суммирование с заранее заданным предикатом
template <class InputIterator, class T>
T sum(InputIterator first, InputIterator last, T initialValue) {
  return accumulate(first, last, initialValue, BinaryOperationSum(),
    PredicateCommon());
}
 
// частный случай sum -- суммирование всех элементов контейнера с заранее заданным предикатом
template <class Container, class T>
T sum(const Container &container, T initialValue) {
  return sum(container.begin(), container.end(), initialValue);
}
 
int main(int argc, char **argv) {
  std::map<int, double> d;
  d[0] = 0.72;
  d[1] = 0.12;
  d[2] = 1.22;
  std::cout << sum(d, 0.0d) << std::endl;
  std::cout << intToString(100, 16) << std::endl;
  return 0;
};