c++的vector容器的自我实现

最新推荐文章于 2024-08-08 17:06:25 发布
最新推荐文章于 2024-08-08 17:06:25 发布
阅读量242 收藏
点赞数
分类专栏： 数据结构 c/c++ 文章标签： c 自定义类 数据结构 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_Super_Mouse/article/details/84868993
版权

实现代码

 

#pragma once
#include <windows.h>
template<class T>
class Myvector
{
	T *pBuff;
	size_t num;
	size_t maxNum;
public:
	struct MyIterator
	{
		T *pIt;
		MyIterator& operator=(MyIterator const& srcIt)
		{
			pIt = srcIt.pIt;
			return *this;
		}
		MyIterator& operator+=(int n)
		{
			pIt = pIt + n;
			return *this;
		}
		MyIterator& operator-=(int n)
		{
			pIt = pIt - n;
			return *this;
		}
		T operator *()
		{
			return *pIt;
		}
		MyIterator operator+(int n)
		{
			MyIterator it;
			it.pIt =pIt;
			it.pIt +=  n;
			return it;
		}
		MyIterator operator-(int n)
		{
			MyIterator it;
			it.pIt = pIt;
			it.pIt -= n;
			return it;
		}
		MyIterator& operator++()
		{
			pIt += 1;
			return *this;
		}
		MyIterator operator++(int)
		{
			MyIterator temp(*this);
			pIt += 1;
			return temp;

		}
		bool operator !=(MyIterator const& srcIt) const
		{
			return pIt != srcIt.pIt;
		}
		int operator -(MyIterator const& srcIt)const
		{
			return pIt - srcIt.pIt;
		}
		T& operator[](int index) const
		{
			return pBuff[index];
		}
	};
public:
	MyIterator begin()
	{
		MyIterator it;
		it.pIt = pBuff;
		return it;
	}
	MyIterator end()
	{
		MyIterator it;
		it.pIt = pBuff+num;
		return it;
	}
public:
	Myvector();
	Myvector(int n);
	Myvector(Myvector const& other);
	Myvector(int n,T const& srcDate);
	Myvector(MyIterator b, MyIterator e);
	~Myvector();
public:
	size_t size() const;
	size_t max_size() const;
	size_t capacity() const;
	void reserve(int n);
	bool empty() const;
	void clear();
public:
	bool operator ==(Myvector const & srcVector) const;
	bool operator !=(Myvector const & srcVector) const;
	bool operator >=(Myvector const & srcVector) const;
	bool operator <=(Myvector const & srcVector) const;
	bool operator >(Myvector const & srcVector) const;
	bool operator <(Myvector const & srcVector) const;
	void operator =(Myvector const & srcVector);
	//void operator =(T n);
	T& operator [](int index) const;
public:
	void swap(Myvector vector1);
public:
	void assign(int n,T const& srcdate);//拷贝n个数据
	void assign(MyIterator b,MyIterator e);//拷贝n个数据
public:
	T at(int index)const;
public:
	void push_back(T const & srcDate);//压入数据
	void pop_back();//删除最后一个数据
	void resize(size_t n);
public:
	T front()const;
	T back()const;
private:
	//容器变大重分配
	void Mymalloc()
	{
		if (num>maxNum)
		{
			maxNum = maxNum + ((maxNum >> 1)>1 ? (maxNum >> 1) : 1);
			T* temppBuff = new T[maxNum];
			memcpy(temppBuff, pBuff, sizeof(T)*num);
			if (pBuff)
				delete[]pBuff;
			pBuff = temppBuff;
		}
	}
public:
	MyIterator erase(MyIterator const &beg, MyIterator const &end)
	{
		int be = beg.pIt - pBuff, en = end.pIt - pBuff;
		for (int i = be,j=en; i < num-en+be+1; i++,j++)
			pBuff[i] = pBuff[j];
		num =num-en+be;
		MyIterator tempIt;
		tempIt.pIt = pBuff + be;
		return tempIt;
	}
	MyIterator erase(MyIterator const& pos)
	{
		int index = pos.pIt - pBuff;
		for (int i = index; i < num; i++)
			pBuff[i] = pBuff[i + 1];
		num--;
		MyIterator tempIt;
		tempIt.pIt = pBuff+index;
		return tempIt;
	}
	void insert(MyIterator const& pos, int n, T const& srcDate)
	{
		int index = pos.pIt - pBuff;
		if (num + n > maxNum)
		{
			maxNum = maxNum + n;
			T* temppBuff = new T[maxNum];
			memcpy(temppBuff, pBuff, sizeof(T)*num);
			if (pBuff)
				delete[]pBuff;
			pBuff = temppBuff;
		}
		printf("%d %d %d\n",index, num + n - 1, index + n);
		for (int i = num + n - 1, j = num-1; i >= n + index - 1; i--, j--)
			pBuff[i] = pBuff[j];
		for (int i = index; i < index + n; i++)
			pBuff[i] = srcDate;
		num = num + n;
	}
	void insert(MyIterator const& pos, MyIterator const& beg, MyIterator const& end)
	{
		MyIterator temp = beg;
		int index = pos.pIt - pBuff;
		int n = end.pIt - beg.pIt;
		if (num+n > maxNum)
		{
			maxNum = maxNum +n;
			T* temppBuff = new T[maxNum];
			memcpy(temppBuff, pBuff, sizeof(T)*num);
			if (pBuff)
				delete[]pBuff;
			pBuff = temppBuff;
		}
		for (int i = num + n - 1, j = num - 1; i >= n + index - 1; i--, j--)
		{
			pBuff[i] = pBuff[j];
		}
		for (int i = index; i < index+n; i++)
		{
			pBuff[i] = *(temp);
			temp = temp + 1;
		}
		num = num + n;
	}
	void insert(MyIterator const& pos, T const& srcDate)
	{
		int index = pos.pIt - pBuff;
		if (num>=maxNum)
		{
			maxNum = maxNum + ((maxNum >> 1)>1 ? (maxNum >> 1) : 1);
			T* temppBuff = new T[maxNum];
			memcpy(temppBuff, pBuff, sizeof(T)*num);
			if (pBuff)
				delete[]pBuff;
			pBuff = temppBuff;
		}
		for ( int i = num; i >index; i--)
		{
			pBuff[i] = pBuff[i - 1];
		}
		pBuff[index] = srcDate;
		num++;
	}
};

template<class T>
T Myvector<T>::front()const
{
	return pBuff[0];
}
template<class T>
T Myvector<T>::back()const
{
	return pBuff[num-1];
}


template<class T>
void Myvector<T>::resize(size_t n)
{
	if (n!=num)
	{
		int tempNum = n < num ? n : num;
		T *temppBuff = new T[n];
		memcpy(temppBuff, pBuff, sizeof(T)*tempNum);
		if (pBuff)
			delete[]pBuff;
		pBuff = temppBuff;
		num =maxNum= n;
	}
	
}
template<class T>
void Myvector<T>::clear()
{
	memcpy(pBuff,0 , sizeof(T)*num);
	num =  0;
}

template<class T>
void Myvector<T>::pop_back(){
	if (num)
		num--;
}

template<class T>
void Myvector<T>::push_back(T const & srcDate)
{
	if (num>=maxNum)
	{
		maxNum = maxNum + ((maxNum >> 1)>1 ? (maxNum >> 1) : 1);
		T* temppBuff = new T[maxNum];
		memcpy(temppBuff, pBuff, sizeof(T)*num);
		if (pBuff)
			delete[]pBuff;
		pBuff = temppBuff;
	}
	pBuff[num++] = srcDate;
}

template<class T>
T& Myvector<T>::operator [](int index) const
{
	return pBuff[index];
}

template<class T>
T Myvector<T>::at(int index)const{
	if (index < 0 || index >= num)
		throw "数组越界";
	return pBuff[index];
}

template<class T>
void Myvector<T>::assign(MyIterator b, MyIterator e)
{
	int n = e - b;
	if (pBuff)
	{
		delete[]pBuff;
		if (maxNum < n)
			maxNum = n;
	}
	else
		maxNum = n;
	pBuff = new T[maxNum];
	num = n;
	for (int i = 0; i < num; i++)
		pBuff[i] = *(b+i);
}
template<class T>
void Myvector<T>::assign(int n, T const& srcdate)
{
	if (pBuff)
	{
		delete[]pBuff;
		if (maxNum < n)
			max = n;
	}
	else
		max = n;
	pBuff = new T[maxNum];
	num = n;
	for (int i = 0; i < num; i++)
		pBuff[i] = srcdate;
}

template<class T>
void Myvector<T>::swap(Myvector swapVector)
{
	size_t tempNum = num;
	size_t tempMaxNum = maxNum;
	T *temppBuff = pBuff;

	num = swapVector.num;
	maxNum = swapVector.maxNum;
	pBuff = swapVector.pBuff;

	swapVector.num=tempnum;
	swapVector.maxNum = tempMaxNum;
	swapVector.pBuff = temppBuff;
}

template<class T>
bool Myvector<T>::operator !=(Myvector const & srcVector) const
{
	return !(*this == srcVector);
}

template<class T>
void Myvector<T>::operator =(Myvector const & srcVector)
{
	num = srcVector.num;
	maxNum = srcVector.maxNum;
	if (num)
		pBuff = srcVector.pBuff;
}

template<class T>
bool Myvector<T>::operator >=(Myvector const & srcVector) const
{
	size_t tempNum = num > srcVector.num ? num : srcVector.num;
	for (size_t i = 0; i < tempNum; i++)
	{
		if (pBuff[i] < srcVector.pBuff[i])
			return false;
	}
	return true;
}
template<class T>
bool Myvector<T>::operator >(Myvector const & srcVector) const
{
	size_t tempNum = num > srcVector.num ? num : srcVector.num;
	for (size_t i = 0; i < tempNum; i++)
	{
		if (pBuff[i] <= srcVector.pBuff[i])
			return false;
	}
	return true;
}
template<class T>
bool Myvector<T>::operator <=(Myvector const & srcVector) const
{
	size_t tempNum = num > srcVector.num ? num : srcVector.num;
	for (size_t i = 0; i < tempNum; i++)
	{
		if (pBuff[i] > srcVector.pBuff[i])
			return false;
	}
	return true;
}
template<class T>
bool Myvector<T>::operator <(Myvector const & srcVector) const
{
	size_t tempNum = num > srcVector.num ? num : srcVector.num;
	for (size_t i = 0; i < tempNum; i++)
	{
		if (pBuff[i] >= srcVector.pBuff[i])
			return false;
	}
	return true;
}
//template<class T>
//bool Myvector<T>::operator >(Myvector const & srcVector) const
//{
//	return !(*this <= srcVector);
//}
//template<class T>
//bool Myvector<T>::operator <(Myvector const & srcVector) const
//{
//	return !(*this >= srcVector);
//}

template<class T>
bool Myvector<T>::operator ==(Myvector const & srcVector) const
{
	if (num==servecor.num)
	{
		for (size_t i = 0; i < num; i++)
		{
			if (pBuff[i]!=srcVector.pBuff[i])
				retrun false;
		}
		return true;
	}
	return false;
}
template<class T>
void Myvector<T>::reserve(int n)
{
	num = 0;
	maxNum = n;
	pBuff = new T[maxNum];
	memset(pBuff,0,sizeof(T)*maxNum);
}
template <class T>
size_t Myvector<T>::max_size() const
{
	return INT_MAX / sizeof(T);
}
template <class T>
size_t Myvector<T>::capacity() const
{
	return maxNum;
}
template<class T>
size_t Myvector<T>::size() const
{
	return num;
}
template<class T>
bool Myvector<T>::empty() const
{
	return num == 0;
}
template<class T>
Myvector<T>::Myvector(int n, T const& srcDate)
{
	num = maxNum = n;
	pBuff = NULL;
	if (num)
	{
		pBuff = new T[num];
		for (int i = 0; i < n; i++)
		{
			pBuff[i] = srcDate;
		}
	}
}

template<class T>
Myvector<T>::~Myvector()
{
	if (pBuff)
		delete[]pBuff;
}

template<class T>
Myvector<T>::Myvector(MyIterator b, MyIterator e)
{
	int n=0;
	if ((n=e-b)>0)
	{
		num = maxNum = n;
		pBuff = new T[num];
		for (int i = 0; i < num; i++)
			pBuff[i] = *(b + i);
	}
}

template<class T>
Myvector<T>::Myvector(Myvector const& other)
{
	num = other.num;
	maxNum = other.maxNum;
	if (num)
	{
		pBuff = new T[num];
		memcpy(pBuff,other.pBuff,sizeof(T)*num);
	}
}

template<class T>
Myvector<T>::Myvector(int n)
{
	num = n;
	maxNum = n;
	pBuff = new T[num];
	memset(pBuff,0,sizeof(T)*num);
}


template<class T>
Myvector<T>::Myvector()
{
	pBuff = NULL;
	num = 0;
	maxNum = 0;
}

 

编程小耗子
关注
专栏目录
c++实现Vector
piyixia的博客
03-11 330
//Vector.h extern const double uZero; class Vector3 { float x, y, z; public: Vector3() { x = 0; y = 0; z = 0; }; Vector3(float x1, float y1, float z1) { x = x1, y = y1, z = z1; } Vector3 operato...
C++之vector容器
米时光
07-26 136
一、STL的基本概念 STL（Standard Template Library）标准模板库大体上分为六大组件，分别为容器，算法，迭代器，仿函数，适配器和空间配置器，其中最重要的是容器，算法和迭代器，容器和算法之间通过迭代器无缝连接。 容器：各种数据结构，比如vector，list，deque，set，map等，用来存放数据； 算法：各种常用的算法，比如sort，find，copy，for_each等； 迭代器：提供一种方法，能够依序寻访某个容器所含的各个元素，每个容器都有自己专属的迭代器。迭代器的
『C++』vector容器模拟实现
叄拾叄画生
06-04 279
vector模拟实现。Vector.h。Vector.cc。
C++中vector的实现
最新发布
2302_80190394的博客
08-08 1014
C++中vector的实现
自己实现vector(C++)
mwt_442396446的博客
07-13 235
#ifndef MVECTOR_H #define MVECTOR_H #include<iostream> #include"vector_iterator.h" using namespace std; template<typename T> class Mvector { public: typedef Vector_Iterator<Mvector<T>> iterator; Mvector(T* arr, int len) { _len
C++自己实现一个简单地Vector
午夜飞行
12-29 838
直接贴代码 Vector.h #ifndef __LeetCode__Vector__ #define __LeetCode__Vector__ #include #include using namespace std; typedef int Rank;// static const int DEFAULT_CAPACITY = 3; template class Vector {
实现自己的vector
07-09 96
关于标准库vector的介绍：http://www.cplusplus.com/reference/vector/vector/ 1 #pragma once 2 3 #include<memory> 4 #include<cassert> 5 #include<algorithm> 6 #include<itera...
C++vector容器
C语言实战技术
03-05 479
文章目录一、容器的定义二、容器的使用1、存放整数2、存放字符串3、存放结构体4、存放类三、其它成员函数1、定位的函数2、增加元素的函数3、删除元素的函数4、判断容器的大小四、容器的排序五、课后作业六、版权声明 我们在声明数组的时候，采用的是datatype array[len]的形式，数组在分配之后，不能调整大小，删除和插入数据时操作十分的繁琐，虽然可以采用链表，但是链表的操作更麻烦，我们希望有更...
C++ STL容器如何解决线程安全的问题？
果冻虾仁
10-16 4003
众所周知，STL容器不是线程安全的。对于vector，即使写方（生产者）是单线程写入，但是并发读的时候，由于潜在的内存重新申请和对象复制问题，会导致读方（消费者）的迭代器失效。实际表现也就是招致了core dump。另外一种情况，如果是多个写方，并发的push_back()，也会导致core dump。 解法一： 加锁是一种解决方案，但是加std::mutex互斥锁确实性能较差。对于多读少写的场景可以用读写锁（也叫共享独占锁），来缓解。C++17引入了std::shared_mutex 。更多锁的种类可
C++ STL：vector容器基本命令与理解
Stefanlin的博客
08-24 519
STL基本命令 1.vector是什么？ vector是C++语言中的一种数组容器，用于顺序存放用户放入的数据，它与普通数组的区别在于，vector是可动态扩展的单端数组，当其容量不足以存放新的数据时，vector会自主的寻找更大的内存空间，并将原本数据与新加入数据拷贝到新空间中，同时释放原存储内存空间。 ...
C++容器—队列以及队列的自我实现
qq_44819750的博客
07-06 669
队列介绍 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端 提取元素。 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的 成员函数来访问其元素。元素从队尾入队列，从队头出队列。 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操 作: empty：检测队列是否为空 size：返回队列中有效元素的个数 front：返回队头元素的引用 back：返回队尾元素的引用
Vector c++的简单实现
12-01
简单的实现vector的功能，但有可能在扩容和缩容时降低效率
C++自我梳理.pdf
03-26
C++标准模板库（STL）中提供了链表容器list，它封装了链表的实现细节，使得操作链表变得简单高效。 Java与C++的语法差异部分涉及到C++特有的语法特性，如C++中的this指针、静态成员的访问方式，以及无参对象的定义...
STL中vector类的自我简单实现
qq_55143256的博客
04-18 484
前面写了STL中关于string类的自我实现,感兴趣的小伙伴可以移步至这里((45条消息) STL中string类的自己实现_芜湖开冲～的博客-CSDN博客https://blog.csdn.net/qq_55143256/article/details/124212845),接着上面,今天我们来实现vector类的简单实现(友情提示:很全,比我网上找到的大部分都全),所谓的vector类,其实就是顺序表,只不过这个顺序表不仅能存放int,还能存放各种各样的类型,vector类的实现其实也不是很难,别看底下
动手实现自己的 STL 容器 《1》---- vector
L.J.SHOU的专栏
04-11 3249
本文参考了侯捷的 《STL 源码分析》一书，出于兴趣，自行实现了简单的 vector 容器。 之后会陆续上传 list， deque 等容器的代码，若有错误，欢迎留言指出。 vector 容易实现的几点注意事项： 1. 由于vector 是动态数组。 出于效率的考虑，在往vector 中加入元素时，内存的扩展遵循的规则是：    1> 如果当前可用内存不够，开 2倍大的内存，将原
自己动手实现一个C++STL中的vector
m0_47262980的博客
07-11 435
myVector and myDeque 自己动手实现了一个c++ stl中的vector容器，利用三根指针实现，简单易懂，大部分功能都实现了，还请各位批评指正。 三根指针分别为start，finish，end_of_storage，用于控制vector的容量，程序包含丰富的测试用例。 废话不多说，直接上代码。 该代码为头文件的内容 #ifndef myVector_h #define myVector_h template <typename T> class myVector { publ
C++中STL的vector自我实现(部分接口)详解
qq_44819750的博客
06-24 219
vector自我实现 在库中的vector中，底层实现是由三个指针实现的，在这里我就用_start，_finish和_eos实现 必要解释都在代码中加以注释 //运用模板，以便vector中实现各种数据类型 template <class T> class Vector//自我实现的Vector { public: //Vector的构造函数实现 Vector() //初始化列表 :_start(nullptr)//指向有效元素的第一个位置 , _finish(nullptr)//
c++简单实现-vector
weixin_44024891的博客
01-31 604
模拟实现一个STL容器-vector vector文档：          1、 vector是表示可变大小数组的序列容器， 采用连续存储空间来储存元素（像数组一样） 支持下标访问和修改， 但是又与数组不同， 它的长度是可以动态改变的，而且它的大小会被容器自 动处理。    &n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值