自定义STL游标实现虚拟容器(4)

//#pragma once
#include <iterator>
template<class T,class Generator,class SizeType=size_t> class dummy
{
public:
        typedef T value_type;
        typedef value_type& reference;
        typedef const reference const_reference;
        typedef value_type* pointer;
        typedef const pointer const_pointer;
        typedef SizeType size_type;
        typedef ptrdiff_t difference_type;
public:
        dummy():_start(0),_finish(0){}
        dummy(size_type n):_start(0),_finish(n){}
        dummy(size_type istart,size_type ifinish):_start(istart),_finish(ifinish){}
public:
        class iterator:public std::iterator<std::forward_iterator_tag,value_type>
        {
                friend class dummy<T,Generator,SizeType>;
        public:
                iterator() :_i(0)
                {
                }
                iterator(size_type i) :_i(i)
                {
                }
                reference operator*()
                {
                        return _value = _generator(_i);
                }
                iterator& operator++()
                {
                        ++_i; return *this;
                }
                iterator operator++(int)
                {
                        iterator tmp = *this;
                        ++(*this);
                        return tmp;
                }
                bool operator==(const iterator& other) const
                {
                        return _i == other._i;
                }
                bool operator!=(const iterator& other) const
                {
                        return _i != other._i;
                }
                operator size_type()const{return _i;}
                operator size_type&(){return _i;}
        private:
                size_type _i;
                value_type _value;
                Generator _generator;
        };
public:
        iterator begin()
        {
                return _start;
        }
        iterator end()
        {
                return _finish;
        }
        size_type size()
        {
                return static_cast<size_type>(_finish) - static_cast<size_type>(_finish);
        }
        void prepend(size_type sz)
        {
                static_cast<size_type&>(_start) -= sz;
        }
        void append(size_type sz)
        {
                static_cast<size_type&>(_finish) += sz;
        }
private:
        iterator _start;
        iterator _finish;
};

//
#include <iostream>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cmath>
struct Sin { double operator()(size_t i) { return sin(i); } };
struct Cos { double operator()(size_t i) { return cos(i); } };
struct Int { int operator()(size_t i) { return i; } };
template<class Dummy> void display(const char*str,Dummy&v)
{
        std::cout << str ;
        std::copy(v.begin(),v.end(),std::ostream_iterator<typename Dummy::value_type>(std::cout," "));
        std::cout << std::endl;
}
int main()
{
        std::cout.precision(20);
        {
                dummy<double,Sin> v(0,5);//索引从0开始到4结束：[0,5)
                display("正弦函数:",v);
                double result=std::accumulate(v.begin(),v.end(),0.0);
                std::cout << "正弦函数求和 = [" << result<< "]" << std::endl;
        }
        std::cout << std::endl;
        {
                dummy<double,Cos> v(5);//索引从0开始到4结束：[0,5)
                display("余弦函数:",v);
                double result=std::accumulate(v.begin(),v.end(),0.0);
                std::cout << "余弦函数求和 = [" << result<< "]" << std::endl;
        }
        std::cout << std::endl;
        {
                dummy<double,Sin> sv(0,5);//索引从0开始到4结束：[0,5)
                dummy<double,Cos> cv(5);//索引从0开始到4结束：[0,5)从0开始可以只写数量
                display("正弦函数:",sv);
                display("余弦函数:",cv);
                double result=std::inner_product(sv.begin(),sv.end(),cv.begin(),0.0);
                std::cout << "a和b的内积 = [" << result<< "]" << std::endl;
        }
        std::cout << std::endl;
        {
                dummy<int,Int,long> v(0,5);//索引从0开始到4结束：[0,5)
                display("整型函数初始值:",v);
                v.prepend(-1);//起始索引变为"1"
                display("整型函数头部先添加-1个元素:",v);
                v.append(+2);//起始索引变为"7"
                display("整型函数尾部再添加+2个元素:",v);
                int result=std::accumulate(v.begin(),v.end(),0);
                std::cout << "整型函数求和 = [" << result<< "]" << std::endl;
        }
        return 0;
}
//
//输出结果如下所示：
/************************************************************************************************
正弦函数:0 0.8414709848078965 0.90929742682568171 0.14112000805986721 -0.7568024953079282 
正弦函数求和 = [1.1350859243855171]

余弦函数:1 0.54030230586813977 -0.41614683654714241 -0.98999249660044542 -0.65364362086361194 
余弦函数求和 = [-0.51948064814305994]

正弦函数:0 0.8414709848078965 0.90929742682568171 0.14112000805986721 -0.7568024953079282 
余弦函数:1 0.54030230586813977 -0.41614683654714241 -0.98999249660044542 -0.65364362086361194 
a和b的内积 = [0.43121883997110472]

整型函数初始值:0 1 2 3 4 
整型函数头部先添加-1个元素:1 2 3 4 
整型函数尾部再添加+2个元素:1 2 3 4 5 6 
整型函数求和 = [21]
*************************************************************************************************/
//