当前位置:编程学习 > C/C++ >>

STL,迭代器的C++简单实现

[cpp] 
// Iterator.cpp : 定义控制台应用程序的入口点。  
//  
  
#include "stdafx.h"  
#include <Windows.h>  
#include <iostream>  
#include <string>  
#include <memory>  
using namespace std;  
// 对于C++,STL中已经包含迭代器的实现了  
// 就不再单独造车轮了  
  
  
// 部分代码见【STL源码剖析】  
  
  
// 来一个智能指针的示意  
namespace TEST  
{  
  
template<class T>  
class auto_ptr  
{  
public:  
    // 显示构造函数  
    explicit auto_ptr(T *p = NULL) : pointee(p){}  
    template<class U>  
    auto_ptr(auto_ptr<U>& rhs) : pointee(rhs.release()){}  
    ~auto_ptr() {delete pointee;}  
  
    template<class U>  
    auto_ptr<T>& operator=(auto_ptr<U>& rhs)  
    {  
        if (this != &rhs)  
        {  
            reset(rhs.release());  
            return *this;  
        }  
    }  
  
    T& operator*() const  
    {  
        return *pointee;  
    }  
    T* operator->() const  
    {  
        return pointee;  
    }  
    T* get() const  
    {  
        return pointee;  
    }  
protected:  
    T* release()  
    {  
        T *p = new T;  
        memcpy(p, pointee, sizeof(T));  
        delete this;  
        return p;  
    }  
    void reset(T *p)  
    {  
        if (pointee)  
        {  
            delete pointee;  
            pointee = NULL;  
        }  
        pointee = p;  
    }  
private:  
    T *pointee;  
};  
  
}  
  
  
  
  
// 智能指针的示例  
// 申请的内存不需要释放,没有内存泄露  
void func()  
{  
    TEST::auto_ptr<string> ps(new string("Hello"));  
    cout<< *ps <<endl;  
    cout<< ps->size() <<endl;  
}  
  
namespace TEST  
{  
  
template<typename T>  
class ListItem  
{  
public:  
    ListItem(T vl)  
        : _value(vl)  
        , _next(NULL)  
    {  
          
    }  
    T value() const {return _value;}  
    ListItem *next() const {return _next;}  
    void SetNext(ListItem<T> *p){_next = p;}  
  
private:  
    T           _value;  
    ListItem    *_next;  
  
};  
  
  
// 迭代器是一种智能指针  
template<typename T>  
class List  
{  
public:  
    List()  
    {  
        ListItem<T> *a = new ListItem<T>(0);    // 没有析构哦  
        _front = a;  
        _front->SetNext(NULL);  
        _size = 0;  
    }  
    void            insert_end(T value);  
    void            display(std::ostream &os = std::cout) const;  
    ListItem<T> * front(){return _front;}  
    ListItem<T> * end()  
    {  
        ListItem<T> *end = _front;  
        while(1)  
        {  
            if (end->next())  
            {  
                end = end->next();  
            }  
            else  
            {  
                break;  
            }  
        }   
        return end;  
    }  
private:  
    ListItem<T> *_front;  
    long _size;  
};  
  
template<typename T>  
void TEST::List<T>::display( std::ostream &os /*= std::cout*/ ) const  
{  
    ListItem<T> *end = NULL;  
    end =  _front->next();  
    ListItem<T> *before = _front;  
    do   
    {  
        os<<end->value()<<endl;  
        end = end->next();  
    } while (end);  
}  
  
  
// 因为只保留了链表头,所以插入操作很纠结,比较失败  
template<typename T>  
void TEST::List<T>::insert_end( T value )  
{  
    ListItem<T> *node = new ListItem<T>(value);  
  
    ListItem<T> *end = this->end();  
  &n
补充:软件开发 , C++ ,
CopyRight © 2022 站长资源库 编程知识问答 zzzyk.com All Rights Reserved
部分文章来自网络,