【C++】C++ STL探索:Vector使用与背后底层逻辑

news2024/11/24 13:55:04

在这里插入图片描述

C++语法相关知识点可以通过点击以下链接进行学习一起加油！
命名空间缺省参数与函数重载C++相关特性类和对象-上篇类和对象-中篇
类和对象-下篇日期类C/C++内存管理模板初阶String使用
String模拟实现

在string类文章中提及了STL容器间的接口是大差不差的，本篇将直接通过模拟实现Vector来讲解底层实现与使用。

请添加图片描述
Alt
🌈个人主页：是店小二呀
🌈C语言笔记专栏：C语言笔记
🌈C++笔记专栏： C++笔记
🌈初阶数据结构笔记专栏： 初阶数据结构笔记
🌈Linux笔记专栏： Linux笔记

🌈喜欢的诗句:无人扶我青云志 我自踏雪至山巅 请添加图片描述

文章目录

  • 前文:vector介绍
  • 一、模拟实现Vector准备工作
    • 1.1 vector的成员对象
    • 1.2 原生指针模拟迭代器
  • 二、正式模拟实现Vector
    • 2.1 构造函数
      • 2.1.1 无参构造
      • 2.1.2 vector迭代区间构造
      • 2.1.3 初始化构造
    • 2.2 拷贝构造
    • 2.3 初始化列表
    • 2.4 析构函数
    • 2.5 operator[] 下标访问
    • 2.6 swap 交换函数
    • 2.7 operator= 赋值运算符重载
    • 2.8 得到当前元素空间信息
      • 2.8.1 size(有效元素个数)
      • 2.8.2 capacity(当前空间容量)
    • 2.9 reserve
      • 2.9.1 第一版本:野指针问题
      • 2.9.2 第二版本：浅拷贝问题
    • 2.10 resize(重点常用)
      • 2.10.1 const T& val = T()解释
    • 2.11 单或多参数构造支持隐式类型转化
    • 2.12 insert
      • 2.12.1 insert使用
    • 2.13 扩容前迭代器失效
    • 2.14 erase
      • 2.14.1 erase使用
      • 2.14.2 验证迭代器失效
      • 2.14.3缩容导致迭代器失效
    • 2.15 push_back
    • 2.16 pop_back
    • 2.17 pop_back
    • 2.18 empty 判断空
    • 2.19 print_vector 打印数据
  • 三、vector.h

前文:vector介绍

vector的文档介绍

  1. vector是表示可变大小数组的序列容器，底层是动态开辟顺序表
  2. vector插入新数据发生扩容，其做法是，分配一个新的数组，然后将全部元素移动到这个数组(单论时间，需要付出相对代价很高).每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小(不清楚这块空间剩余多少内存)
  3. vector分配空间策略:vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大，不同的库采用不同的策略权衡空间的使用和重新分配。重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的
  4. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更

一、模拟实现Vector准备工作

在模拟实现vector过程中，为了避免跟库中vector发生冲突，需要创建个命名空间，在命名空间中实现vector。需要选择现实vector类模板去用于不同的类型(内置类型、自定义类型)

namespace vec
{
	template<class T>
	class vector
	{

	};
}

1.1 vector的成员对象

适用于不同类型的操作，可以通过模板参数列表的类型指针，去对不同类型进行访问和修改。

template<class T>
    class vector
    {
        public:
        typedef T* iterator;
        typedef const T* const_iterator;

        private:
        iterator _start = nullptr;
        iterator _finish = nullptr;
        iterator _end_of_storage = nullptr;
    };

成员说明:

  • typedef T* iteratror:采用原生指针去模拟迭代器(不是真正的迭代器)
  • _start：指向空间的第一个位置
  • _finish：指向最后有效数据的位置
  • _end_of _storage：指向空间的最后一个位置

1.2 原生指针模拟迭代器

在这里插入图片描述

	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
        
        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 _end_of_storage = nullptr;
	};

二、正式模拟实现Vector

2.1 构造函数

在这里插入图片描述

在这里插入图片描述

具体说明：allocator_type是内存配置器（内存池）和explicit这个阶段都不用去理会它。最经常使用是接口(1)和(4)，其中(1)就当作是无参的构造，不用传什么值，就使用它的缺省值()

value_type()是模板参数列表实例化转化的T类型

2.1.1 无参构造

    vector()
    {}

这里就算不显式写无参构造，编译器也会自动生成。从某种意义上无参构造不用写，但是我们需要实现拷贝构造，编译器就不会默认生成无参构造函数了。总之要显式写无参构造函数。

2.1.2 vector迭代区间构造

类模板的成员函数可以是函数模板

template<class InputIterator>
    vector(InputIterator fist, InputIterator last)
{
    while (fist != last)
    {
        push_back(*fist);
        ++fist;
    }
}

使用场景：

vector<int> v2(v1.begin()+1, v1.end()-1);
print_vector(v2);

string str("abcd");
vector<int> v3(str.begin(), str.end());
print_vector(v3);

具体说明：在使用该接口时，需要注意不可以(--v1.begin(), --v1.end()使用。这里begin()和end()函数是传值返回，返回临时对象具有常性，不能通过++或–修改临时对象

2.1.3 初始化构造

vector(size_t n, const T* val = T())
{
    reserve(n);
    for (size_t i = 0; i < n; i++)
    {
        push_back(val);
    }
}

这段初始化构造逻辑是没有问题的，但是在调用过程可能会出现问题

首先给出三组数据，去使用初始化构造函数
    vector<int> v1(10, 1);
    print_vector(v1);

    vector<int> v2(10u, 1);
    print_vector(v2);

    vector<int> v3(10, 'a');
    print_vector(v3);

在这里插入图片描述

具体说明：在调用过程中会报出非法的间接寻址错误，原因在于第一个实例化(就这个比较特别)，调用的是函数模板，这里*first就会报错，想走捷径，发现掉坑里面。

  1. vector<int> v1(10, 1)参数部分都是整型类型，如果使用下面的初始化构造，需要int转化为size_t（发生隐式类型转化）。对于模板初始化函数而言，自动推导类型，对此上面更加匹配(那就报错哦)
  2. vector<int> v2(10u, 1)参数部分都是无符号整数，有现成吃现成，就是调用第二个
  3. vector<int> v3(10, 'a')参数部分是不同类型，自然调不动第一个函数，调用第二个函数，进行类型转化

解决措施：实现函数重载，特殊情况特殊处理

vector(size_t n, const T* val = T())
{
    reserve(n);
    for (size_t i = 0; i < n; i++)
    {
        push_back(val);
    }
}
vector(int n, const T& val = T())
{
    reserve(n);
    for (int i = 0; i < n; i++)
    {
        push_back(val);
    }
}

2.2 拷贝构造

vector(const vector<T>& v)
{
    //需要开一样大的空间
    reserve(v.capacity());
    for (auto& e : v)
    {
        push_back(e);
    }
}

具体说明:这里可以采用string类拷贝构造方式，但是这个更加简洁。auto自动识别类型建议加&，如果T是自定义类型，就需要调用多次拷贝构造(深拷贝)

2.3 初始化列表

auto x = { 1,2,3,4,5,6 };
cout << typeid(x).name() << endl;
cout << sizeof(x) << endl;
输出结果:
class std::initializer_list<int>

当我们想实现像数组nums[5] = {12,3,4,5}这样初始化，库提供初始化列表initializer_list的方式满足了我们的需求。

其中vector类也包含了这种方式

  1. initializer_list y = {1,2,3,4,5};
  2. vector x = {1,2,3,4,5};

通过类模板在vector类中实现该功能

vector(initializer_list<T> il)
{
    reserve(il.size());
    for (auto& e : il)
    {
        push_back(e);
    }
}

2.4 析构函数

~vector()
{
    delete[]_start;
    _start = nullptr;
    _finish = _end_of_storage = nullptr;
}

2.5 operator[] 下标访问

T& operator[](size_t pos)
{
    assert(pos <= size());

    return _start[pos];
}

const T& operator[](size_t pos) const
{
    assert(pos <= size());

    return _start[pos];
}

具体说明：

  • 下标加方括号仅限于物理逻辑连续的容器，比如:string、vector、list之类。
  • 针对对象是否被const修饰，需要重载两个函数(可读可写，可读不可写)。使用引用返回，可以修改到实参和提高效率

2.6 swap 交换函数

void swap(vector<T>& v)
{
    std::swap(_start, v._start);
    std::swap(_start, v._start);
    std::swap(_start, v._start);
}

2.7 operator= 赋值运算符重载

    //v2 = v1;
    vector<T>& operator=(vector<T> v)
    {
        swap(v);

        return *this;
    }

说明：跟string是同一套流程，这里就直接选用优化现代写法版本

2.8 得到当前元素空间信息

2.8.1 size(有效元素个数)

size_t size() const
{
    //指针 - 指针
    return _finish - _start;
}

2.8.2 capacity(当前空间容量)

size_t capacity()	const
{
    return _end_of_storage - _start;
}

说明:

  1. size是有效元素的个数，capacity是当前空间的容量
  2. 都是通过指针-指针得到的大小

2.9 reserve

2.9.1 第一版本:野指针问题

void reserve(size_t n)
{
    if (n > capacity())
    {
        T* tmp = new T[n];
        memcpy(tmp, _start, size(T) * n);

        delete[] _start;
        _start = tmp;
        _finish =  tmp + size();
        _end_of_storage =  tmp + n;
    }
}

在这里插入图片描述

不足之处:迭代器失效的问题，出现野指针_finish指向错误。在delete[] _start的时候，finish还在指向旧空间，导致调用size()得到数据错误。

解决办法:在销毁旧空间之前，提前保留size()的大小

void reserve(size_t n)
{
    if (n > capacity)
    {
        T& tmp = new T[n];
        size_t size = size();
        memcpy(tmp, _statr, sizeof(T) * n);

        delete[] _start;
        _start = tmp;
        _finish = tmp + size;
        _end_of_storage = tmp + n;
    }
}

2.9.2 第二版本：浅拷贝问题

在这里插入图片描述

问题说明:这里memcpy是逐字节拷贝，属于浅拷贝。当T为自定义类型，使用memcpy进行浅拷贝操作，会指向同一块空间。

_str指向的空间没有拷贝，导致指向同一块空间，调用析构函数会造成野指针问题。

解决办法:
在这里插入图片描述

void reserve(size_t n)
{
    if (n > capacity())
    {
        size_t old_size = size();

        T* tmp = new T[n];
        //memcpy(tmp, _start, size(T) * n);
        for (size_t i = 0; i < old_size; i++)
        {
            //自定义类型会赋值运算符重载
            tmp[i] = _start[i];
        }

        delete[] _start;
        _start = tmp;
        _finish = tmp + old_size;
        _end_of_storage = tmp +n ;
    }
}

这属于一种更加暴力的解法，直接将_start里面的数据拷贝过来

2.10 resize(重点常用)

//重点实现resize
void resize(size_t n, const T& val = T())
{
    //缩容
    if (n <= size())
    {
        //类似截断
        _finish = _start + n;
    }
    else
    {
        //提前扩容
        //大于capacity才起作用
        reserve(n);

        while (_finish < _start + n)
        {
            *_finish = val;
            _finish++;
        }
    }
}

具体说明:虽然没有reserve这么多坑，但是有几个知识点值得我们注意。

2.10.1 const T& val = T()解释

  • 对于T可能是内置类型或自定义类型，对于自定义类型不能通过简单常量作为缺省值，所以选择了T()调用构造函数作为缺省值最合适。
  • 对于内置类型不是说没有构造函数这一说法吗？好的，内置类型被迫升级下。内置类型也有了自己的构造函数和析构函数(平常一般不使用)，int就是0（char也是整型 ASCII码）、double就是0.0、指针就是空指针。
  • 因为缺省值怎么给都不合理，只能用自身的构造(匿名对象实例化)

2.11 单或多参数构造支持隐式类型转化

string str="1111";//构造+拷贝构造-->优化 直接构造
const string& str1="1111";//构造临时对象，引用的是临时对象

vector<string>v;
v.push_back(str);
v.push_back(string("2222"));
v.push_back("33333");

在这里插入图片描述

隐式类型+优化的情况:

vector<int> v1={1,2,3,4,5};

vector<int> v2({1,2,3,4,5}) //直接构造

2.12 insert

2.12.1 insert使用

在这里插入图片描述

    void insert(iterator pos, const T& val)
    {
        assert(_start <= pos);
        assert(pos <= _finish);

        //考虑是否需要扩容
        //说明空间已经满了
        if (_finish == _end_of_storage)
        {
            reserve(capacity() == 0 ? 4 : capacity() * 2);

        }

        //开始移动数据
        iterator it = _finish - 1;

        while (it >= pos)
        {
            *(it + 1) = *it;
            it--;
        }

        *pos = val;
        _finish++;
    }

具体说明：使用迭代器去模拟实现insert比起string模拟实现，在 while (it >= pos)没有pos为0的坑。涉及到开辟或销毁空间时，都有可能涉及到迭代器失效，对此都需要考虑到位。

2.13 扩容前迭代器失效

void test_vector()
{
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6);
    v1.push_back(7);
    v1.push_back(8);
    print_vector(v1);

    vector<int>::iterator it = v1.begin() + 3;
    v1.insert(it, 40);
    print_vector(v1);

    cout << *it << endl;
}

问题:在进行insert操作后，迭代器it就会失效。

在这里插入图片描述

思考:在扩容接口中，不是解决迭代器失效的问题了吗？

具体说明：

在调用insert接口是it传参pos位置，而形参是实参的一份临时拷贝，那么需要传引用解决。一波未平一波又起，如果传引用v2.insert(v2.begin(),11.11)，这里v2.begin()返回的是临时变量，不能通过引用来接收。

没有给出解决办法，调用insert接口出现扩容操作，迭代器会失效，不要去使用

2.14 erase

2.14.1 erase使用

//迭代器实现erase
iterator erase(iterator pos)
{
    assert(_start <= pos);
    //删除不到_finish这个位置
    assert(pos < _finish);

    iterator it = pos+1;

    //it=pos+1=_finish就是最后一个位置
    while (it <= _finish)
    {
        *(it - 1) = *(it);
        it++;
    }
    _finish--;
    return pos;
}

2.14.2 验证迭代器失效

接下来我将给出三个场景:都是关于删除偶数

第一个场景:没啥问题

		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		vector<int>::iterator it = v1.begin();
		while (it != v1.end())
		{
			if (*it % 2 == 0)
			{
				v1.erase(it);
			}
			++it;
		}

在这里插入图片描述

第二个场景:少删除

		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(4);
		v1.push_back(5);

		vector<int>::iterator it = v1.begin();
		while (it != v1.end())
		{
			if (*it % 2 == 0)
			{
				v1.erase(it);
			}
			++it;
		}

在这里插入图片描述

在这里插入图片描述

第三个场景:迭代器失效

vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
v1.push_back(4);

在这里插入图片描述

关于上面出现的问题分析:

  • 在erase的逻辑是通移动数据覆盖不需要的数据，达到删除的效果。逻辑上会跳过一个值，移动++可能会导致错过了一些值。
  • 如果it++操作跳过end()，it就会一路向北，错过了判断条件

解决措施:

vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
    if (*it % 2 == 0)
    {
        v1.erase(it);
    }
    else
    {
        it++;
    }
}
print_vector(v1);

2.14.3缩容导致迭代器失效

上面解决措施在Linux下还可以，但是在Vs下就不行了。由于因为Vs下的iterator没有使用原生指针实现，是自定义类型的迭代器，内部会进行强制类型检查。

在这里插入图片描述

对于erase不同编译器迭代器是不同的，erase也可能会缩容。erase迭代器的解决方案有两个：迭代器失效以后不要直接使用，如果要使用按照规则重新更新后使用。

	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			it=v1.erase(it);
		}
		else
		{
			it++;
		}
	}

这样子就可以适应不同的版本，缩容以后。迭代器还是但会删除原生的下一个迭代器。

2.15 push_back

void push_back(const T& val )
{
    insert(end(), val);
}

2.16 pop_back

void pop_back()
{
    /*assert(!empty());

                --_finish;*/

    erase(end()-1);
}

2.17 pop_back

void pop_back()
{
    /*assert(!empty());

                --_finish;*/

    erase(end()-1);
}

2.18 empty 判断空

bool empty()
{
    return _start == _finish;
}

2.19 print_vector 打印数据

为了实现适用于不同类型的打印，这里需要涉及一个函数模板

void print_vector(const vector<T>& v)
{
    //下标加[]
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;

    //迭代器
    vector<T>::const_iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    //范围for
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;、
}

不足之处：在三种遍历方式，使用迭代器遍历会出现报错。

问题在于: vector<T>,这里类模板没有实例化，对于内嵌类型，那么不敢进去取，里面的东西也有没有实例化。编译器无法识别const_iterator是静态变量还是内中类,选择报错。

vector类模板没有完成实例化，对于内嵌类型const_iterator不敢进去取，对于内部是否实例。编译器无法编译器无法识别const_iterator是静态变量还是内中类。编译器选择报错。

解决措施:编译器规定typename告诉后面后面是一个类型，不是静态成员变量(先通过编译，之后再给你实例化)。在编译阶段才知道类型，如果需要一个类型接收，可以使用auto自动识别类型。

typename vector<T>::const_iterator it = v.begin();
auto it = v.begin();
while (it != v.end())
{
    cout << *it << " ";
    ++it;
}
cout << endl;

三、vector.h

#pragma once
#include <assert.h>
#include <iostream>
#include <algorithm>

using namespace std;
namespace bit
{
    template<class T>
        class vector
        {
            public:
            typedef  T*  iterator;
            typedef const T* const_iterator;


            iterator begin()
            {
                return _start;
            }

            iterator end()
            {
                return _finish;
            }

            const_iterator begin() const
            {
                return _start;
            }


            const_iterator end() const
            {
                return _finish;
            }


            //构造函数
            //无参构造
            vector()
            {}
            //有参构造
            //.....

            //析构
            ~vector()
            {
                delete[]_start;
                _start = nullptr;
                _finish = _end_of_storage = nullptr;
            }

            //vector<int> v1={1,2,3,4,5,6};
            vector(initializer_list<T> il)
            {
                reserve(il.size());
                for (auto& e : il)
                {
                    push_back(e);
                }
            }

            //拷贝构造
            //v2(v1)
            vector(const vector<T>& v)
            {
                //需要开一样大的空间
                reserve(v.capacity());

                for (auto& e : v)
                {
                    push_back(e);
                }
            }
            //v2 = v1;
            vector<T>& operator=(vector<T> v)
            {
                swap(v);

                return *this;
            }
            //通过下标访问
            //并且不知道会返回什么具体的类型
            T& operator[](size_t pos)
            {
                //不能等于size()，指向\0
                assert(pos < size());

                return _start[pos];
            }

            const T& operator[](size_t pos) const
            {
                assert(pos < size());

                return _start[pos];
            }

            //交换
            void swap(vector<T>& v)
            {
                std::swap(_start, v._start);
                std::swap(_start, v._start);
                std::swap(_start, v._start);
            }

            //得到当前元素空间信息

            //指针-指针
            size_t size()	const
            {
                return _finish - _start;
            }

            size_t capacity()	const
            {
                return _end_of_storage - _start;
            }

            //扩容
            //第一个问题，迭代器失效
            //void reserve(size_t n)
            //{
            //	if (n > capacity())
            //	{
            //		T* tmp = new T[n];
            //		memcpy(tmp, _start, size(T) * n);

            //		delete[] _start;
            //		_start = tmp;
            //		_finish =  tmpt + size();
            //		_end_of_storage =  tmp + n;
            //	}
            //}

            改良
            第二个问题，当T为自定义类型，就是浅拷贝，但是还是指向同一块空间
            //void reserve(size_t n)
            //{
            //	if (n > capacity())
            //	{
            //		size_t old_size = size();

            //		T* tmp = new T[n];
            //		memcpy(tmp, _start, size(T) * n);

            //		delete[] _start;
            //		_start = tmp;
            //		_finish =  tmp + old_size;
            //		_end_of_storage =  tmp + n;
            //	}
            //}

            正确写法
            void reserve(size_t n)
            {
                if (n > capacity())
                {
                    size_t old_size = size();

                    T* tmp = new T[n];
                    //memcpy(tmp, _start, size(T) * n);
                    for (size_t i = 0; i < old_size; i++)
                    {
                        tmp[i] = _start[i];
                    }

                    delete[] _start;
                    _start = tmp;
                    _finish = tmp + old_size;
                    _end_of_storage = tmp +n ;
                }
            }

            //vector的迭代区间
            //函数模板
            template<class InputIterator>
                vector(InputIterator fist, InputIterator last)
            {
                while (fist != last)
                {
                    push_back(*fist);
                    ++fist;
                }
            }

            //初始化 构造
            vector(size_t n, const T& val = T())
            {
                reserve(n);
                for (size_t i = 0; i < n; i++)
                {
                    push_back(val);
                }
            }

            vector(int n, const T& val = T())
            {
                reserve(n);
                for (int i = 0; i < n; i++)
                {
                    push_back(val);
                }
            }
            //重点实现resize
            void resize(size_t n, const T& val = T())
            {
                //缩容
                if (n <= size())
                {
                    _finish = _start + n;
                }
                else
                {
                    //提前扩容
                    //大于capacity才起作用
                    reserve(n);

                    while (_finish < _start + n)
                    {
                        *_finish = val;
                        _finish++;
                    }
                }
            }
            //核心操作
            void push_back(const T& val )
            {
                insert(end(), val);
            }


            void pop_back()
            {
                /*	assert(!empty());
			_finish--;*/

                //不能--
                erase(end() - 1);
            }

            //判断空
            bool empty()
            {
                return _start == _finish;
            }

            //实现插入操作时，可能会涉及到扩容操作，就有可能出现迭代器失效的可能
            void insert(iterator pos, const T& val )
            {
                assert(_start <= pos);
                assert(pos <= _finish);

                //考虑是否需要扩容
                //说明空间已经满了
                if (_finish == _end_of_storage)
                {
                    size_t len = pos - _start;
                    //这里迭代器失效的问题
                    //不是解决了吗！当时pos没有解决呀！
                    reserve(capacity() == 0 ? 4 : capacity() * 2);

                    pos = _start + len;
                }

                //开始移动数据
                iterator it = _finish - 1;

                while (it >= pos)
                {
                    *(it + 1) = *it;
                    it--;
                }

                *pos = val;
                _finish++;
            }

            //迭代器实现erase
            iterator erase(iterator pos)
            {
                assert(_start <= pos);
                //删除不到_finish这个位置
                assert(pos < _finish);

                iterator it = pos+1;

                //it=pos+1=_finish就是最后一个位置
                while (it <= _finish)
                {
                    *(it - 1) = *(it);
                    it++;
                }
                _finish--;
                return pos;
            }

            private:
            iterator _start=nullptr;
            iterator _finish=nullptr;
            iterator _end_of_storage=nullptr;
        };

    // 函数模板
    template<class T>
        void print_vector(const vector<T>& v)
    {
        //for (size_t i = 0; i < v.size(); i++)
        //{
        //	cout << v[i] << " ";
        //}
        //cout << endl;

        //typename vector<T>::const_iterator it = v.begin();
        auto it = v.begin();
        while (it != v.end())
        {
            cout << *it << " ";
            ++it;
        }
        cout << endl;

        /*for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;*/
    }

    void test1()
    {
        vector<int> v;
        v.push_back(12);
        v.pop_back();
        v.push_back(1);
        print_vector(v);
    }


    void test_vector2()
    {
        vector<int> v1(10, 1);
        print_vector(v1);

        vector<int> v2(10u, 1);
        print_vector(v2);

        vector<int> v3(10, 'a');
        print_vector(v3);
    }

    void test_vector3()
    {
        vector<int> v1;
        v1.push_back(1);
        v1.push_back(2);
        v1.push_back(3);
        v1.push_back(4);
        v1.push_back(5);
        v1.push_back(6);
        v1.push_back(7);
        v1.push_back(8);
        print_vector(v1);

        vector<int>::iterator it = v1.begin() + 3;
        v1.insert(it, 40);
        print_vector(v1);

        cout << *it << endl;
    }

    void test_vector4()
    {
        auto x = { 1,2,3,4,5,6 };
        cout << typeid(x).name() << endl;
        cout << sizeof(x) << endl;
    }

    void test_vector5()
    {
        vector<int> v1;
        v1.push_back(1);
        v1.push_back(2);
        v1.push_back(3);
        v1.push_back(4);
        v1.push_back(5);
        v1.push_back(4);

        //std::vector<int>::iterator it = v1.begin();
        vector<int>::iterator it = v1.begin();
        while (it != v1.end())
        {
            if (*it % 2 == 0)
            {
                it=v1.erase(it);
            }
            else
            {
                it++;
            }
        }
        print_vector(v1);
    }
}

以上就是本篇文章的所有内容，在此感谢大家的观看！这里是店小二呀C++笔记，希望对你在学习C++语言旅途中有所帮助！
请添加图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2109237.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

虚幻5|不同骨骼受到不同伤害|小知识（2）

虚幻5|不同骨骼受到不同伤害|小知识（2）

1.蓝图创建一个结构&#xff0c;B_BoneDamage 结构里添加一个浮点变量&#xff0c;表示伤害倍数 2.当我们创建了一个结构&#xff0c;就需要创建一个数据表格&#xff0c;数据表格可以选择对应的结构 不同骨骼不同倍数伤害&#xff0c;骨骼要对应骨骼网格体的名称 3.把我们br…
阅读更多...
C#继承_里氏替换原则

C#继承_里氏替换原则

知识点一&#xff1a;基本概念 知识点二&#xff1a;基本实现 #region 知识点二基本实现class GameObject{}class Player : GameObject{public void PlayerAtk(){Console.WriteLine("玩家攻击");}}class Monster : GameObject{public void PlayerAtk(){Console.Writ…
阅读更多...
NLP从零开始------文本中阶处理之序列到序列模型（完整版）

NLP从零开始------文本中阶处理之序列到序列模型（完整版）

1. 序列到序列模型简介 序列到序列( sequence to sequence, seq2seq) 是指输入和输出各为一个序列(如一句话) 的任务。本节将输入序列称作源序列&#xff0c;输出序列称作目标序列。序列到序列有非常多的重要应用&#xff0c; 其中最有名的是机器翻译( machine translation), 机…
阅读更多...
消息中间件都有哪些

消息中间件都有哪些

RabbitMQ&#xff1a;这可是一个开源的消息代理软件&#xff0c;也叫消息中间件。它支持多种消息传递协议&#xff0c;可以轻松地在分布式系统中进行可靠的消息传递。 Kafka&#xff1a;Apache Kafka是一个分布式流处理平台&#xff0c;它主要用于处理实时数据流。Kafka的设计初…
阅读更多...
时下改变AI的6大NLP语言模型

时下改变AI的6大NLP语言模型

本文将深入研究大语言模型领域的最新进展&#xff0c;改变AI的6大NLP语言模型&#xff0c;每个模型能够引入的增强功能、以及潜在功能应用与限制。 在快速发展的人工智能&#xff08;AI&#xff09;领域&#xff0c;自然语言处理&#xff08;Natural Language Processing&#…
阅读更多...
6.1均值滤波

6.1均值滤波

目录 实验原理 示例代码 运行结果 注意事项 总结 实验代码 运行结果 实验原理 https://zhuanlan.zhihu.com/p/76188487 在OpenCV中&#xff0c;cv::blur函数用于对图像进行均值滤波&#xff08;Mean Filter&#xff09;&#xff0c;这是一种线性滤波技术&#xff0c;主…
阅读更多...
科技信贷业务怎么寻找客户？

科技信贷业务怎么寻找客户？

在科技信贷业务领域&#xff0c;寻找客户的痛点主要集中在以下几个方面&#xff1a; 1.风险评估难题&#xff1a;科技型企业尤其是初创企业&#xff0c;往往缺乏足够的历史数据和抵押物&#xff0c;这使得金融机构在评估其信用风险时面临较大挑战。由于科技企业的研发周期长、…
阅读更多...
视频监控系统布局策略：EasyCVR视频汇聚平台构建高效、全面的安全防线

视频监控系统布局策略：EasyCVR视频汇聚平台构建高效、全面的安全防线

随着科技的飞速发展&#xff0c;视频监控系统已成为现代社会安全防范的重要组成部分&#xff0c;广泛应用于公共场所、企业园区、住宅小区等各个领域。一个科学合理的视频监控系统布局与选型策略&#xff0c;不仅能够显著提升安全监控的效率和效果&#xff0c;还能在关键时刻提…
阅读更多...
我用 GPT 学占星

我用 GPT 学占星

最近对占星赶兴趣&#xff0c;但是看到星盘中好多名词&#xff0c;不懂是什么意思&#xff1f;所以直接问 gpt &#xff0c; 发现回答的真的很棒&#x1f389; &#xff01; 假如我想知道各个状态的具体是根据什么数据来显示的&#xff1f; 分分钟解决了我的问题&#xff1b; 我…
阅读更多...
OpenFeign请求拦截器，注入配置属性类（@ConfigurationProperties），添加配置文件（yml）中的token到请求头

OpenFeign请求拦截器，注入配置属性类（@ConfigurationProperties），添加配置文件（yml）中的token到请求头

一、需求 OpenFeign请求拦截器&#xff0c;注入配置属性类&#xff08;ConfigurationProperties&#xff09;&#xff0c;添加配置文件&#xff08;yml&#xff09;中的token到请求头 在使用Spring Boot结合OpenFeign进行微服务间调用时&#xff0c;需要在发起HTTP请求时添加一…
阅读更多...
【Linux高级命令】1_进程和端口相关命令

【Linux高级命令】1_进程和端口相关命令

文章目录 一、重启和关机的命令【了解】二、进程2.1 查看系统进程&#xff1a;ps 【重点】2.1.1 grep结合管道符去查找特定的进程信息 2.2 实时查看系统的进程信息&#xff1a;top2.3 关闭进程&#xff1a;kill【重点】 三、端口3.1 查看系统监听端口&#xff1a;netstat【重点…
阅读更多...
Notepad++ 下载安装教程

Notepad++ 下载安装教程

目录 1.下教程 2.安装教程 1.下教程 Downloads | Notepad (notepad-plus-plus.org) 进入下载地址后选择最新版点击连接 点击链接后&#xff0c;向下滑动&#xff0c;下载适合自己电脑版本的安装包 这里大家没有梯子可能打不开页面&#xff0c;可以直接从本文开头下载。 2.安…
阅读更多...
【vscode】vscode paste image插件设置

【vscode】vscode paste image插件设置

本文首发于 ❄️慕雪的寒舍 vscode编辑md文件的时候&#xff0c;如果想插入图片&#xff0c;自带的粘贴只会粘贴到当前目录下&#xff0c;也没有文件重命名&#xff0c;很不友好。 在扩展商店里面有mushan的Paste Image插件&#xff0c;相比自带的&#xff0c;更加友好一点。但…
阅读更多...
物联网之ESP32控制舵机、通过网页设置舵机角度、Web服务、舵机原理、接线、Arduino、WiFi、Http

物联网之ESP32控制舵机、通过网页设置舵机角度、Web服务、舵机原理、接线、Arduino、WiFi、Http

MENU 前言原理硬件电路设计软件程序设计LEDC输出PWM信号使用第三方库控制舵机网页控制舵机 前言 舵机在电子产品中非常常见&#xff0c;比如四足机器人、固定翼航模等都有应用&#xff0c;因此学习舵机对电子制作非常有意义。本文章使用Arguino的PWM对SG90舵机旋转角度控制。 原…
阅读更多...
什么是Hash冲突？如何解决Hash冲突？

什么是Hash冲突？如何解决Hash冲突？

目录 一丶什么是Hash冲突 二丶如何解决Hash冲突 简介&#xff1a;Hash叫做‘散列表’&#xff0c;就是把任意长度输入&#xff0c;通过散列算法&#xff0c;变成固定长度输出&#xff0c;该输出结果是散列值。其实这种转换是一种压缩映射&#xff0c;散列表的空间通常小于输入…
阅读更多...
深入解析EF Core并发控制：乐观与悲观策略的全面对比与实战应用

深入解析EF Core并发控制：乐观与悲观策略的全面对比与实战应用

1. 前言 在使用EF Core开发应用程序时&#xff0c;并发控制是确保数据一致性的重要机制。EF Core 提供了两种主要的并发控制策略&#xff1a;乐观并发控制和悲观并发控制。它们各自有不同的应用场景和实现方式。本文将详细介绍这两种并发控制的区别、常见的应用场景&#xff0…
阅读更多...
fastadmin 文件上传七牛云

fastadmin 文件上传七牛云

1-安装七牛云官方SDK composer require qiniu/php-sdk 2-七牛云配置 <?phpnamespace app\common\controller;use Qiniu\Storage\BucketManager; use think\Config; use Qiniu\Auth; use Qiniu\Storage\UploadManager; use think\Controller; use think\Db;/*** 七牛基类*…
阅读更多...
python操作kafka

python操作kafka

一、参考阿里云的官方链接&#xff1a; 使用Python SDK接入Kafka收发消息_云消息队列 Kafka 版(Kafka)-阿里云帮助中心 二、安装python环境 三、添加python依赖库 pip install confluent-kafka1.9.2 四、新建一个setting.py文件配置信息 kafka_setting {sasl_plain_user…
阅读更多...
爆改YOLOv8|利用SCConv改进yolov8-即轻量又涨点

爆改YOLOv8|利用SCConv改进yolov8-即轻量又涨点

1&#xff0c;本文介绍 SCConv&#xff08;空间和通道重构卷积&#xff09;是一种高效的卷积模块&#xff0c;旨在优化卷积神经网络&#xff08;CNN&#xff09;的性能&#xff0c;通过减少空间和通道的冗余来降低计算资源的消耗。该模块由两个核心组件构成&#xff1a; 空间重…
阅读更多...
斯坦福UE4 C++课学习补充25：寻路EQS

斯坦福UE4 C++课学习补充25：寻路EQS

文章目录 一、创建EQS二、修改行为树三、查询上下文 一、创建EQS 场景查询系统EQS&#xff1a;可用于收集场景相关的数据。然后该系统可以使用生成器&#xff0c;通过各种用户定义的测试就这些数据提问&#xff0c;返回符合所提问题类型的最佳项目Item。 EQS的一些使用范例包…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023