迭代器

迭代器的编写Cstring 嵌套类(访问私有成员) 类似普通指针 遍历容器

#include<iostream>
#include<string>
using namespace std;

class Cstring
{
public:
    Cstring(char *p=NULL)//构造函数 带一个参数或不带参数的构造 
    {
        if (p != NULL)
        {
            mpstr=new char[strlen(p)+1];
            strcpy(mpstr,p);
        }
        else
        {
            mpstr=new char[1];
            *mpstr=0;
        }
    }
    Cstring(const Cstring &src)//因为会发生浅拷贝 所以需要自己定义拷贝构造函数
    {
        mpstr =new char[strlen(src.mpstr)+1];
        strcpy(mpstr,src.mpstr);

    }
    Cstring & operator=(const Cstring &src)//赋值运算符重载
    {
        if (this == &src) //防止自赋值
        {
            return *this;
        }

        delete []mpstr; //释放原来空间
        mpstr=NULL;

        mpstr = new char[strlen(src.mpstr) + 1];
        strcpy(mpstr,src.mpstr);
        return *this;
    }
    ~Cstring()//析构
    {
        delete []mpstr;
        mpstr=NULL;
    }
    bool operator >(const Cstring &src)//大于运算符的重载
    {
        return strcmp(mpstr,src.mpstr) > 0 ? true:false;
    }

    bool operator <(const Cstring &src)//小于运算符的重载
    {
        return strcmp(mpstr,src.mpstr) < 0 ? true:false;
    }

    bool operator == (const Cstring &src)//等于运算符的重载
    {
        return strcmp(mpstr,src.mpstr) == 0 ? true:false;
    }

    //求字符串长度大小
    unsigned int size()const{return strlen(mpstr);}

    //[]运算符的重载函数  [] * -> 一般都实现两种方法 普通方法和常方法

    char & operator[](int i){ return mpstr[i];}

    //这里char & 之前加const 主要是因为防止参数被修改 只读的“hello”字符串常量不能被修改
    const char & operator[](int i)const {return mpstr[i];}


    //返回当前指针
    const char * c_str()const{return mpstr;}
    //解引用重载
    char operator *()
    {
        return *mpstr;
    }
    const char operator *()const
    {
        return *mpstr;
    }
    class Citerator//迭代器
    {
    public:

        Citerator(Cstring *p=NULL,int pos=0):mpiter(p)
        {  
               mindex=mpiter->mpstr+pos;
        }
        void operator++()
        {
            ++mindex;
        }
        char& operator *(){return *mindex;}
        const char& operator *()const {return *mindex;}
        //这里的不等于是所指的位置不相等，而不是解引用的值不相等
        bool operator !=(const Citerator &src){return mindex != src.mindex ? true:false;}
    private:
        Cstring *mpiter;//类类型指针，指向该对象的指针，指向要操作的对象
        char *mindex;  //用户使用类型的指针，指向目前所在位置的下标
    };

    Citerator begin(){return Citerator(this,0);}
    Citerator end(){return Citerator(this,strlen(mpstr));}

    typedef Citerator iterator; //类型重定义

private:
    char* mpstr;
    friend ostream& operator<<(ostream &out, const Cstring &src);
};
ostream& operator<<(ostream &out, const Cstring &src)
{
    out << src.mpstr;
    return out;
}


int main()
{
    Cstring str10("helloworld");
    Cstring::iterator it =str10.begin(); //这里的it是指针
    for ( ; it != str10.end();++it)
    {
        cout<< *it <<" "; // it.operator*()
    }
    cout<<endl;
}