Фильтр map

struct sdate  
{   int year;  int month;  int day;  };
 
 struct stime  
{ int hour; int mines; int quantity; };
 
 struct sdate_time
 {   sdate date_;   stime time_;  };
 
 struct  all_trade
 {   int quantity;  };
 
map<sdate_time, all_trade> all_trade_;

        typedef  map<i_time, one_trade> type_one_trades;
    type_one_trades  m_one_trades{};
    map<i_date, type_one_trades> m_day_trades{};

int main()
{
    std::map<int,int> myMap={{1,1},{2,2},{3,3},{4,4},{5,5}};
    auto minPos=myMap.lower_bound(3);
    auto maxPos=myMap.lower_bound(7);
    for(auto pos=minPos;pos!=maxPos;++pos)
        std::cout<<pos->second<<std::endl;
    return 0;
}

        bool operator<(const i_date& val) const
        {
            const int is_g = god > val.god ? 1 :
                god < val.god ? -1 : 0;
 
            const int is_m = mes > val.mes ? 1 :
                mes < val.mes ? -1 : 0;
 
            const int is_d = day > val.day ? 1 :
                day < val.day ? -1 : 0;
 
            return is_g == 1 ? true : is_g == -1 ? false :
                is_m == 1 ? true : is_m == -1 ? false :
                is_d == 1 ? true : false;
        }

map<sdate_time, all_trade> all_trade_;

    struct date_time   // Ключ map
    {   date_time() = default;
        date_time(const int year, const int month, const int day, const int hour, const int minute)
        {   set(year, month, day, hour, minute); };
        date_time(const int year, const int month, const int day) 
                {set(year, month, day, 0, 0); };
        date_time(const date_time *sourse)
        {   set(sourse->year, sourse->month, sourse->day, sourse->hour, sourse->minute); };
        void set(const int year, const int month, const int day, const int hour, const int minute)
        {   leap(year);
            this->year = year;
            this->month = month;
            this ->day = day;
            this->hour = hour;
            this->minute = minute;
               _is = is();
        }
        void set_hour_min(const int hour, const int min)
        {   this->hour = hour;
            this->minute = min;
        }
        bool operator < (const date_time& val) const      //  для ключа в map
        {   if (year > val.year) return false;
            if (year < val.year) return true;
            if (month > val.month) return false;
            if (month < val.month) return true;
            if (day > val.day) return  false;
            if (day < val.day) return true;
            if (hour > val.hour) return false;
            if (hour < val.hour) return true;
            if (hour > val.hour) return false;
            if (hour < val.hour) return true;
            if (minute < val.minute) return true;
            return false;
        }
        int year = -1;
        int month = -1;
        int day = -1;
        int hour = -1;
        int minute = -1;
        bool _is = false;
    private:
        int days_[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
        void leap(int y)                                                                                              // проверка на високосный год
        {   if ((y % 4 == 0 && y % 100 != 0) || y % 400) days_[1] = 29; }
        int maxday()    {   return days_[month - 1];    }
        bool is()    
        {   return _is = year > 2000 && year < 2050 && month >= 1 && month <= 12
                && day >= 1 && day <= maxday() && hour >= 0 && hour < 24
                && minute >= 0 && minute <= 59;
        }
    };

    typedef my_date_time::date_time datetime;
    template <class T>
    struct mapfiltr_datetime 
    {   ~mapfiltr_datetime(){};
        std::map<datetime, T*> day_trades{};
        typename std::map<datetime, T*> ::iterator min_pos;
        typename std::map<datetime, T*> ::iterator max_pos;
        mapfiltr_datetime() { day_trades.clear(); }
        virtual void calculation_repeat(typename std::map<datetime, T*> ::iterator pos){}
        void add(datetime dt, T* t) {   day_trades.insert(std::pair <datetime, T*>(dt, new T(t)));  }
        int  kol_record(const datetime begin, const datetime end)
        {   if (day_trades.empty() && day_trades.size() == 0)   return 0;
            min_pos = day_trades.lower_bound(begin);
            max_pos = day_trades.upper_bound(end);
            return std::count_if(min_pos, max_pos, [](std::pair < datetime, T*>  p) {return  p.second;});
        }
        void filtr(const datetime *begin, const datetime *end)
        {   const auto kol = kol_record(begin, end);   
            if (kol <= 0) return;
            for (auto pos = min_pos; pos != max_pos; ++pos) 
                calculation_repeat(pos);   // обработка записи
        }
    };

struct dan_test
{
    dan_test(float punct1, float punct2): punct1(punct1),  punct2(punct2)   {   }
    dan_test(dan_test* sours)   { punct1 = sours->punct1;   punct2 = sours->punct2; }
    float punct1 = 0.f;
    float punct2 = 0.f;
    float add_punct = 0.f;
    float sum_punct = 0.f;
};

struct test_map : mapfiltr_datetime<dan_test>
{   test_map()  {   };
        //[B][U] вызывается  из mapfiltr_datetime[/U][/B]  
    void calculation_repeat(typename std::map<datetime, dan_test*> ::iterator pos) override
    {   add_punct = add_punct + pos->second->punct1;
        sum_punct= sum_punct - pos->second->punct2;
        pos->second->add_punct= add_punct;
        pos->second ->sum_punct= sum_punct;
    }
    void calculation(const datetime *begin, const datetime *end)
    {   add_punct = 0.f;
        sum_punct = 0.f;
        filtr(begin, end);
    }
    date_time dt0;
    float add_punct = 0.f;
    float sum_punct = 0.f;
};

#include "stdafx.h"
#include <memory>
int main()
{   std::shared_ptr<test_map> _test = std::make_shared<test_map>();;
    _test->add(date_time(2018, 3, 1, 0, 0), new dan_test(1, -11));
    _test->add(date_time(2018, 3, 1, 1, 2), new dan_test(22, -212));
    _test->add(date_time(2018, 3, 2, 2, 3), new dan_test(3, -32));
    _test->add(date_time(2018, 3, 4, 10, 20), new dan_test(44, 424));
    _test->add(date_time(2018, 3, 3, 12, 10), new dan_test(55, -552));
    _test->add(date_time(2018, 3, 2, 3, 30), new dan_test(6, 612));
    _test->add(date_time(2018, 3, 5, 15, 40), new dan_test(77, 76));
    auto xx = _test->kol_record(new date_time(2018, 3, 1, 0, 0), new date_time(2018, 3, 7, 0, 0));
    _test->calculation(new date_time(2018, 3, 2, 0, 0), new date_time(2018, 3, 4, 0, 0));
    return 0;
}