Essential C++学习记录&笔记整理26（打造一个Iterator Class）

浅浅的花香味﹌ 2023-03-13 02:13 16阅读 0赞

## 打造一个Iterator Class ##

### 目录 ###

*   *  打造一个Iterator Class
     *   *  运算符重载
         *  嵌套类型

*  这一节讲了运算符重载的相关知识，以及嵌套类型（typedef）

### 运算符重载 ###

*  泛型指针类的运算，肯定不能用正常的内置类型的那种运算符。为什么?这是规定！此时我就需要运算符重载，怎么运算符重载呢？
 *  运算符重载，说白了就是我重新定义**原有的运算符**以适合泛型指针类的运算。我可以像**定义成员函数**那样重新定义运算符。
 *  运算符函数很像普通函数，但是运算符函数不用指定函数名。**只需要在运算符前加上关键字operator即可**，如：

class Triangular_iterator
    {
        
    public:
    	//为了不要在每次访问元素的时候都执行-1操作
    	//此处将_index的值设为index-1（就是贴合数组的逻辑次序）
    	Triangular_iterator(int index):_index(index-1){
        }
    	//构造函数（采用类成员的初始化语法——成员初始化列表这种形式）
    	bool operator==(const Triagnular_iterator&)const;
    	bool operator!=(const Triangular_iterator&)const;
    	int operator*()const;
    	Triangular_iterator& operator++();//前置++版
    	Triangular_iterator operator++(int);//后置++版
    	//运算符重载
    private:
    	void check_integrity()const;
    	int _index;

Triangular\_iterator的作用：维护索引值\_index，用以索引Triangular中存储数列元素的静态数据成员(\_elems)，为达到此作用，Triangular类必须赋予Triangular\_iterator的成员函数特殊访问权限。利用友元机制来给予这种特殊权限。

*  下面说明一下运算符函数的定义：

//如果两个Triangular_iterator对象的索引值（_index)相等，这两个对象相等。
    inline bool Triangular_iterator::
    operator==(const Triangular_iterator &rhs)const
    {
        
    	return _index==rhs._index
    }
    //如果==右侧的索引值等于==左侧的索引值，返回true，否则返回false

在重载运算符以后，我们可以直接用于类对象之间啦！

if(trian1==trian2)//...
    //trian1和trian2都是Triangular类（或其它类）

如果我想将重载后的运算符作用于**指针所指的类对象**，我就要提领该指针（该指针是Triangular类（或其它类）

if(*ptr1==*ptr2)//...

再说一下!=运算符函数的定义吧（重载!=运算符）

inline bool Triangular_iterator::
    operator!=(const Triangular_iteragor &rhs)const
    {
        
    	return !(*this==rhs);//该this指针自动代表左操作数
    }
    //运用了this指针的写法。另一种写法，要用索引的话，我就写 
    //return ！（_index==rhs._index）;

*  好的，说下运算符重载的规则：  
    ①**不可以引入新的运算符**（比如!!、.?、\*%这种不是人写的运算符）。除了`.\.*\::\?:`四个运算符，其他的运算符都可以被重载  
    ②**运算符操作数个数不能变**。你别==、！=这种二元运算符你重载成一元运算符，别放狗屁  
    ③**运算符优先级不可变**  
    ④**运算符函数的参数列表中，必须至少有一个参数为class类型**。什么意思呢，我们没法给指针这种**非类类型**重载运算符，也不能给它引进新运算符，这会乱套，打破语法规则！万万不可！
 *  运算符的定义方式，你可以选择以成员函数的定义方式，亦或非成员函数的定义方式，成员函数的定义方式你自己去看上面的==、！=运算符函数的定义。我这里说明一下非成员函数的定义方式（重载运算符的运算符函数定义方式）：

inline int  operator*(const Triangular_iterator)
    {
        
    	rhs.check_integrity();
    	//如果这是一个非成员函数，就没有访问私有成员的权利。
    	return Triangular::_elems[_index];
    }

非成员函数形式定义的运算符的参表中，会比成员函数形式定义的运算符多出一个参数，即**this指针**（该this指针自动代表左操作数）

*  递增运算符（++）的前置后置版本的重载：

inline Triangular_iterator& Triangular_iterator::
    operator++()
    {
        
    	//前置版本
    	++_index;
    	check_integrity()://该函数确保索引值不大于数列（容器）的最大规定长度，确保容器存储对的元素
    	return *this;
    }

好，我解释一下，我们知道前置递增运算符，先让变量（或类对象）+1，再将+1后的变量（或类对象）作为++表达式的值。这里的运算符函数定义就是如此，**增加当前类对象的索引值，并返回当前类对象，也就是增加了索引值后的类索引的对象**。this指针自动指向使用这个重载运算符的类对象。

inline Triangular_iterator Triangular_iterator::
    operator++(int)
    {
        
    	//后置版本
    	Triangular_iterator tmp=*this;
    	//因为索引值要+1，但后置版本的++表达式是不会变的，也就是
    	//原类对象的值作为后置版本的++表达式的值
    	++_Index;
    	check_integrity();
    	return tmp;
    }

我们知道后置递增运算符，先让变量（或类对象）作为++表达式的值，再让变量（或类对象）+1。也就是**增加当前类对象的索引值，并返回增加索引值之前的类对象。因为要符合内置运算符的的规则，故需要备份调用的类对象。**  
参表里的int参数，我们不用管，编译器会自动给后置版产生一个值为0的int参数。

### 嵌套类型 ###

typedef关键字：

typedef 内置类型/复合类型/class类型 new_name;
    //new_name是该类型的别名

使用说明如上。不多解释，C语言用了八百回了。  
还是举个例子：

typedef Triangular_iterator iterator;
    //Triangular_iterator是一个类，前面的代码提到过。
    iterator it=trian.begin();
    //这么写就错了，必须要用到::,以便让编译器知道iterator这个字眼背后代表的某个类内部提供的定义。
    Triangular::iterator it=trian.begin();
    //对的写法，这是定义一个泛型指针对象的写法。
    Fibonacci::iterator ift=fib.begin();
    Pell::iterator pit=pel.begin();
    vector<int>::iterator vit=_elems.begin();
    string::iterator sit=file_name.begin();
    //把iterator这个(用typedef再定义）的类型的别名放在每个
    //"提供iterator抽象概念“的类内，就可以提供有着相同名称的多个定义。

> 任何声明变量的语句前面加上typedef之后，原来是变量的都变成一种类型。摘自https://blog.csdn.net/hai008007/article/details/80651886

书上说的很迷，我的理解是经过typedef后这里的iterator是一个类的别名，其实iterator成为了类型名了因为有了typedef让iterator代替了Triangular\_iterator这个类（假如你再定义Triangular\_iterator的类对象，你就可以iterator a;）让iterator去定义Triangular\_iterator类的类对象（**不管怎么说，typedef Triangular\_iterator iterator;就让Triangular\_iterator和iterator等价了！**），所以你可以说iterator成了一种嵌套类型了。（参照上面的引用）  
然后你就可以定义iterator类对象。但是你得让这个iterator类对象的类型和它指向的类对象的类型一致。  
嗯，你就记住typedef的作用是省事，把大长类型名用`typedef 大长类型名 小短类型名;`给代替掉就行了，小短类型名就从只是个名字变成了一个类型——我们称小短类型，小短类型代表的类型是大长类型名的类型，所以我们称小短类型是嵌套类型。