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

最新推荐文章于 2024-06-30 15:15:21 发布
最新推荐文章于 2024-06-30 15:15:21 发布
阅读量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());
}






程序员必须掌握的600个英语单词
Sapphire521的博客
07-21 1740
partialspecialization偏特化（ref.C++Primer3/e,16.10）局部特化######（ref.fullspecialization）calloperatorcall（函式呼叫）运算子调用操作符######（同functioncalloperator）constructor（ctor）建构式构造函数######（与class同名的一种memberfunctions）......
计算机编程 英语词汇
ZJQ的博客
01-03 1064
radius ：半径 Slate：石板，写字板 Canvas：画布 Airbrush：气笔，喷枪 fountain： found：建立，从下向上： 喷泉。 压力值：Pressure value BrushesPlotter： 刷子， 绘图仪 画板。 Stroke:(打、击等的)一下 Strokes:笔画 platform---平台 version---版本 proje...
C++ 练习使用重载操作符封装Iterator
最新发布
weixin_63162063的博客
06-30 221
赋值---operator=，判断是否相等operator== operator!=，间接引用取值 operator*，向后移动 operator++。学过链表和重载操作符之后，我们就可以写一个链表的迭代器，方便我们使用链表。
STL运用的C++技术（5）——重载操作符
wuzhekai的专栏
08-04 6068
STL是C++标准库的重要组成部分之一，它不仅是一个可复用的组件库，更是一个包含算法与数据结构的软件框架，同时也是C++泛型编程的很好例子。STL中运用了许多C++的高级技术。本文介绍重载操作符。主要参考了《C++ Primer》和《STL源码剖析》。
运算符重载，迭代器
u012698962的专栏
10-05 2464
【1】 bool operator > (const Book &p) const { return p.isbn < isbn; } 是对运算符 > 的重载 ，const Book &p 是 对类Book 的引用 &p，p.isbn 【2】 在STL中，如果要将自定义的类型放入到set中的话，就需要重载“ 假设现在设计如下类型： 这时，为了让MyType类型可以顺利地放进s
运算符重载，以及迭代器[foreach]示例
weixin_33877092的博客
12-16 143
 以下代码来源于"c#高级编程(第4版)"，只不过我对它做了一些注释和修改 using System; using System.Collections; using System.Text; namespace Wrox.ProCSharp.VectorAsCollection {     class MainEntryPoint     {         static...
string迭代器和运算符重载
landscape 南北——的博客
08-31 179
知识点： 手动实现字符串的strlen，strcpy，strcat，strcmp重载字符串之间的+，!=，==，+=等运算符。 同样存储字符串使用的是动态数组！！！ #include<iostream> #include <string.h> namespace { //str == str1 //str != str1 //str + str1 //str += str1 //str + "Hello" class String { //friend Str
侯捷老师整理||IT专业术语中英对照表
qq_37097507的博客
06-23 2012
侯捷老师整理||IT专业术语中英对照表 百度文库的原文，侯捷老师整理的中英单词，真的对我们学习很有帮助 由于老师的网站已经失效了，所以就是从网上搜索来的，没有注明转载。 一群性质相近同的「东西」，如果译名一贯，阅读的感觉就很好。 一贯性的术语，扩充性高，延伸性高，系统化高。 ————by侯捷 一群性质相近同的「东西」，如果译名一贯，阅读的感觉就很好。 一贯性的术语，扩充性高，延伸性高，系统化高。 ● 我喜欢「式」： constructor 建构式 declarat
编程常用英语词汇大全
热门推荐
weixin_33935777的博客
03-08 1万+
编程常用英语词汇大全 很实用的编程英语词库，共收录一千五百余条词汇。 第一部分： application 应用程式 应用、应用程序 application framework 应用程式框架、应用框架 应用程序框架 architecture 架构、系统架构 体系结构 argument 引数（传给函式的值）。叁见 parameter 叁数、实质叁数、实叁、自变量 array 阵列 数组 ...
python中常用英文单词
python学习者的博客
12-13 2322
application 应用程式 应用、应用程序 application framework 应用程式框架、应用框架 应用程序框架 architecture 架构、系统架构 体系结构 argument 引数（传给函式的值）。叁见 parameter 叁数、实质叁数、实叁、自变量 array 阵列 数组 arrow operator arrow（箭头）运算子 箭头操作符 assembly 装配件 a...
C++ 重载解引用_迭代器
Sico2Sico
03-30 2277
C++ 重载解引用_迭代器
迭代器相关的运算重载符
进入python的世界-killeri
10-18 749
__iter__和__next__是在类中自动实现迭代协议的运算重载符。 例如： class square: def __init__(self, start, stop): self.value = start -1 self.stop = stop def __iter__(self): return self def __next__(self): if self.v...
12月2日笔记C++7_运算符重载典型应用-迭代器
CW_qian的博客
12-02 580
运算符重载典型应用-迭代器迭代器模式： 在不暴露一个对象的内部实现的情况下，提供一种方式，能顺序访问对象的数据元素的 一般情况下，把能存放其它对象的对象，称为 容器对象，如链表、数组等 在C++中，可以把容器的遍历机制封装成一个对象，称之为 迭代器 C++的容器类型都应该提供自己的迭代器类型，其中封装了一个指针和一组运算符函数 同时，容器类型 还需要提供begin和 end 两个专门的接口 通过 begin() 获取容器的首元素迭代器，通过end()确定...
迭代器中解引用操作符的重载
Accelerator12138的博客
10-21 798
在机械工业出版社出版的这本数据结构、算法与应用中，为链表制作了一套迭代器，其中关于解引用操作符（*和->）的重载，书上的代码如下： T& operator*() const { return node->element; } T* operator->() const { return &node->element; } 背景大概就是在这之前写了一个类chainNode代表链表结点，有element和next两个元素，而node是迭代器类中的chainNode&lt
530-C++运算符的重载(复数类和string类的实现,迭代器基础)
LINZEYU666的博客
09-08 375
C++的运算符重载 使对象的运算表现得和编译器内置类型一样 template<typename T> T sum(T a, T b) { return a+b;//a.operator+(b) } 如果T是编译器的内置类型的话，编译器对a+b是可以做的。 但是如果T是我们自定义的对象类型，a和b是两个对象，对象和对象之间该怎么相加？？？编译器是不知道的。 这里就要使用运算符的重载了。 return a+b;//a.operator+(b) 加法运算符的重载函数。 复数类的实现(运算符重载)
C++实现带赋值运算符重载函数和迭代器的String类
qq_24336773的博客
01-19 457
该类实现了C++中string类中定义的基本方法，可以看出其类似于容器。#include using namespace std; class CString { public: //带一个默认值参数的构造函数 CString(const char *p = NULL) { if(p == NULL) { mptr = new char[1]; // new char()
list容器模拟实现（二）—— 迭代器遍历数据(含++、*、=运算符的重载)
challenglistic的博客
04-16 1987
手动模拟实现list容器的迭代器，并使用迭代器遍历数据
STL—Iterator的分类和copy的重载及其使用
Kevinonlie的博客
04-29 786
Iterator是什么 简单的来说，iterator是C++中容器的访问接口，不需要关心容器内如何实现的，这和容器适配器很相似，容器适配器给出相应的接口可以使得Stack用Vector进行底层实现 ...
197-C++运算符的重载（vector容器的迭代器iterator实现）
Edward_LF的博客
05-12 2685
1、初步在自定义vector类中实现迭代器 1.1、迭代器定义 迭代器示意图： 为什么迭代器遍历所有容器方式都是一样？ 因为迭代器遍历完当前元素跳到下一个元素，底层数据结构的具体的遍历方式都封装在这个迭代器的++运算符函数了； 所以，作为使用方，我们不需要知道底层的数据结构原理； 我们只知道底层数据元素的遍历都封装在++运算符重载函数里面。 1.2、自定义vector类中 实现迭代器 在之前实现的vector基础上，继续完善！ 1、‘[]’ 重载函数 2、迭代器初步实现 迭代器一般实现成容器的嵌套
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值