Lesson09（初阶）---vector

落笔映浮华丶

已于 2024-11-17 21:51:13 修改

阅读量742

点赞数 15

文章标签： c++

于 2024-10-12 01:57:43 首次发布

本文链接：https://blog.youkuaiyun.com/m0_67371175/article/details/142698716

版权

Lesson09—vector

第9章c++ vector类

文章目录

Lesson09---vector
前言
1.1vector的介绍
2 vector的使用
3 相关题目
4.vector 的模拟实现

前言

这篇博文详细写了vector的的介绍及使用和内容深度剖析及模拟实现

1.1vector的介绍

https://legacy.cplusplus.com/reference/vector/vector/
vector的文档

vector是表示可变大小数组的序列容器。
就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

使用STL的三个境界：能用，明理，能扩展，那么下面学习vector，我们也是按照这个方法去学习

2 vector的使用

vector学习时一定要学会查看文档：vector的文档：https://cplusplus.com/reference/vector/vector/介绍，vector在实际中常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口是要重点掌握的。

2.1 vector 的初始化

为了方便记忆
在这里插入图片描述
可以直接理解成定义一个int的方式，把vector也当作一个类型，vector就是顺序表顺序表的底层不一定是整形所以这里要指定类型

在这里插入图片描述
像这样

2.2 vector 的成员函数

vector和string的成员函数特别像

2.2.1 push_back 尾插

在这里插入图片描述

2.2.2 vector的遍历方式

第一种就是和字符串一样用下标去访问
迭代器
范围for

在这里插入图片描述

2.2.3 at 和[]

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/54af6f2bdc88408d8f2904376724a6df.png
at的作用和[]访问是差不多的，at访问如果越界了就是抛异常，[]访问下标如果越界了就是一个断言

2.2.4 front 和 back

在这里插入图片描述
分别是取头和尾

2.2.5 sort

在这里插入图片描述
用sort可以直接给vector排序默认是升序，要拍降序就要加一个

3 相关题目

https://leetcode.cn/problems/single-number/

> 这里是引用

class Solution {
public:
    int singleNumber(vector<int>& nums) 
    {
        int ret=0;
        for(auto e: nums)
        {
            ret = ret ^ e;
        }
        return ret;
    }
};

https://leetcode.cn/problems/pascals-triangle/submissions/571052519/

在这里插入图片描述

class Solution
{
public:
    vector<vector<int>> generate(int numRows) 
    {
       vector<vector<int>> vv;
       vv.resize(numRows);
       for(size_t i = 0 ; i < vv.size() ; i++)
       {
            vv[i].resize(i+1,0);
            vv[i][0] = vv[i][vv[i].size()-1] = 1;

            for(size_t j=0; j< vv[i].size();j++)
            {
                if(vv[i][j] != 1)
                {
                    vv[i][j] = vv[i-1][j] + vv[i-1][j-1];
                }
            }

       }
       return vv;
    }
};

4.vector 的模拟实现

//MyVector.h
#pragma once
#include<bits/stdc++.h>
using namespace std;
template<class T>
class my_vector
{
public:
	typedef T* iterator;
	/*my_vector(
		iterator start = nullptr,
		iterator finish = nullptr,
		iterator end_of_storage = nullptr)
	{

		 _start = start;
		 _finish = finish;
		 _end_of_storage = end_of_storage;
	}*/
	my_vector() = default;
	my_vector(const my_vector<T>& v)
	{
		 reserve(v.capacity());
		 
		for (auto e : v)
		{
			push_back(e);
		}
	}
	
	void swap(my_vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_end_of_storage, v._end_of_storage);
	}
	//v1 = v3;
	template<class InputIterator>
	 my_vector(InputIterator first, InputIterator last)
	{
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}
	 my_vector(size_t n, const T& val=T())
	 {
		 reserve(n);
		 for (size_t i = 0; i < n; i++)
		 {
			 push_back(val);
		 }
	 }
	my_vector<T>& operator=(my_vector<T> v)
	{
		swap(v);
		return *this;
	}
	~my_vector()
	{
		delete[] _start;
		_start = _finish = _end_of_storage = nullptr;
	}
	

	iterator begin()const
	{
		return _start;
	}
	iterator end()const
	{
		return _finish;
	}
	size_t capacity()const
	{
		return _end_of_storage - _start;
	}
	size_t size()
	{
		return _finish - _start;
	}
	T& operator[](size_t n)
	{
		assert(n < size());
		return _start[n];
	}
	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t oldsize = size();
			T* tmp = new T[n];
			if (_start)
			{
				memcpy(tmp, _start, sizeof(T) * size());
				delete[] _start;
			}
			_start = tmp;
			_finish = _start + oldsize;
			_end_of_storage = _start + n;
			
		}
		
	}
	void push_back(const T& x)
	{
		if (_finish == _end_of_storage)
		{
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);
		}
		
		*_finish = x;
		++_finish;


	}
	void pop_back()
	{
		assert(size() > 0);
		--_finish;
	}
	iterator insert(iterator pos,const T& x)
	{
		assert(pos >= _start);
		assert(pos <= _finish);
		if(_finish == _end_of_storage)
		{
			size_t len = pos - _start;
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);
			pos =_start + len;
		}
		auto end = _finish - 1;
		while (end >= pos)
		{
			*(end + 1) = *(end);
			--end;
		}
		*pos = x;
		++_finish;
		return pos;
	}
	void erase(iterator pos)
	{
		assert(pos >= _start);
		assert(pos <= _finish);
		auto it = pos + 1;
		while (it < _finish)
		{
			*(it - 1) = *it;
			it++; 
		}
		_finish--;
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _end_of_storage = nullptr;

};
void test()
{
	my_vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	for (int i = 0; i< v.size();i++)
	{
		cout << v[i] << ' ' ;

	}
	cout << endl;
	for (auto e : v)
	{
		cout << e << ' ';
	}
	cout << endl;	
	my_vector<int>::iterator  it= v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

}


//MyVector.cpp
#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<vector>
#include<bits/stdc++.h>
using namespace std;
#include"MyVector.h"

void test1()
{
    my_vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    for (size_t i = 0; i < v1.size(); i++)
    {
        cout << v1[i] << " ";
    }
    cout << endl;

    my_vector<int>::iterator it = v1.begin();
    while (it != v1.end())
    {
        cout << *it << " ";
        it++;
    }
    cout << endl;

    for (auto e : v1)
    {
        cout << e << " ";
    }
    cout << endl;

}
void test2()
{
    my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    //cout << v.at(2) << endl;
    cout << v[2] << endl;
}
void test3()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    cout << v.front() << endl;
    cout << v.back() << endl;
}
void test4()
{
    vector<int> v;
   
    v.push_back(13143);
    v.push_back(43234);
    v.push_back(1324);
    v.push_back(2113);
    v.push_back(4443);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
    sort(v.begin(), v.end(),greater<int>());
    for (auto e : v)
    {
        cout << e << " ";
    }
}
void test5()
{
    my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.insert(v.begin(), 0);
    v.erase(v.begin());
    v.erase(v.begin() + 1);
    for (auto e : v)
    {
        cout << e << ' ';
    }
    cout << endl;
}
void test6()
{
    my_vector<int> v1;
    v1.push_back(1);
    v1.push_back(1);
    v1.push_back(1);
    v1.push_back(1);
}
void test7()
{
    my_vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    for (auto e : v1)
    {
        cout << e << ' ';
    }
    cout << endl;
    my_vector<int> v2;
    v2.push_back(10);
    v2.push_back(20);
    v2.push_back(30);
    v2.push_back(40);

    my_vector<int> v3(v2);
    for (auto e : v3)
    {
        cout << e << ' ';
    }
    cout << endl;
    v1 = v3;
    for (auto e : v1)
    {
        cout << e << ' ';
    }

}
void test8()
{
    my_vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    my_vector<int> v2(v1.begin() + 1, v1.end() - 1);
    for (auto e : v2)
    {
        cout << e << ' ';
    }

}
int main()
{
    test8();
    
    return 0;
}


---

# 总结
要注意vector迭代器丢失的问题，注意更新新的it，可以更新成insert的返回值，这样就可以让it更新成它的下一个