C/C++ 入门（8）vector类（STL）

仍有未知等待探索

已于 2024-04-29 17:13:59 修改

阅读量433

点赞数 8

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-04-25 15:40:53 首次发布

本文链接：https://blog.csdn.net/qq_73435980/article/details/138183578

版权

C++ 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

个人主页：仍有未知等待探索-CSDN博客

专题分栏：C++

请多多指教！

2、因为类没有实例化且用了类里面声明的类型等而产生的报错

3、内部编译器错误

4、迭代器失效

一、标准库中的vector

1、了解

vector就是一个支持变长的数组。

2、vector常用接口

vector的使用不做过多强调，注重的是实现vector类。

可以点击下面的链接进入cplusplus网站，查看文档。

vector - C++ Reference

二、vector的实现

1、框架

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

template<class T>
class vector
{
public:
    typedef T* iterator;//普通迭代器
    typedef const T* const_iterator;//const迭代器
    // Iterators:	
    iterator begin()
    {
	    return _start;
    }
    iterator end()
    {
	    return _finish;
    }
    const_iterator begin() const
    {
	    return _start;
    }
    const_iterator end() const
    {
	    return _finish;
    }
	// 成员函数
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;
};

2、构造、析构函数

// 无参的构造必须写，因为下面实现了构造函数，编译器不会自动生成一个无参构造函数
vector(){}
// 开辟n个大小的空间，并初始化为m
vector(const int& n, const int& m = 0)
{
    // 新写法（复用reserve）
	reserve(n);
	for (int i = 0; i < n; i ++ ) _start[i] = m;
	_finish = _start + n;
}
// 用迭代器进行构造
template<class input_iterator>
vector(input_iterator start, input_iterator end)
{
	input_iterator it = start;
	while (it != end)
	{
		push_back(*it);
		it ++ ;
	}
}
// 开辟n个大小的空间，并初始化为val
// const T& val = T() -> 用一个匿名对象进行初始化，目的是为了预防vector<T>中T是一个自定义类型。
vector(size_t n, const T& val = T())
{
	resize(n, val);// 复用resize
}
// 用一个vector<T>进行拷贝构造
vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (auto& e : v)
	{
        // 复用push_back（）
		push_back(e);
	}
}
// 用列表进行初始化
// vector<int> v = {1, 2, 3};
// 用库函数实现的initializer_list<T>
vector(initializer_list<T> il)
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}
// 析构函数
~vector()
{
	delete[] _start;
	_start = _finish = _endofstorage = nullptr;
}

3、操作函数

vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}
// Capacity:
size_t capacity() const
{
	return _endofstorage - _start;
}
size_t size() const 
{
	return _finish - _start;
}
bool empty() const
{
	return size() == 0;
}
void reserve(size_t n)
{
	if (capacity() < n)
	{
		T* tmp = new T[n];
		int old_size = size();
		//memcpy(tmp, _start, size() * sizeof(T));
		// 当T是string类型的时候，memcpy会导致浅拷贝问题，并且会同时对一块空间析构多次
		for (int i = 0; i < old_size; i ++ )
		{
			tmp[i] = _start[i];
		}
		delete[] _start;

		_start = tmp;
		_finish = tmp + old_size;
		_endofstorage = tmp + n;
	}
}
void resize(size_t n, const T& val = T())
{
	reserve(n);
	iterator it = _start;
	while (it != _endofstorage)
	{
		*it = val;
		it ++ ;
	}
}
// Element access:
T& operator[](int pos)
{
	assert(pos < size());
	return _start[pos];
}

// Modifiers:
// 在pos之前插入一个数x
void insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _endofstorage)
	{
		int len = pos - _start;
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		pos = _start + len;
	}
	iterator it = _finish - 1;
	while (it >= pos) 
	{
		*(it + 1) = *it;
		it -- ;
	}
	*pos = x;
	_finish ++ ;
}
// 尾插
void push_back(const T& x)
{
    // 老写法
	/*if (_finish == _endofstorage)
	{
	reserve(capacity() == 0 ? 4 : 2 * capacity());
	}
	*_finish = x;
	_finish ++ ;*/
    // 新写法
	insert(end() , x);
}
// 尾删
void pop_back()
{
	assert(!empty());
	_finish -- ;
}
// 交换函数，用库里面的swap实现指针的交换，来完成vector的交换
void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}

三、问题

1、由于赋值而引起的浅拷贝

如果要将一个引用进行赋值，并且没有对赋值运算符重载的话，会只进行值拷贝而导致浅拷贝。最后会使编译器对同一块空间析构多次。

为什么*pos，x都是T类型的，而赋值重载却写一个vector<T>类型的就能行？

因为单参数的构造函数支持隐式类型转化，编译器会先进行构造函数，将这两个值构造成对象，然后在进行赋值。

vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}

2、因为类没有实例化且用了类里面声明的类型等而产生的报错

需要在使用这个类型前面加上typename标志这是一个类型。

template<class T>
void print_vector(vector<T>& v)
{
	// 不加typename会报错，因为在这个函数模板里，vector<T>这个类并没有实例化，会不清楚const_iterator是类型还是变量
	// 加typename的含义就是告诉编译器，这个是类型
	typename vector<T>::const_iterator it = v.begin();
	//auto it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it ++ ;
	}
}