vector

类中可以把void swap(vector<T>& v)写成void swap(vector & v)

文章目录

0.是什么

template < class T, class Alloc = allocator<T> > class vector; // generic template

——>是一个类模板

头文件：<vector>

1.构造

	vector<int>v1;//创建一个空vector
	vector<int>v2(10, 1);//创建一个vector，里面有10个1

	vector<int>v3(++v2.begin(), --v2.end());//按迭代器创建一个vector，里面有8个1

    //迭代器换成数组下标
    int arr[] = {1, 2, 3, 4, 5};
    vector<int> v4(arr, arr + 5);


    vector<int> v { 2,3,4,6,1,7 };//后面再说
  • vector<int> 类模板实例化
  • vector<int> v1; 用这个 类 定义了一个对象（变量） v1，并调用默认构造函数。
  • vector<int> v2(10, 1); 用这个 类 定义了一个对象（变量） v1，并调用 构造函数

关于类模板的知识在这里

为什么直接用数组下标也能构造？

  1. 指针满足迭代器的所有要求，指针可以直接用来充当迭代器

  2. vector有（范围）构造函数：

    template <class InputIterator>
    vector(InputIterator first, InputIterator last);

    是一个模板函数，它不关心 传进来的 类型，只要 满足 " 迭代器" 就行。

    ——>通过这个模版生成函数来构造

    （模板函数自动类型推导的知识在这里：【纯干货】C++ 模板核心知识点 函数模板 / 类模板语法 + 面试高频坑（类型推）导 / 实例化 / 分离编译）

2.遍历

  1. 下标（实际上是 重载operator[ ]）
  2. 通过迭代器
  3. 范围for

    vector<int> v { 2,3,4,6,1,7 };
    for (int i = 0; i < v.size(); i++)
        cout << v[i] << ",";

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

    for (auto e : v)
        cout << e << " ";

有关类和对象的知识，在这里：

【万字干货】C++类和对象从入门到精通：内存划分/访问限定符/this指针/默认成员函数/const用法/类型转换全拆解，附C++实现顺序表、链表、栈——吃透大厂面试高频考点-CSDN博客

AI问了好久！终于搞懂 C++ 命名空间 / 类 / 对象，90% 初学者都踩过的 getline 天坑全解-CSDN博客

类 = 类型，对象 = 用这个类型创建出来的变量。

概念 对应现实事物 说明
头文件（#include <string>） 电脑上的文件夹 按功能分类存放代码的容器
命名空间（std） 文件夹里的大箱子 防止名字冲突的隔离层
类（std::string） 箱子里的小盒子 自定义的类型，描述一类事物的共同属性和行为
对象（std::string s;） 用小盒子装的具体物品 用类创建出来的变量，是实际存在的实体
函数（std::getline） 箱子里的独立工具 完成特定功能的代码块
全局对象（std::cin） 箱子里已经装好的现成工具 标准库提前创建好、可以直接使用的对象
  • C++ 标准库所有的东西都在std这个命名空间里
  • 同名的命名空间会自动合并
  • 不同的标准库头文件，只是把std这个大命名空间分成了不同的小块

3.reserve

文档中说不会缩容

If n is greater than the current vector capacity, the function causes the container to reallocate its storage increasing its capacity to n (or greater).

In all other cases, the function call does not cause a reallocation and the vector capacity is not affected.


    vector<int> v { 2,3,4,6,1,7 };
    cout << "size:" << v.size() << endl << "capacity:" <<  v.capacity() << endl;

    v.reserve(10);
    cout << "size:" << v.size() << endl << "capacity:" << v.capacity() << endl;

    v.reserve(6);
    cout << "size:" << v.size() << endl << "capacity:" << v.capacity() << endl;

size:6
capacity:6
size:6
capacity:10
size:6
capacity:10

4.resize

  • n<size，删除数据
  • n>size，插入数据（插入传的第二个参数，没传就用value_type()），空间（capacity）不够就扩容

value_type是容器的元素类型别名，value_type()就是该元素类型的默认构造函数。

比如：

  • vector<int>的value_type()就是int() → 0
  • vector<string>的value_type()就是string() → 空字符串

resize 扩容时，如果你没指定填充值，就用这个默认值填充新元素。


    vector<int> v { 2,3,4,6,1,7 };
    for (auto e : v)
        cout << e << " ";
    cout << endl;
    cout << "size:" << v.size() << endl << "capacity:" <<  v.capacity() << endl;

    v.resize(10); 
    for (auto e : v)
        cout << e << " ";
    cout << endl;
    cout << "size:" << v.size() << endl << "capacity:" << v.capacity() << endl;

    v.resize(2); 
    for (auto e : v)
        cout << e << " ";
    cout << endl;
    cout << "size:" << v.size() << endl << "capacity:" << v.capacity() << endl;







2 3 4 6 1 7
size:6
capacity:6
2 3 4 6 1 7 0 0 0 0
size:10
capacity:10
2 3
size:2
capacity:10

5.插入

5.1push_back


    vector<int> v { 2,3,4,6,1,7 };
    v.push_back(88);

5.2insert

‼️注意点：

insert 后迭代器可能失效（insert 可能导致扩容，所有迭代器、引用、指针失效。）

image-20260529144003535

  1. 头插/中间插入（通过迭代器）
  2. 插入多个数据
    1. 通过迭代器
    2. 连续插入相同数据
    vector<int> v1 { 2,3,4,6,1,7 };

    v1.insert(v1.begin() + 3, 5);

//打印

    vector<int> v2 { 1,1,1,1,1,1 };
    v1.insert(v1.begin(), v2.begin(), v2.begin() + 4);

//打印

    v1.insert(v1.begin(), 2, 0);
     
//打印 


2 3 4 5 6 1 7
1 1 1 1 2 3 4 5 6 1 7
0 0 1 1 1 1 2 3 4 5 6 1 7

手搓

1.private:

// vector.h
namespace lcj
{
    template<class T>
    class vector
    {
    public:
        // ...
    private:
        iterator _start = nullptr;          // 指向数组的起始位置
        iterator _finish = nullptr;         // 指向最后一个有效数据的下一个位置
        iterator _end_of_storage = nullptr; // 指向整个已分配空间的末尾
    };
}

2.size，capacity，empty

// 返回有效元素个数
size_t size() const { return _finish - _start; }

// 返回总容量
size_t capacity() const { return _end_of_storage - _start; }

// 判断是否为空
bool empty()const
{ return _start == _finish; }

3.实现迭代器和operator[ ]

➡️有关 const对象，const函数 的知识，可以点击这里进行学习⬅️

  • 普通对象（非 const 对象）既可以调用 const 成员函数，也可以调用非 const 成员函数。
  • const 对象只能调用 const 成员函数
// vector的迭代器本质就是原生指针！
typedef T* iterator;
typedef const T* const_iterator;

// 普通迭代器（可以修改元素）
iterator begin() { return _start; }
iterator end() { return _finish; }

// const迭代器（只能读不能改）
const_iterator begin() const 
{ return _start; }

const_iterator end() const 
{ return _finish; }


// 普通版本，可以修改元素
T& operator[](size_t i)
{
    assert(i < size()); // 下标越界直接崩溃，比原生数组安全
    return _start[i];
}

// const版本，只能读不能改
const T& operator[](size_t i) const
{
    assert(i < size());
    return _start[i];
}


		void print()const 
		{
			const_iterator it = begin();
			while (it != end())
			{
				cout << *it << " ";
				++it;

			}
			cout << endl; 

			for (auto e : *this)
				cout << e << " ";
			cout << endl;
		}

为什么要专门新建一个：const迭代器const_iterator呢？

**原因：**const 对象就是代表“只读不修改”，如果返回普通迭代器就可以修改内容

reserve扩容

1.浅拷贝

此处使用的memcpy 是逐字节拷贝，对于 std::string、vector 等类类型，会导致浅拷贝，后面会细说

❌错误示例：

  • size（）是个函数，这时候会计算： _finish - _start;，可是这时候：_start = tmp;，start已经不是原来的start了

    ——>计算的size（）是错的

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

				_start = tmp;
				_finish = _start + size();
				_end_of_storage = _start + n;
			}
		}
修改方式1：
  • 先改_finish: _finish = tmp + size();，这时候size()还是用的原来的_finish
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				memcpy(tmp, _start, sizeof(T) * size());
				delete[] _start;

				_finish = tmp + size();

				_start = tmp;
				_end_of_storage = _start + n;
			}
		}
修改方式2：
  • 提前记录下原来的有效元素个数
// vector.h
void reserve(size_t n)
{
    if (n > capacity())
    {
        size_t old_size = size();        // 1. 先记录下原来的有效元素个数
        T* tmp = new T[n];               // 2. 开新空间
        memcpy(tmp, _start, size() * sizeof(T)); // 3. 拷贝数据
        delete[] _start;                 // 4. 释放旧空间

        _start = tmp;                    // 5. 更新三个指针 
        _finish = tmp + old_size;/////////////////////////////////////////////////////////////////
        _end_of_storage = tmp + n;
    }
}

2.深拷贝

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

				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;

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

push_back


void push_back(const T& x)
{
    // 检查是否需要扩容
    if (_finish == _end_of_storage)
    {
        reserve(capacity() == 0 ? 4 : capacity() * 2);
    }

    *_finish = x;   // 在当前finish位置存放数据
    ++_finish;      // 移动 finish 指针
}

实现print

类内

namespace lcj 内的class vector 中

		void print()const 
		{
			const_iterator it = begin();
			while (it != end())
			{
				cout << *it << " ";
				++it;

			}
			cout << endl; 

			for (auto e : *this)
				cout << e << " ";
			cout << endl;
		}

类外1

namespace lcj 内的class vector 外

没有实例化的类模板不能直接取得const_iterator

如果想用：

  1. 加typename，且只能加typename（不能用class）
  2. 用auto

	template<class T>
	void print_vector(const vector<T>& v)
	{
		///没有实例化的类模板不能直接取得const_iterator，且只能加typename
		typename vector<T>::const_iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;

		}
		cout << endl;

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

类外2

namespace lcj 内的class vector 外

没有实例化的类模板不能直接取得const_iterator

如果想用：

  1. 加typename，且只能加typename（不能用class）
  2. 用auto
	template<class Container>
	void print_container(const Container& v)
	{
		///没有实例化的类模板不能直接取得const_iterator，且只能加typename或者使用auto
		// typename Container::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;
	}

➡️豆包的详细介绍⬅️

insert

reserve后，pos改变 ➡️pos = _start + len;`——>更新迭代器

		iterator insert(iterator pos, T x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);


			iterator end = _finish - 1;

			int len = pos - _start;

			///扩容——注意迭代器失效
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2); 
				pos = _start + len;
			}
			/// 挪动数据
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;

			///改变_finish
			_finish++;
			
			return ++pos;
		}

迭代器失效

  1. 扩容导致_start 等指针都是新地址，原来的pos等地址不可用
  2. 不扩容的insert导致原指针意义改变，也不建议用（vs有强制检查，会报错）

erase

  • 迭代器也失效了‼️

⬇️没有考虑vector中是容器的情况——没有调用析构

		iterator erase(iterator pos)
		{
			int len = pos - _start;
			while (pos != _finish)
			{
				*pos = *( pos+1);
				pos++;
			}
			--_finish;
			pos = _start + len;
			return pos;
		}

⬇️ 考虑vector中是容器的情况——给删掉的位置上调用析构函数

// ✅ 正确：先销毁要删除的元素
iterator erase(iterator pos)
{
    assert(pos >= _start && pos < _finish);
    pos->~T(); // 先调用被删除元素的析构函数
    
    // 向前移动元素
    iterator it = pos;
    while (it != _finish - 1)
    {
        *it = *(it + 1);
        ++it;
    }
    
    --_finish;
    return pos;
}

resize

内置类型也有了构造函数int i=int()，默认是0

  1. n<size：删除数据
    1. _finish
  2. 其他情况：reserve：需要就扩容
    1. size<n<capacity：
    2. n>capacity
		void resize(size_t n, T val = T())///调用默认构造
		{
			if (n < size())
			{
				_finish = _start + n  ;
			}
			else
			{
				reserve(n);
				while (size() < n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

考虑 “ 直接赋值覆盖被删除元素，不会调用其析构函数，对于string、vector等自定义类型会导致 内存泄漏。”

// ✅ 缩容时逐个调用析构函数
void resize(size_t n, const T& val = T())
{
    if (n < size())//缩容
    {
        // 增加了析构函数的调用
        for (iterator it = _start + n; it != _finish; ++it)
        {
            it->~T();
        }
        
        
        
        _finish = _start + n;
    }
    
    
    
    
    else//扩容
    {
        reserve(n);
        while (size() < n)
        {
            *_finish = val;
            ++_finish;
        }
    }
}

clear

		void clear()
		{
			_finish = _start;
		}

void clear()
{
    // 逐个调用元素的析构函数
    for (iterator it = _start; it != _finish; ++it)
    {
        it->~T();
    }
    _finish = _start;
}

swap

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

为什么要自己写一个： swap❓

原因：

C++ 标准库提供的通用std::swap如下：

template<class T>
void swap(T& a, T& b) {
    T temp = a; // 拷贝构造
    a = b;      // 赋值
    b = temp;   // 赋值
}

这个实现对于int、double这种内置类型没问题，但对于vector这种需要深拷贝的类型，就是灾难：

  • 交换两个有 100 万个元素的 vector，默认std::swap会：

    1. 拷贝 100 万个元素到 temp
    2. 再拷贝 100 万个元素到 a
    3. 再拷贝 100 万个元素到 b

  • 总时间复杂度：O(n)，还要触发 3 次内存分配和释放

自己写的只做了3 次指针交换，👍

上面的拷贝构造，会导致两个vector指向相同的空间，会出问题

析构

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = 0;

			}
		}

构造

  • 两种写法（因为拷贝构造的存在——>如果这时候不自己写一个构造，编译器不会自动生成‼️——>必须自己写）

⬇️❌不完全写法，因为它们会是随机的野指针，而不是nullptr。

		vector()
		{ }

		vector() = default;//C++11有的
default默认构造⬆️

实际上的写法：

缺省声明

**作用：**初始化列表没有给这个成员变量初始化的时候用。（const，引用，没有默认构造函数的成员函数 不能用‼️，只能在初始化列表里初始化‼️）

// vector.h
namespace lcj
{
    template<class T>
    class vector
    {
    public:
        可能写法1：vector()
		{ }

		可能写法2：vector() = default;
        
        
        
    private:
        iterator _start = nullptr;          // 指向数组的起始位置
        iterator _finish = nullptr;         // 指向最后一个有效数据的下一个位置
        iterator _end_of_storage = nullptr; // 指向整个已分配空间的末尾
    };
}
和string的默认构造比较一下：
string(const char* s = "")
{
    _size = strlen(s);       // 空字符串长度是0
    _capacity = _size;       // 容量也是0
    _str = new char[_capacity + 1]; // 必须分配1个字节存'\0'
    strcpy(_str, s);         // 把'\0'拷贝进去
}

拷贝构造

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

operator=

古代写法：


		vector& operator =( const  vector<T>&  v)
		{
			if (this != &v)
			{
				///这里不用delete[], 避免再次开空间+resize等

				//delete[] _start;
				clear();
				for (auto& e : v)
				{
					push_back(e);
				}

			}
			return *this; 
		}

现代写法：

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

v就是拷贝构造来的，不是原来的，安全，直接和*this 交换。

而且v销毁后也可以直接调用析构，析构掉原来的*this 中的东西。👍

区间构造

类模板的成员函数，还可以继续是函数模版

namespace lcj 内的class vector 中

class vector 是一个类模板：template<class T>

		// 类模板的成员函数，还可以继续是函数模版
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

使用实例：



	void test_vector1()
	{
		vector<double> v;
		v.push_back(1.1);
		v.push_back(2.2);
		v.push_back(3.3);
		v.push_back(4.4);
		v.push_back(5.5);
		v.push_back(6.6);
        
		vector<double> v2(v.begin() + 1, v.begin() + 3);

		print_vector(v2);


		print_vector(v);
	}

2.2 3.3
1.1 2.2 3.3 4.4 5.5 6.6

填充构造

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

错误 ：
vector<int> v2(3,1);会调用上面的区间构造模板函数：vector(InputIterator first, InputIterator last)

因为类型转换更少

解决方法：

  • 写两个填充构造函数，减少类型转换

		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);
			}
		}

总代码

vector.h


#pragma once
#include<assert.h>
#include<iostream>
using namespace std;
namespace lcj
{
	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() = default;

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

		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);
			}
		}


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



		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = 0;

			}
		}

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

		//vector& operator =( const  vector<T>&  v)
		//{
		//	if (this != &v)
		//	{
		//		///这里不用delete[], 避免再次开空间+resize等

		//		//delete[] _start;
		//		clear();
		//		for (auto& e : v)
		//		{
		//			push_back(e);
		//		}

		//	}
		//	return *this;


		//}

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

		void clear()
		{
			_finish = _start;
		}

		size_t size()
		{
			return _finish - _start;
		}
		

		size_t capacity()
		{
			return _end_of_storage - _start;
		}

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

		//		delete[] _start;

		//		_finish = tmp + size(); 
		//		_start = tmp; 
		//		_end_of_storage = _start + n;
		//	}
		//}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t old_size = size();

				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;

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

		void push_back(const T& x)///T 的种类不确定，如果是个类，传值会拷贝构造
		{
			if (_finish == _end_of_storage)
				reserve(capacity() == 0 ? 4 : capacity() * 2);

			*_finish = x;
			++_finish;
		}

		T& operator[](size_t  i)
		{
			assert(i < size());
			return _start[i];
		}

		const T& operator[](size_t  i)const
		{
			assert(i < size());
			return _start[i];
		}

		void print()const 
		{
			//const_iterator it = begin();
			//while (it != end())
			//{
			//	cout << *it << " ";
			//	++it;

			//}
			//cout << endl; 

			for (auto e : *this)
				cout << e << " ";
			cout << endl;
		}

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

		void pop_back()
		{
			assert(empty());
			--_finish;
		}

		iterator insert(iterator pos, T x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);


			iterator end = _finish - 1;

			int len = pos - _start;

			///扩容——注意迭代器失效
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2); 
				pos = _start + len;
			}
			/// 挪动数据
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;

			///改变_finish
			_finish++;
			
			return ++pos;
		}

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

			// 扩容
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;

			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			int len = pos - _start;
			while (pos != _finish)
			{
				*pos = *( pos+1);
				pos++;
			}
			--_finish;
			pos = _start + len;
			return pos;
		}

		void resize(size_t n, T val = T())///调用默认构造
		{
			if (n < size())
			{
				_finish = _start + n  ;
			}
			else
			{
				reserve(n);
				while (size() < n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}


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

	template<class Container>
	void print_container(const  Container& v)
	{
		///没有实例化的类模板不能直接取得const_iterator，且只能加typename
		typename Container::const_iterator it = v.begin();
		//while (it != v.end())
		//{
		//	cout << *it << " ";
		//	++it;

		//}
		//cout << endl;

		for (auto& e : v)
			cout << e << " ";
		cout << endl;
	}

	template<class T>
	void print_vector(const vector<T>& v)
	{
		///没有实例化的类模板不能直接取得const_iterator，且只能加typename
		typename vector<T>::const_iterator it = v.begin();
		//while (it != v.end())
		//{
		//	cout << *it << " ";
		//	++it;

		//}
		//cout << endl;

		for (auto& e : v)
			cout << e << " ";
		cout << endl;
	}



	void test_vector1()
	{
		/*vector<double> v;
		v.push_back(1.1);
		v.push_back(2.2);
		v.push_back(3.3);
		v.push_back(4.4);
		v.push_back(5.5);
		v.push_back(6.6);*/


		/*for (size_t i = 0; i < v.size(); i++)
			cout << v[i] << endl;*/
		/*v.print();*/
		//auto pos = find(v.begin(), v.end(), 1.1);



		//pos = v.insert(pos + 1 , 1.23);
		//print_vector(v);

		//v.insert(pos, 2.33);
		//print_vector(v);

		//v.erase(find(v.begin(), v.end(), 2.33));

		//v.resize(10);

		//vector<double> v2(v.begin() + 1, v.begin() + 3);
		vector<string> v2 ;
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");
		v2.push_back("hello");

 
		print_container(v2);
		 
		//print_vector(v);
	}
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1 
#include<iostream>
using namespace std;


#include "vector.h"
 

int main() 
{
    lcj::test_vector1();
    return 0;
}
# 开发语言 # c++ # 面试
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

2026年，讯飞星火海外访问中转方案究竟有何独特之处？

avatar 亚马逊云科技技术品牌专区

Java分布式架构设计方法

服务拆分后，服务间的通信成为关键。事件驱动架构是另一种有效解耦和数据同步的方式，服务通过发布/订阅领域事件进行通信，借助Apache Kafka或RabbitMQ等消息中间件，可以实现事件的可靠传递与异步处理，提升系统整体响应能力。从业务拆分出发，选择恰当的通信与治理模式，妥善处理数据一致性，并构建完善的运维支撑体系。随着云原生理念的深入，Serverless、Service Mesh等新技术也在

avatar 亚马逊云科技技术品牌专区

分布式事务尝试取消确认模式的具体实现步骤

首先需要事务协调器（Transaction Coordinator），负责协调整个分布式事务的流程，记录事务状态，并在必要时触发补偿操作。尝试取消确认模式（Try-Cancel-Confirm，简称TCC）作为一种补偿型分布式事务解决方案，通过业务逻辑层面的拆解，提供了更灵活的一致性实现方式。未来，随着事务中间件的成熟和云原生技术的发展，TCC模式的实施成本将进一步降低，应用场景也将更加广泛。Co

avatar 亚马逊云科技技术品牌专区