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

于 2015-07-29 16:27:37 发布
阅读量1.8k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： STL C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kai8wei/article/details/47127533
本文深入探讨了C++中灵巧指针和迭代器的概念，通过具体代码实例展示了如何封装指针和迭代器来访问数据结构中的数据，以及它们在实际编程中的优势。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

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

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

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

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

下面是一个简单的迭代器的使用：


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

class IntStack
{
public:
	IntStack():top(0)
	{
	}
	void push(int i)
	{
		assert(top<=size);
		stack[top++] =i;
	}
	int Pop()
	{
		assert(top>0);
		return stack[--top];
	}
	friend class iter;
private:
	enum{size = 100};
	int stack[size];
	int top;
};

class  iter//迭代器，类似于对指针的封装
{
public:
	iter(IntStack& is):s(is),index(0){}
	int operator++()
	{
		assert(index<s.top);
		return s.stack[++index];
	}
	int operator++(int)
	{
		assert(index <s.top);
		return s.stack[index++];
	}
private:
	IntStack &s;
	int index;
};

void main()
{
	IntStack s;
	for(int i=0;i<20;++i)
	{
		s.push(i);
	}
	iter it(s);
	for(int j=0;j<20;++j)
	{
		cout<<it++<<endl;
	}
}

下面是一个内嵌的迭代器：（STL中也是内嵌的哟）

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

class IntStack
{
public:
	IntStack():top(0)
	{
	}
	void push(int i)
	{
		assert(top<=size);
		stack[top++] =i;
	}
	int Pop()
	{
		assert(top>0);
		return stack[--top];
	}
	class iter;
	friend class iter;
	class iter
	{
	public:
		iter(IntStack& is):s(is),index(0){}
		iter(IntStack& is,bool):s(is),index(is.top){}
		T operator*()  {return s.stack[index-1];}//T current() { return s.stack[index-1];}
              T operator++()
		{
			assert(index<s.top);
			return s.stack[++index];
		}
		int operator++(int)
		{
			assert(index <s.top);
			return s.stack[index++];
		}
		iter& operator+=(int amount)
		{
			assert((index+amount) <s.top);
			index+=amount;
			return *this;
		}
		bool operator==(const iter& rv)const{ return this->index==rv.index;}
		bool operator!=(const iter& rc)const{return this->index!=rc.index;}
	   friend ostream& operator<<(ostream&os,const iter &it)
		{
			return os<<*it;//return os<<it.current();
		}
	private:
		IntStack &s;
	    int index;
	};
	iter begin(){return iter(*this);}
	iter end(){return iter(*this,true);}
private:
	enum{size = 100};
	int stack[size];
	int top;
};



void main()
{

	IntStack s;
	for(int i=0;i<20;++i)
	{
		s.push(i);
	}
	IntStack::iter it=s.begin();
	while(it != s.end())
	{
		cout<<it++<<endl;
	}
	IntStack::iter start=s.begin();
	IntStack::iter end = s.end();
	start+=5;
	cout<<"start= "<<start<<endl;
     cout<<"end= "<<end<<endl;
}

下面是一个模版化后的简单迭代器：（实现泛型）

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

template<class T,int size=100>
class Stack
{
public:
	Stack():top(0)
	{
	}
	void push(const T& i)
	{
		assert(top<size);
		stack[top++] =i;
	}
	int Pop()
	{
		assert(top>0);
		return stack[--top];
	}
	class iter;//声明迭代器
	friend class iter;//是迭代器成为一个友元类
	class iter
	{
	public:
		iter(Stack& is):s(is),index(0){}
		iter(Stack& is,bool):s(is),index(is.top){}
		T current()const {return s.stack[index-1];}
		T operator++()
		{
			assert(index<s.top);
			return s.stack[++index];
		}
		T operator++(int)
		{
			assert(index <s.top);
			return s.stack[index++];
		}
		iter& operator+=(int amount)
		{
			assert((index+amount) <s.top);
			index+=amount;
			return *this;
		}
		bool operator==(const iter& rv)const{ return this->index==rv.index;}
		bool operator!=(const iter& rc)const{return this->index!=rc.index;}
		friend std::ostream& operator<<(std::ostream&os,const iter &it)
		{
			return os<<it.current();
		}
	private:
		Stack &s;
	    int index;
	};
	iter begin(){return iter(*this);}
	iter end(){return iter(*this,true);}
private:
	T stack[size];
	int top;
};



void main()
{

	Stack<int> s;
	for(int i=0;i<20;++i)
	{
		s.push(i);
	}
	Stack<int>::iter it=s.begin();
	while(it != s.end())
	{
		cout<<it++<<endl;
	}
	Stack<int>::iter start=s.begin();
	Stack<int>::iter end = s.end();
	start+=5;//可以跳跃到第五个
	cout<<"start= "<<start<<endl;
     cout<<"end= "<<end<<endl;
	
	 Stack<string> str;
	 string ss[]={"1,2,3,4,5","a,b,c,d,r"};
   for(int j=0;j<sizeof(ss)/sizeof(*ss);++j)
   {
	   str.push(ss[j]);
   }
   Stack<string>::iter sit=str.begin();
   Stack<string>::iter sit1=str.end();
   while(sit!=sit1)
   {
	   cout<<sit++<<endl;
   }
}

又是一个泛型编程：

/**********************************************************************     
* *   Copyright (c)2015,WK Studios   
* *   Filename:  Pstash.h 
* *   Compiler: GCC  vc 6.0    
* *   Author:WK     
* *   Time: 2015 1,8  
* **********************************************************************/  

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

template<class T,int incre=20>
class Pstash
{
	public:
		Pstash():quantity(0),storage(0),next(0){}
		~Pstash();
		int add(T* ele);
		T* operator[](int index)const;
		T* remove(int index);
		int count()const{return next;}
		class iter;
		friend iter;
		class iter
		{
		public:
			iter(Pstash &p):ps(p),index(0){}
			iter(Pstash& p,bool):ps(p),index(ps.next){}
			iter(const iter& rv):ps(rv.ps),index(rv.index){}
			iter& operator=(const iter& rv)
			{
				if(&rv != this)
				{
				ps = rv.ps;
				index = rv.index;
				}
				return *this;
			}
			iter& operator++()
			{
				assert(++index <= ps.next);
				return *this;
			}
			iter& operator++(int)
			{
				return operator++(); 
			}
			iter& operator--()
			{
				assert(--index >= 0);
				return *this;
			}
			iter& operator--(int)
			{
				return operator--();
			}
         iter& operator+=(int amount)
		 {
			 assert(index+ amount <ps.next && index +amount>=0);
			 index += amount;
			 return *this;
		 }
		 iter& operator-=(int amount)
		 {
			 assert(index - amount <ps.next && index -amount >=0)
			 index -= amount;
			 return *this;
		 }
		 iter operator+(int amount)const
		 { 
			 iter tmp(*this);
			 tmp+=amount;
			 return tmp;
		 }
		 T* current()const
		 {
			 return ps.storage[index];
		 }
               T* operator*()const
		 {
              return current();
		 }
		 T* operator->()const
		 {
			 assert(ps.storage[index] != 0);
			 return current();
		 }
          T* remove()
		  {
			  return ps.remove(index);
		  }

		  bool operator==(const iter& rv)const
		  {return index == rv.index; }
		  bool operator !=(const iter& rv)const
		  {return index != rv.index;}
		private:
			Pstash &ps;
			int index;
		};  
		iter begin()
		{
			return iter(*this);
		}
		iter end()
		{
			return iter(*this,true);
		  }
	private:
		int quantity;
		int next;
		T** storage;
		void inflate(int increase=incre);
};

template<class T,int incre>
Pstash<T ,incre>::~Pstash()
{
	for(int i=0;i<this->next;++i)
	{
		delete storage[i];
		storage[i]=0;
	}
	delete []storage;
}

template<class T,int incre>
int Pstash<T,incre>::add(T* ele)
{
	if(next >= quantity)
		inflate();
	storage[next++] = ele;
	return (next -1);
}

template<class T,int incre>
inline T*  Pstash<T,incre>::operator[](int index)const
{
 assert(index >= 0);
 if(index >= next)
	 return 0;
 assert(this->storage[index] !=0 );
 return storage[index];
}

template<class T,int incre>
T* Pstash<T,incre>::remove(int index)
{
 T* v =operator[](index);
 storage[index] = 0;
 return v;
}

template<class T,int incre>
void Pstash<T,incre>::inflate(int increase)
{
	const int tmp = sizeof(T*);
	T** st = new T*[quantity+ increase];
	memset(st,0,(quantity+increase)*tmp);
	memcpy(st,storage,quantity*tmp);
	delete []storage;
	storage = st;
	quantity += increase;
}

class Int
{
public:
	Int(int a=0):i(a)
	{
		cout<<"Int()\n";
	}
	~Int()
	{
		cout<<"~Int()\n";
	}
	operator int()const{ return i;}
	friend ostream&
	operator<<(ostream &os,const Int&ii)
	{
		return os<<"Int operator<<()"<<ii.i<<endl;;	
	}
	friend ostream&
		operator<<(ostream &os,const Int*x)
	{
		return os<<"Int op()"<<x->i<<endl;
	}
private:
	int i;
};



void main()
{
 Pstash<Int> ints;

 for(int i=0;i<20;++i)
 {
	 ints.add(new Int(i));
 }
 
  Pstash<Int>::iter it =ints.begin();
   it+=5;
   Pstash<Int>::iter it2 = it+10;
   for(; it != it2;++it)
   {
	   delete it.remove();//把第6个到第11个置0
   }

   for(it = ints.begin();it != ints.end();++it)
   {
	   if(*it)
		   cout<<*it<<endl;//调用*号重载
   }

}

#include "Pstash.h"

class shape
{
public:
	virtual void draw()=0;
	virtual void ease()=0;
	virtual ~shape(){}
};
class Circle:public shape
{
public:
	Circle()
	{
		cout<<"Circle()\n";
	}
	~Circle()
	{
		cout<<"~Circle()\n";
	}
	void draw()
	{
		cout<<"Circle:: draw()\n";
	}
	void ease()
	{
		cout<<"Circle::ease()\n";
	}

};

class Drawing :public Pstash<shape>
{
public:
	~Drawing()
	{
		cout<<"~Drawing()\n";
	}

};

template <class TT>
void drawAll(TT start,TT end)
{
	while(start != end)
	{
		(*start)->draw();
		start++;
	}
}
void main()
{

	Drawing d;
	d.add(new Circle);
	d.add(new Circle);
	cout<<"Drawing d:\n";
	drawAll(d.begin(),d.end());
}






评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值