STL(1)---从对->运算符的重载到灵巧指针再到迭代器

首先->也就是指针间接引用运算符一定是 一个成员函数，必须返回值是一个对象或者对象的引用，或者必须返回一个指针，被用于选择指针间接引用运算符箭头所指的内容

所谓灵巧指针就是一个对象表现的像一个指针，这时候这个指针比一般的指针具有与生俱来的灵巧性，常称作灵巧指针

所谓迭代器就是一个对指针进行封装的结构，通过对指针封装从而对数据结构中的数据进行访问，从而使指针不直接接触数据，既安全有方便用户

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

class Obj//基本的数据类
{
public:
	void f()const
	{
		cout<<i++<<endl;
	}
	void g()const
	{
		cout<<j++<<endl;
	}

private:
	static int i,j;
};

int Obj::i=47;
int Obj::j=11;

class Objcontainer//类的容器
{
public:
	void add(Obj* obj)
	{
		a.push_back(obj);
	}
	friend class SmartPointer;
private:
	vector<Obj*> a;//使用向量类建立一个动态数组obj的对象指针
};
class SmartPointer//灵巧指针
{
private:
	Objcontainer &oc;//容器类的一个对象引用
	int index;//数组索引号
public:
	SmartPointer(Objcontainer &objc):oc(objc),index(0)
	{

	}
	void require(bool b,char*c="ERRO")const
	{
		if(!b)
		{
			cout<<c<<endl;
		}
	}
	bool operator++ ()//负责向后移动这个是对象当作指针的对象
	{
		if(index >= oc.a.size())
			return false;
		if(oc.a[++index]==0)
			return false;
		return true;
	}
	bool operator++(int)
	{
		return operator++();
	}
	Obj* operator->()const //实现对象当作指针
	{
		require((oc.a[index]) != 0,"Zero value");
		cout<<"operator->()\n";
		return oc.a[index];
	}
};

void main()
{
   const int sz =10;
   Obj o[sz];
   Objcontainer oc;
   for(int i=0;i<sz;++i)
   {
	   oc.add(&o[i]);
   }
 SmartPointer sp(oc);
 while(sp++)//调用++重载
 {
	 sp->f();//调用->重载
	 sp->g();

 }
}

上边这个程序就是通过一个类将指针封装，从而使用友员类是各类之间建立联系，从未使用封装指针的类所产生的对象通过内部貌似指针的用法访问数据

下面这个是将封装的指针类内嵌如类中实现灵巧指针

#include <iostream>
#include<vector>
#include <assert.h>
using namespace std;

class obj
{
private:
static int i,j;
public:
	void f()
		{
			cout<<i++<<endl;
		}
		void g()
		{
			cout<<j++<<endl;
		}
};

int obj::i=47;
int obj::j=11;

class objcontainer
{
private:
	vector<obj*>a;
public:
	void add(obj* oj)
	{
		a.push_back(oj);
	}
	class SmartPointer;
	friend SmartPointer;
	class SmartPointer//灵巧指针嵌入类中
	{
	public:
		SmartPointer(objcontainer &oj):oc(oj),index(0)
		{
			cout<<"SmartPointer()\n";
		}
		bool operator++()
		{
			if((index >= oc.a.size())||(oc.a[++index]==0))
				return false;
			return true;
		}
		obj* operator->()const
		{
             assert(oc.a[index] != 0);
			 cout<<"operator->()\n";
			 return oc.a[index];
		}

	private:
		objcontainer &oc;
		size_t index;
	};
	SmartPointer begin()
	{
		return SmartPointer(*this);
	}
};
void main()
{
	const int sz =10;
	obj o[sz];
	objcontainer oc;
	for(int i=0;i<sz;++i)
	{
		oc.add(&o[i]);
	}
	objcontainer::SmartPointer sp = oc.begin();
	while(sp++)//调用++重载
	{
		sp->f();//调用->重载
		sp->g();

	}
}

从这两个代码中是否可以嗅到迭代器的味道？？

版权声明：本文为博主原创文章，未经博主允许不得转载。