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();
		
	}
}

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

标签：

原文地址：http://blog.csdn.net/kai8wei/article/details/47127533