posts - 7,  comments - 64,  trackbacks - 0

最近在百度知道上回答了一道问题,并为他封装了一个类来解决。大意是不开辟新的数组同时排序两个数组。
http://zhidao.baidu.com/question/112777967.html

之后想要给这个类添加iterator好直接使用sort之类的函数,经过1个多小时的忙碌(能力有限,可以鄙视一下),终于实现了random_access_iterator。
上源码:

template<typename T>
class Obj;

template<typename T>
class Obj_iterator : public std::iterator <std::random_access_iterator_tag , T>
{
public:
        Obj_iterator() : m_Obj(NULL) , m_index(0) {}
        Obj_iterator( Obj<T> *p , size_t index ) : m_Obj(p) , m_index(index){}
        Obj_iterator& operator = ( const  Obj_iterator &t )
        {
                m_index = t.m_index;
                m_Obj = t.m_Obj;
                return *this;
        }
        bool operator ==( const Obj_iterator &rh ) const
        {
                return rh.m_Obj == m_Obj && rh.m_index == m_index;
        }
        bool operator !=( const Obj_iterator &rh ) const
        {
                return !( *this == rh );
        }
        Obj_iterator operator ++()
        {
                ++m_index;
                return Obj_iterator(m_Obj,m_index);
        }
        Obj_iterator operator ++( int )
        {
                Obj_iterator x = *this;
                ++(*this);
                return x;
        }
        Obj_iterator operator -- ()
        {
                --m_index;
                return Obj_iterator(m_Obj , m_index);
        }
        //一开始这里总是过不去,后来回想起以前遇到的问题,才知道需要在后面加上const来修饰,原因如下
        /*
        C++不鼓励把非常量引用绑定到临时对象
        非const的operator*有可能改变对象值,从而对象整体的const性质得不到保证
        */
        T& operator *() const
        {
                return (*m_Obj)[m_index];
        }
        T* operator ->() const
        {
                return &(*m_Obj[m_index]);
        }
        const Obj_iterator operator +(size_t n)
        {
                return Obj_iterator(m_Obj , m_index + n);
        }
        const Obj_iterator operator += (size_t n)
        {
                m_index += n;
                return *this;
        }
        difference_type operator -(const Obj_iterator &n)
        {
                return m_index - n.m_index;
        }
        Obj_iterator operator -(size_t n)
        {
                return Obj_iterator(m_Obj , m_index-n);
        }
        bool  operator < (const Obj_iterator n) const
        {
                return m_index<n.m_index;
        }
protected:
private:
        Obj<T> *m_Obj;
        size_t m_index;
};


template <typename T>
class Obj
{
public:
        Obj(T *p1,size_t sizeofp1,T *p2,size_t sizeofp2):
              m_p1(p1),
              m_p2(p2),
              m_sizeofp1(sizeofp1),
              m_sizeofp2(sizeofp2)
      {
              m_sumsize = sizeofp1+sizeofp2;
      }

 

      typedef Obj_iterator<T>  iterator;

 

      T& operator [](size_t index)
      {
              if (index > m_sizeofp1 + m_sizeofp2)
              {
                      throw std::out_of_range("out_of_range");
              }
              if (index<m_sizeofp1)
              {
                      return m_p1[index];
              }
              else
              {
                      return m_p2[index - m_sizeofp1];
              }
      }
      size_t size() const
      {
              return m_sumsize;
      }
      iterator begin()
      {
              return iterator(this,0);
      }
      iterator end()
      {
              return iterator(this,m_sumsize);
      }
protected:
private:
        T *m_p1;
        T *m_p2;
        size_t m_sizeofp1;
        size_t m_sizeofp2;
        size_t m_sumsize;
};

int _tmain(int argc, _TCHAR* argv[])
{
        int p1[] = {1,6,3,123456,2,67,2,8};
        int p2[] = {4,2,6,234,9,4,0,5};
        Obj<int> h(p1 , sizeof(p1)/sizeof(*p1) , p2 , sizeof(p2)/sizeof(*p2));
        std::copy(h.begin() , h.end() , std::ostream_iterator<int>(std::cout," "));
        std::cout<<std::endl;
        std::sort(h.begin() , h.end());
        std::copy(h.begin() , h.end(),std::ostream_iterator<int>(std::cout,"\n"));
        return EXIT_SUCCESS;
}

 


这段程序在我的vs2008上正确编译执行。

posted on 2009-08-20 10:06 HIT@ME 阅读(1809) 评论(4)  编辑 收藏 引用

FeedBack:
# re: 成功在自己的类中加入random_access_iterator,但也遇到新的问题。
2009-08-20 12:28 | OwnWaterloo
template<typename T>
class Obj;

template<typename T>
class Obj_iteator { ... };

template<typename T>
class Obj { ... };

这样吗?  回复  更多评论
  
# re: 成功在自己的类中加入random_access_iterator,但也遇到新的问题。[未登录]
2009-08-20 13:50 | HIT@ME
@OwnWaterloo
哎,我大脑进水了。在类中声明obj_iterator的时候居然忘记加类型说明了。现在编译通过了。谢谢啊~!  回复  更多评论
  
# re: 成功在自己的类中加入random_access_iterator。
2009-08-20 16:56 |
好东西  回复  更多评论
  
# re: 成功在自己的类中加入random_access_iterator。
2009-08-21 17:20 | 乐蜂网
不错啊  回复  更多评论
  

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


<2009年8月>
2627282930311
2345678
9101112131415
16171819202122
23242526272829
303112345

常用链接

留言簿(5)

随笔档案

test

搜索

  •  

最新评论

阅读排行榜

评论排行榜