手写实现vectorC++

原创已于 2023-09-06 18:12:43 修改 · 341 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #开发语言

于 2023-09-06 18:03:25 首次发布

本文详细介绍了C++中的vector模板类，包括其构造函数、析构函数、重载操作符（=、[]）及常用方法如push_back,insert,pop_back,erase等的实现。特别提到了typename关键字在重载操作符中的使用和模板类的编译注意事项。

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

#pragma once
#include <stdio.h>
#include<iostream>
using namespace std;
template<typename T>
class vector
{
public:
	typedef T value_type;
	typedef T* iterator;
	vector() : _data(NULL), _size(0), _capacity(0) {};
	vector(size_t a);
	vector(size_t a, T b);
	vector(const vector& vec);
	bool operator==(const vector& vec) const;
	vector& operator=(const vector& vec);
	value_type& operator[](size_t index);
	void push_back(value_type val);
	void insert(iterator it, value_type val);
	void pop_back();
	void erase(iterator it);
	value_type& front();
	value_type& back();
	size_t size() const;
	size_t capactiyt()const;
	bool empty();
	~vector();
private:
	value_type* _data;
	size_t _size;
	size_t _capacity;
};

//指定大小的有参构造函数
template<typename T>
vector<T>::vector(size_t n)
{
	_data = new value_type[n + 10];
	_capacity = n + 10;
	_size = n;
}

//析构函数
template<typename T>
vector<T>::~vector()
{
	delete _data;
	_data = NULL;
	_size = 0;
	_capacity = 0;
}

//指定大小和初始值的有参构造函数
template<typename T>
vector<T>::vector(size_t a, T b)
{
	_capacity = a + 10;
	_data = new value_type[_capacity];
	for (int i = 0; i < a; i++)
	{
		_data[i] = b;
	}
	_size = a;
}

//拷贝构造函数
template<typename T>
vector<T>::vector(const vector& vec)
{
	_size = vec._size;
	_capacity = vec._capacity;
	_data = new value_type[_capacity];
	for (int i = 0; i < _size; i++)
	{
		_data[i] = vec._data[i];
	}
}

//重载 == 运算符
template<typename T>
bool vector<T>::operator==(const vector& vec) const 
{
	if (_size != vec._size) return false;
	for (int i = 0; i < _size; i++)
	{
		if (_data[i] != vec._data[i]) return false;
	}
	return true;
}

//重载等于号运算符为什么要加<T>
template<typename T>
vector<T>& vector<T>::operator=(const vector& vec)
{
	if (this == &vec) return *this;
	delete[]_data;
	_data = new value_type[vec._capacity];
	for (int i = 0; i < _size; i++)
	{
		_data[i] = vec._data[i];
	}
	_size = vec._size;
	_capacity = vec._capacity;
	return *this;
}

//重载[]运算符当函数声明或定义在类模板之外时，需要使用 typename 关键字来指示 value_type 是一个类型
template<typename T>
typename vector<T>::value_type& vector<T>::operator[](size_t index)
{
	if (index > _size - 1) cout << "OUT OF RANGE" ;
	return _data[index];
}

//增添元素push_back()
template<typename T>
void vector<T>::push_back(value_type val)
{
	if (0 == _capacity)
	{
		_capacity = 10;
		_data = new value_type[_capacity];
	}
	else if (_size + 1 > _capacity)
	{
		_capacity *= 2;
		value_type* temp = new value_type[_capacity];
		for (int i = 0; i < _size; i++)
		{
			temp[i] = _data[i];
		}
		delete[]_data;
		_data = temp;
	}
	_data[_size++] = val;
}

//插入元素
template<typename T>
void vector<T>::insert(iterator it, value_type val)
{
	int index = it - _data;
	if (_capacity == 0)
	{
		_capacity = 10;
		_data = new value_type[_capacity];
		_data[0] = val;
	}
	else if (_size + 1 > _capacity)
	{
		_capacity *= 2;
		value_type* temp = new value_type[_capacity];
		for (int i = 0; i < index; i++)
		{
			temp[i] = _data[i];
		}
		temp[index] = val;
		for (int i = index; i < _size; i++)
		{
			temp[i + 1] = _data[i];
		}
		delete[]_data;
		_data = temp;
	}
	else
	{
		for (int i = _size - 1; i >= index; i--)
		{
			_data[i + 1] = _data[i];
		}
		_data[index] = val;
	}
	++_size;
}

//尾删元素
template<typename T>
void vector<T>::pop_back()
{
	if (_size == 0) cout << "OUT OF RANGE";
	else
	{
		--_size;
	}
}

//删除元素
template<typename T>
void vector<T>::erase(iterator it)
{
	int index = it - _data;
	for (int i = index; i < _size - 1; ++i)
	{
		_data[i] = _data[i + 1];
	}
	--_size;
}

//返回首元素
template<typename T>
typename vector<T>::value_type& vector<T>::front()
{
	return _data[0];
}

//返回尾部元素
template<typename T>
typename vector<T>::value_type& vector<T>::back()
{
	return _data[_size - 1];
}

//返回大小
template<typename T>
size_t vector<T>::size() const
{
	return _size;
}

//返回容量
template<typename T>
size_t vector<T>::capactiyt() const
{
	return _capacity;
}

//是否为空
template<typename T>
bool vector<T>::empty()
{
	if (_size == 0) return true;
	else
		return false;
}

里面的几个问题，重载=号返回引用

typename vector<T>::value_type&前面必须添加typename，当函数声明或定义在类模板之外时，需要使用 typename 关键字来指示 value_type 是一个类型

还有模板类没办法分文件编写

常量对象以及常量对象的指针引用等只能调用常量成员函数——C++primer P232