STL模拟实现vector

最新推荐文章于 2023-05-24 09:59:31 发布
最新推荐文章于 2023-05-24 09:59:31 发布
阅读量473 收藏
点赞数
分类专栏： C++ 数据结构 文章标签： 模拟实现vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_iverson/article/details/78402382
版权

首先给出所需要实现的函数接口和类的封装

template<class T>
class Vector
{
public:
	Vector();//无参构造函数
	Vector(const T* array, size_t size);//有参数构造函数
	Vector(const Vector & v);//拷贝构造函数
	Vector& operator=(const Vector& s);//赋值运算符重载
	~Vector();//析构函数
	void PushBack(const T& data);//尾插
	void PopBack();//弹出尾部最后一个元素
	void Insert(size_t pos, const T& data);//指定位置的插入
	void Erase(size_t pos);//指定位置的删除
	size_t Size()const;//求元素个数
    size_t Capacity()const;//求空间容量
	bool Empty()const;//判空
	void Resize(size_t newSize, const T& data = T());//更改元素个数
	T& operator[](size_t index);
	const T& operator[](size_t index)const;
	friend ostream& operator<<(ostream &out, Vector<T>& s);
	T& Front();//返回第一个元素
	const T& Front()const;
	T& Back();
    const T& Back()const;//返回最后一个元素
	void Clear();
private:
	   void _CheckCapacity();//判满函数
private:
	T* _start;//指向起始位置
	T* _finish;//指向最后一个元素末尾
	T* _endOStorage;//指向开辟空间末尾0
};
接下来给出上面接口的具体的实现，但是其中有 类型萃取，因为需要根据不同的数据类型进行不同的赋值方式，从而提高程序的效率。

下面给出所有的实现代码和我自己的测试代码


struct TrueType
{
	static bool IsPODType()
	{
		return true;
	}
};
struct FalseType
{
	static bool IsPODType()
	{
		return false;
	}
};
template<class T>
struct TypeTraits
{
	typedef FalseType PODtype;
};
template<>
struct TypeTraits<double>
{
	typedef TrueType PODtype;
};
template<>
struct TypeTraits<int>
{
	typedef TrueType PODtype;
};
template<>
struct TypeTraits<char>
{
	typedef TrueType PODtype;
};
//上面是类型萃取部分的代码
template<class T>
class Vector
{
public:
	Vector();//无参构造函数
	Vector(const T* array, size_t size);//有参数构造函数
	Vector(const Vector & v);//拷贝构造函数
	Vector& operator=(const Vector& s);//赋值运算符重载
	~Vector();//析构函数
	void PushBack(const T& data);//尾插
	void PopBack();//弹出尾部最后一个元素
	void Insert(size_t pos, const T& data);//指定位置的插入
	void Erase(size_t pos);//指定位置的删除
	size_t Size()const;//求元素个数
    size_t Capacity()const;//求空间容量
	bool Empty()const;//判空
	void Resize(size_t newSize, const T& data = T());//更改元素个数
	T& operator[](size_t index);
	const T& operator[](size_t index)const;
	friend ostream& operator<<(ostream &out, Vector<T>& s);
	T& Front();//返回第一个元素
	const T& Front()const;
	T& Back();
    const T& Back()const;//返回最后一个元素
	void Clear();
private:
	   void _CheckCapacity();//判满函数
private:
	T* _start;//指向起始位置
	T* _finish;//指向最后一个元素末尾
	T* _endOStorage;//指向开辟空间末尾0
};
template<class T>
Vector<T>::Vector()
:_start(0)
, _finish(0)
, _endOStorage(0){}
template<class T>
Vector<T>::~Vector()
{
	if (_start)
	{
		delete[] _start;
		_start = _finish = _endOStorage = NULL;
	}
}
template<class T>
Vector<T>::Vector(const T* array, size_t size)
:_start(new T[size])
, _finish(_start+size)
, _endOStorage(_finish)
{
	if (TypeTraits<T>::PODtype::IsPODType())
	{
		memcpy(_start, array, sizeof(T)*size);
	}
	else
	{
		for (size_t i = 0; i < size; ++i)
			_start[i] = array[i];
	}
}
template<class T>
Vector<T>& Vector<T>::operator=(const Vector& s)
{
	if (s._start != _start)
	{
		_start = new T[s.Capacity()]//新开辟容量
			if (TypeTraits<T>::PODtype::IsPODType())
			{
				memcpy(_start, array, sizeof(T)*size);
			}
			else
			{
				for (size_t i = 0; i < size; ++i)
					*_start[i] = *s._start[i];
			}
			delete s._start;
	}
	return;
}
template<class T>
void Vector<T>::_CheckCapacity()
{
	if (_finish == _endOStorage)
	{
		size_t n = Size();
		T *start = new T[Capacity() + 5];//多开辟
		if (TypeTraits<T>::PODtype::IsPODType())
		{
			memcpy(start,_start, sizeof(T)*n);
		}
		else
		{
			for (size_t i = 0; i < n; ++i)
				start[i] = _start[i];
		}
		_finish = start + Size();
		_endOStorage = start+Capacity()+5;
		delete [] _start;
		_start = start;
	}
	return;
}
template<class T>
void Vector<T>::Insert(size_t pos, const T& data)//指定位置插入元素
{
	assert(pos <= Size()+1);
	_CheckCapacity();//判满
	size_t n = Size();
	for (size_t i =n; i >=pos; i--)
	{
		_start[i] = _start[i - 1];
	}
	_start[pos-1] = data;
	_finish++;
}
template<class T>
void Vector<T>::Erase(size_t pos)//指定位置的删除
{
	if (!Empty())
	{
		size_t n = Size();//获得元素个数
		for (size_t i = pos-1; i<n-1; i++)//删除位置后面的元素向后移动
		{
			_start[i] = _start[i+1];
		}
		_finish--;
	}
}
template<class T>
void Vector<T>::PushBack(const T& data)
{
	_CheckCapacity();
	*_finish++ = data;
}
template<class T>
void Vector<T>::PopBack()
{
	if (!Empty())
	{
		_finish--;
	}
	return;
}

template<class T>
void Vector<T>::Resize(size_t newSize, const T& data = T())//改变元素个数，新增加的空间所赋值的元素
{
	if (newSize<=Size())
	{
		_finish = _start + newSize;
	}
	else if (newSize > Size() && newSize < Capacity())
	{
		for (size_t i = Size(); i < newSize; i++)
		{
			_start[i] = data;//多出来的元素赋值为data
			_finish = _start + newSize;
		}
	}
	else
	{
		T *start = new T[newSize];
		for (size_t i=0; i < Size(); i++)
		{
			start[i] = _start[i];
		}
		for (size_t j = Size(); j < newSize; j++)
		{
			start[j] = data;
		}
		delete[] _start;
		_start = start;
		_finish = _start + newSize;
		_endOStorage = _start + newSize;
	}
}
template<class T>
bool Vector<T>::Empty()const
{
	if (_start == _finish)
		return true;
	else
	   return false;
}
template<class T>
size_t Vector<T>::Size() const//元素个数
{
	return _finish - _start;
}
template<class T>
size_t Vector<T>::Capacity()const
{
	return _endOStorage - _start;
}
template<class T>
T& Vector<T>::operator[](size_t index)
{
	return _start[index];
}
template<class T>
ostream&  operator<<(ostream &out, Vector<T>& s)
{
	out << s._start[i];
}
template<class T>
T& Vector<T>::Front()
{
	return *_start;
}
template<class T>
const T& Vector<T>::Front()const
{
	return *_start;
}
template<class T>
T& Vector<T>::Back()
{
	return *(_finish-1);
}
template<class T>
const T& Vector<T>::Back()const
{
	return *(_finish-1);
}
template<class T>
void Vector<T>::Clear()//清空元素
{
	_finish = _start;
}
void TestVector()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	Vector<int> s(arr, sizeof(arr) / sizeof(*arr));
	cout <<"Back()="<< s.Back() << endl;
	cout << "Front()="<<s.Front() << endl;
	size_t n1 = s.Size();
	for (size_t i = 0; i < n1; i++)
	{
		cout << s[i] << " ";
	}cout << endl;
	s.Insert(6, 6);
	s.Insert(1, 0); 
		size_t n = s.Size();
	for (size_t i = 0; i < n; i++)
	{
		cout << s[i] << " ";
	}cout << endl;
	s.Erase(1);
	size_t n2 = s.Size();
	for (size_t i = 0; i < n2; i++)
	{
		cout << s[i] << " ";
	}cout << endl;
	
		s.Resize(10, 10);
	size_t n3 = s.Size();
	for (size_t i = 0; i < n3; i++)
	{
		cout << s[i] << " ";
	}cout << endl;

	s.Resize(5, 10);
	size_t n4 = s.Size();
	for (size_t i = 0; i < n4; i++)
	{
		cout << s[i] << " ";
	}cout << endl;
	cout << "Capacity=" << s.Capacity() << endl;

	string s1[] = { "aaa", "bbb","ccc","dddd"};
	string s3[4];
	Vector<string> s2(s1, sizeof(s1) / sizeof(*s1));
	size_t n5 = s2.Size();
	for (size_t i = 0; i < n5; i++)
	{
		cout << s2[i] << " ";
	}cout << endl;
}
测试结果如下，自己可以根据自己的想法去测试上面的功能



IT_iverson
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[CF# 366 Thor] STL模拟
Fighting!
08-09 634
[CF# 366 Thor] STL模拟 题目链接：[CF# 366 Thor]  题意描述：N 种物品标号为1~N， Q次操作： 标号为x 的物品增加一个；将标号为x的物品全部删除；将最初加入的前t次物品全部删除。 解题思路：想了好久，就是想不到模拟。 竟然一直想着用树状数组求和.... 直接看官方题解吧.... Consider a queue e fo
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
STL库中的vector的使用和模拟实现
pigff的博客
09-23 662
1.初识STL库STL库即标准模板库，它是一些容器的“集合”，诸如list，vector等。STL可分为容器，迭代器，空间配置器，算法，仿函数，适配器六个部分。本篇文章暂且讨论vector的使用与模拟实现。2.vector的使用vector可以理解成一个能够存放任意类型的动态数组，能够增加和删除数据。我们先来看看vector里都有些什么。 首先，肯定有的是构造函数，析构函数，和运算符重载。
STL模拟实现
weixin_44032272的博客
02-24 259
GITHUB链接： https://github.com/Zruzhuo/C_Realize/tree/master/stl_string
STL的模拟实现
qq_57283958的博客
05-30 183
string的模拟实现 #pragma once #include<iostream> #include<string.h> #include<assert.h> namespace bit { class string { public: typedef char* iterator; typedef const char* const_iterator; iterator begin() { return _str; } iterator e
STL_string模拟实现
qq_44777506的博客
10-25 180
stringstring介绍：代码：代码实现：代码测试：测试结果：注意事项： string介绍： string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string; 不能操作多字节或者变长字符的序列 代码： 代码实现： namespace ZYY { cla
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
操作系统进程调度算法模拟实验报告.pdf
12-01
vector 容器是 C++ .Standard Template Library（STL）中的一个容器，它可以用来实现数组、链表等数据结构。 vector 容器的优点是可以自动管理内存，避免了手动管理内存的麻烦。 （四）结构体设计 结构体设计是 ...
MFC实现n皇后算法(附报告)
06-02
算法实验、利用MFC模拟算法中的N皇后，其中使用STL中的map、vector实现存储所有可行性。
STL——list使用和模拟
qq_62745420的博客
08-31 228
在STL中list底层使用的是双向带头循环链表，这是一个很完善的结构，可以做到在O（1）时间内完成任意位置的插入和删除。唯一的缺点就是不支持随机访问，如果要访问list中的第三个元素，只能通过遍历比如迭代器或者范围for来遍历到第三个元素。所以list不支持算法库里面的sort（因为算法库中的sort底层是快速排序，快速排序为了防止最坏的情况也就是已排序好的数据，在这种情况下的效率就是O（N^2)因此引入了三数取中，但是如果不支持随机访问，三数取中就不可以使用了）...
STL_vector模拟实现
qq_44777506的博客
10-25 718
vectorvector介绍：代码：对代码代码进行测试：执行结果： vector介绍： vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自 动处理。 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小 为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
stl——模拟实现vector
smx_dd的博客
01-13 386
对于vector相信大家并不陌生，这里介绍一些重要的vector的接口和用法。 1. 构造函数 vector(); 无参构造 vector(size_type n, const value_type& val = value_type()); 构造并初始化n个val vector (InputIterator first, InputIterator last); 利用迭代器进行构造。 ...
STL详解— list类的模拟实现
最新发布
qq_61213622的博客
05-24 253
STL详解— list类的模拟实现
模拟实现STL中的vector
ChaseRaod的博客
09-17 376
在之前的文章模拟实现源码剖析了STL中的List，这篇文章模拟STL中的vector. 模拟实现STL中的list 《STL源码剖析》中对vector的描述是这样的： vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间运用的灵活性。array是静态空间，一旦配置了就不能改变。vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。 vec
【STL】模拟实现vector
ArchyLi
03-22 937
本文初步用C++模拟实现vector的一下几个步骤，因为是初步实现，和STL库中的源码还有些不一样，后期会使用类似STL中的vector的三个迭代器再次模拟实现vector。 void PushBack(const DataType& data); void PopBack(); void Insert(size_t pos, const DataType& data); void Eras
STL模拟实现迭代器
lx8211667846947的博客
11-04 214
迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。 模拟实现Vector和List的迭代器版本
【STL】 vector 模拟实现
pointer_y的博客
09-23 2017
上一篇博客说了一下list的使用，其实vector用法基本上和list是一样的，所以此篇博客就只模拟实现以下vector。vector你可以把它理解成一个顺序表或者数组。只是STL里的vector是由三个迭代器来维护的：_start(数据存放开始的位置),_finish(数据存放结束位置的下一个),_endofstorage(容量的最后一个位置)。vector里的迭代器其实就是个指针。来看看代码实
STL：模拟实现Vector
dangzhangjing97的博客
08-11 746
一、vector是什么？ vector是STL中的容器之一，相当于动态的数组（或者顺序表） 二、vector的优点？ 1.效率高 2.通用性好（因为vector使用了模板，所以通用性强） ps：在需要用数组的地方，可优先考虑使用vector 三、vector的缺点？ 不适合头插和头删 因为vector相当于是动态的数组，所以vector不适合频繁的在空...
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector()...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值