首页 > 其他分享 >STL之vector篇（下）（手撕底层代码，从零实现vector的常用指令，深度剖析并优化其核心代码）

STL之vector篇（下）（手撕底层代码，从零实现vector的常用指令，深度剖析并优化其核心代码）

时间：2024-09-27 18:18:44浏览次数：9  
标签：finish v1 STL 代码 back start vector size

文章目录

前言：

在编程的浩瀚星空中，数据结构如同指引方向的星辰，它们不仅是构建算法与程序大厦的基石，更是解决复杂问题、优化性能的关键所在。其中，vector作为C++标准模板库（STL）中的一颗璀璨明珠，凭借其灵活、高效的特点，在软件开发中占据了举足轻重的地位。

vector，即向量容器，是一种能够存储任意类型对象的动态数组。它封装了动态数组的所有特性，包括自动的内存管理、灵活的元素访问方式以及高效的随机访问性能，同时还提供了丰富的成员函数来支持元素的插入、删除、遍历等操作。与静态数组相比，vector的最大优势在于其大小可以动态变化，无需程序员手动管理内存，极大地简化了编程复杂度，提高了代码的安全性和可维护性。
本文旨在深入探讨vector的内部机制、使用技巧及最佳实践，帮助读者全面了解并掌握这一强大的数据结构。我们将从vector的基本概念和特性出发，逐步深入到其内存管理策略、迭代器使用、元素操作、性能优化等多个方面。同时，结合实际应用场景，展示vector在解决各种编程问题时的独特魅力和高效性。

无论你是C++编程的初学者，还是希望提升编程技能的老手，本文都将为你提供宝贵的参考和实用的指导。让我们一起踏上这场关于vector的探索之旅，解锁C++编程的新世界，感受数据结构的魅力与力量。

1.基本结构与初始化

1.1 空构造函数的实现与测试

  • 实现一个空的vector，不分配任何内存。
  • 测试是否创建了容量为0的vector。

实现代码：

namespace xny {
    template<class T>
    class vector {
    public:
        typedef T* iterator;

        vector() {}

        size_t size() const {return _finish - _start;}
        size_t capacity() const {return _endofstorage - _start;}
        bool empty() const {return _start == _finish;}

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

测试样例：

void testvector1() {
    xny::vector<int> v;
    assert(v.size() == 0);  // 验证大小
    assert(v.capacity() == 0);  // 验证容量
    assert(v.empty());  // 验证是否为空
    cout << "testvector1 passed" << endl;
}

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

输出：

testvector1 passed

1.2 带大小和默认值的构造函数

  • 初始化一个给定大小的vector，并使用默认值填充。
  • 测试构造后大小、容量是否符合要求。

实现代码：

namespace xny {
    template<class T>
    class vector {
    public:
        typedef T* iterator;

        vector() {}

        vector(size_t n, const T& val = T()){    // 缺省参数用T类型的匿名对象
            _start = new T[n];
            _finish = _start + n;
            _endofstorage = _finish;
            for (size_t i = 0; i < n; i++) {
                _start[i] = val;  // 填充默认值
            }
        }

        T& operator[](size_t pos) { return _start[pos]; }

        size_t size() const {return _finish - _start;}
        size_t capacity() const {return _endofstorage - _start;}
        bool empty() const {return _start == _finish;}

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

测试样例：

void testvector2(){
    xny::vector<int> v(4, 1);
    assert(v.size() == 4);  // 验证大小
    assert(v.capacity() == 4);  // 验证容量
    assert(!v.empty());  // 验证是否为空
    for (size_t i = 0; i < 4; ++i) {
        assert(v[i] == 1);  // 验证默认值
    }
    cout << "testvector2 passed" << endl;
}

int main()
{
    testvector3();

    return 0;
}

输出：

testvector2 passed

1.3 使用迭代器范围初始化的构造函数(建议先看完后面的reserve和push_back)

【思考】：

  • 假设我用上述代码去实现以下样例会发生什么呢？
void testvector3() {
    int arr[] = { 1, 2, 3, 4, 5 };
    xny::vector<int> v(arr, arr + 5); // 使用迭代器范围初始化构造函数
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

【结果】：

  • 这时我们意识到可能需要重新定义一个构造函数，并且这个构造函数可以使用迭代器范围初始化。

添加代码如下：

namespace xny {
    template<class T>
    class vector {
    public:
        typedef T* iterator;

        iterator begin(){ return _start; }
        iterator end(){ return _finish; }

        vector() {}

        vector(size_t n, const T& val = T()){    // 缺省参数用T类型的匿名对象
            _start = new T[n];
            _finish = _start + n;
            _endofstorage = _finish;
            for (size_t i = 0; i < n; i++) {
                _start[i] = val;  // 填充默认值
            }
        }
        
		// 使用迭代器范围初始化的构造函数
        template<class InputIterator>
        vector(InputIterator first, InputIterator last){
            while (first != last)	// 迭代器区间左闭右开
            {
                push_back(*first);
                ++first;
            }
        }

        void reserve(size_t n){
            if (n > capacity()){
                size_t sz = size();
                T* tmp = new T[n];
                if (_start){
                    for (size_t i = 0; i < sz; i++){
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }

                _start = tmp;
                _finish = _start + sz;
                _endofstorage = _start + n;
            }
        }

        void push_back(const T& x){
            if (_finish == _endofstorage){
                size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapacity);
            }

            *_finish = x;
            ++_finish;
        }

        T& operator[](size_t pos) { return _start[pos]; }

        size_t size() const {return _finish - _start;}
        size_t capacity() const {return _endofstorage - _start;}
        bool empty() const {return _start == _finish;}

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

测试样例：

void testvector3() {
    int arr[] = { 1, 2, 3, 4, 5 };
    xny::vector<int> v1(arr, arr + 5); // 使用迭代器范围构造函数
    for (auto e : v1){
        cout << e << " ";
    }
    cout << endl;

    string str("hello world");
    xny::vector<char> v2(str.begin(), str.end());
    for (auto e : v2) {
        cout << e << " ";
    }
    // 这里我们用两种不同类型的迭代器进行测试
}

输出：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

【思考】：

  • 怎么回事呢？编译器又报错了，并且这次报的错比较模糊，于是我们可以直接搜索error C2100，看看编译示例：

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

【解释】：

  • 结合以上所有的编译报错我们终于发现错误的原因可能是非法寻址了，于是再次进行改进添加代码如下：
vector(int n, const T& val = T()) {    
    _start = new T[n];
    _finish = _start + n;
    _endofstorage = _finish;
    for (size_t i = 0; i < n; i++) {
        _start[i] = val; 
    }
}

输出：

1 2 3 4 5
h e l l o   w o r l d

1.4 拷贝构造函数

  • 实现vector的拷贝构造函数。
  • 测试拷贝后的vector是否完全复制原来的内容和容量。

实现代码:

namespace xny {
    template<class T>
    class vector {
    public:
        typedef T* iterator;
        
        vector() {}
        
        vector(size_t n, const T& val = T()){    
            _start = new T[n];
            _finish = _start + n;
            _endofstorage = _finish;
            for (size_t i = 0; i < n; i++) {
                _start[i] = val;  
            }
        }
        
        vector(const vector<T>& v){
            size_t sz = v.size();   
            _start = new T[capacity()];
            for (size_t i = 0; i < sz; i++) {
                _start[i] = v._start[i];
            }

            _finish = _start + sz;
            _endofstorage = _start + v.capacity();
        }

        T& operator[](size_t pos) { return _start[pos]; }

        size_t size() const {return _finish - _start;}
        size_t capacity() const {return _endofstorage - _start;}
        bool empty() const {return _start == _finish;}

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

测试样例:

void testvector4() {
    xny::vector<int> v1(5, 10);
    xny::vector<int> v2(v1);
    assert(v2.size() == 5);  // 验证大小
    assert(v2.capacity() == 5);  // 验证容量
    for (size_t i = 0; i < 5; ++i) {
        assert(v2[i] == 10);  // 验证数据拷贝
    }
    std::cout << "testvector4 passed" << std::endl;
}

int main()
{
    testvector4();

    return 0;
}

输出：

testvector4 passed

1.5 赋值操作符的实现（深拷贝）

  • 实现赋值操作符重载。
  • 测试两个vector赋值后，是否正确拷贝了内容和容量。

实现代码:

namespace xny {
    template<class T>
    class vector {
    public:
        typedef T* iterator;
        
        vector() {}

        vector(size_t n, const T& val = T()){    
            _start = new T[n];
            _finish = _start + n;
            _endofstorage = _finish;
            for (size_t i = 0; i < n; i++) {
                _start[i] = val;  
            }
        }
        
		// 自定义一个swap函数方便拷贝
        void swap(const vector<T> v){
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endofstorage, v._endofstorage);
        }
		
        // 赋值运算符重载
        vector<T>& operator=(const vector<T>& v){
            swap(v);
            return *this;
        }

        T& operator[](size_t pos) { return _start[pos]; }

        size_t size() const {return _finish - _start;}
        size_t capacity() const {return _endofstorage - _start;}
        bool empty() const {return _start == _finish;}

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

【说明】：

  • **传值参数：**通过传递 vector<T> 的值作为参数，创建一个临时对象 v。调用拷贝构造函数时自动执行拷贝，然后在赋值操作中与现有对象交换内容。传值是安全的，避免了手动内存管理问题。
  • **swap函数：**通过交换数据成员，避免手动内存释放，简化代码逻辑。交换后的临时对象 v 离开作用域时自动销毁，保证资源释放。

测试样例:

void testvector5() {
    xny::vector<int> v1(5, 10);
    xny::vector<int> v2 = v1;  // 赋值操作
    assert(v2.size() == 5);  // 验证大小
    assert(v2.capacity() == 5);  // 验证容量
    for (size_t i = 0; i < 5; ++i) {
        assert(v2[i] == 10);  // 验证数据拷贝
    }
    std::cout << "testvector5 passed" << std::endl;
}

int main()
{
    testvector5();

    return 0;
}

输出：

testvector5 passed

1.6 析构函数

实现代码:

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

【注意】

  • 为了避免内存泄露的问题，上述代码全部都需要添加析构函数。

1.7 begin 与 end 迭代器

【解释】：

  • begin 函数返回指向 vector 起始位置的迭代器（即指向第一个元素）。
  • end 函数返回指向 vector 末尾的迭代器（即指向最后一个元素的下一个位置）。
  • 两者结合可以用于遍历 vector 中的元素。

添加代码:

iterator begin(){
	return _start;
}

iterator end(){
	return _finish;
}

2. 容量管理

2.1 reserve函数：实现动态扩容

  • 实现reserve函数，测试在容量不足时是否能正确扩展。

添加代码：

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

        if (_start) {
            for (size_ t i = 0; i < sz; i++) {
                tmp[i] = _start[i];
            }
            delete[] _start;
        }

        _start = tmp;
        _finish = _start + sz;
        _endofstorage = _start + n;
    }
}

【注意】：

  • T是自定义类型时，依次调用数组每个对象的析构函数，再释放整个空间

  • 原来for循坏中使用的是memcpy(tmp, _start, sizeof(T) * sz);但是vector是深拷贝，但是vector空间上存的对象是string数组，使用memcpy导致string对象的浅拷贝

  • 解决方案：T是string这样深拷贝的类，调用的是string赋值重载，实现的是string对象的深拷贝

测试用例：

void testvector6() {
    xny::vector<int> v(5, 10);
    v.reserve(10);  // 预留容量
    assert(v.capacity() == 10);  // 验证容量扩展
    for (size_t i = 0; i < 5; ++i) {
        assert(v[i] == 10);  // 验证数据保持不变
    }
    std::cout << "testvector6 passed" << std::endl;
}

int main()
{
    testvector6();

    return 0;
}

输出：

testvector6 passed

2.2 resize函数：改变大小

  • 实现resize函数，测试增加或减少vector大小，如果增加，用特定字符暂时覆盖。

添加代码：

void resize(size_t n, const T& val = T()) {
    if (n < size()) {
        _finish = _start + n;
    }
    else {
        // 扩容n
        reserve(n);

        // 传值
        while (_finish != _start + n) {
            *_finish = val;
            ++_finish;
        }
    }
}

测试用例：

void testvector7() {
    xny::vector<int> v(5, 10);
    v.resize(8, 20);  // 扩展大小并填充新值
    assert(v.size() == 8);  // 验证扩展后大小
    for (size_t i = 0; i < 5; ++i) {
        assert(v[i] == 10);  // 验证原值不变
    }
    for (size_t i = 5; i < 8; ++i) {
        assert(v[i] == 20);  // 验证新值
    }
    std::cout << "testvector7 passed" << std::endl;
}

int main()
{
    testvector7();

    return 0;
}

输出：

testvector7 passed

3. 元素插入与删除

3.1 push_back函数：尾插元素

【实现步骤】：

    1. 检查容量是否足够，若不足则扩容（通常容量加倍）。
    1. 将新元素插入到当前末尾。
    1. 更新_finish指针，指向新的末尾。

添加代码：

void push_back(const T& val){
    if (_finish == _endofstorage) {
        size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;  // 采用2倍扩容
        reserve(newcapacity);
    }

    *_finish = val;
    ++_finish;
}

优化版本：

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

测试用例：

void testvector8() {
    xny::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);

    assert(v.size() == 3);  // 验证插入后的大小
    assert(v.capacity() >= 3);  // 验证容量是否自动扩展
    assert(v[0] == 1 && v[1] == 2 && v[2] == 3);  // 验证插入的元素是否正确

    std::cout << "testvector9 passed" << std::endl;
}

int main()
{
    testvector8();

    return 0;
}

输出：

testvector8 passed

3.2 pop_back函数：尾删元素

【实现步骤】：

    1. 将_finish指针向前移动一位，即删除最后一个元素。
    1. 不释放空间。

添加代码：

void pop_back(const T& val) {
    assert(_finish != _start);  // 确保vector非空
    --_finish;  // 逻辑删除最后一个元素
}

优化版本：

void pop_back(){
	erase(--end());
}

测试用例：

void testvector9() {
    xny::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.pop_back();

    assert(v.size() == 2);  // 验证删除后的大小
    assert(v[0] == 1 && v[1] == 2);  // 验证剩余元素是否正确

    std::cout << "testvector9 passed" << std::endl;
}

int main()
{
    testvector9();

    return 0;
}

输出：

testvector9 passed

3.3 insert函数：在指定位置插入元素

【实现步骤】：

    1. 检查容量是否足够，不足时扩容。
    1. 将插入位置及其后的元素整体向后移动。
    1. 将新元素插入指定位置。
    1. 更新_finish指针。

添加代码：

iterator insert(iterator pos, const T& val) {
    // 断言判断pos的有效性
    assert(pos >= _start && pos <= _finish);

    if (_finish == _endofstorage) {
        // 用临时变量存指定位置到起点的长度
        size_t len = pos - _start;
        size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;  // 采用2倍扩容
        reverse(newcapacity);

        // 解决pos迭代器失效问题
        pos = len + _start;
    }

    // 将插入位置及其后的元素整体向后移动。
    iterator end = _finish - 1;
    while (end >= pos) {
        *(end + 1) = *end;
        --end;
    }

    *pos = val;
    ++_finish;

    return pos;
}

测试用例：

void testvector10() {
    xny::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);

    v.insert(v.begin() + 2, 3);  // 在第2个位置插入3

    assert(v.size() == 4);  // 验证插入后的大小
    assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4);  // 验证插入的元素是否正确

    std::cout << "testvector8 passed" << std::endl;
}

int main()
{
    testvector10();

    return 0;
}

输出：

testvector10 passed

【问题】：

  • 扩容之后，pos迭代器可能会发生改变，所以不能用原来的pos。

3.4 erase函数：删除指定位置的元素

【实现步骤】：

    1. 将erase位置之后的元素向前移动一位。
    1. 更新_finish指针。

添加代码：

iterator erase(iterator pos) {
    // 断言判断pos的有效性
    assert(pos >= _start && pos <= _finish);

    iterator it = pos + 1;
    while (it != _finish) {
        *(it - 1) = *it;
        ++it;
    }
    --_finish;

    return pos;
}

测试用例：

void testvector11() {
    xny::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);

    v.erase(v.begin() + 2);  // 删除第2个元素

    assert(v.size() == 3);  // 验证删除后的大小
    assert(v[0] == 1 && v[1] == 2 && v[2] == 4);  // 验证删除后的元素顺序

    std::cout << "testvector11 passed" << std::endl;
}

int main()
{
    testvector11();

    return 0;
}

输出：

testvector11 passed

4.全部代码实现

【注意】：

  • 以下代码会提供常量和普通变量的两种函数或者迭代器。

4.1 头文件

#pragma once

#include<assert.h>
using namespace std;

namespace xny
{
	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(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			resize(n, val);
		}

		// 解决vector<int> v(10, 1)
		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			resize(n, val);
		}

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)	// 迭代器区间左闭右开
			{
				push_back(*first);
				++first;
			}
		}

		vector()
		{}

		vector(const vector<T>& v)
		{
			size_t sz = v.size();
			_start = new T[v.capacity()];
			// memcpy(_start, v._start, sizeof(T) * v.size());
			for (size_t i = 0; i < sz; i++)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + sz;
			_endofstorage = _start + v.capacity();
		}

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

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

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


		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}

				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + n;
			}
		}

		void resize(size_t n, const T& val = T())	// T类型的匿名对象
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);

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

		void push_back(const T& x)
		{
			/*if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			*_finish = x;
			++_finish;*/
			insert(end(), x);
		}

		void pop_back()
		{
			erase(--end());
		}

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

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

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

			return _start[pos];
		}

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

			return _start[pos];
		}

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

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;

				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);

				// 解决pos迭代器失效问题
				pos = _start + len;
			}

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

			*pos = x;
			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);

			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;

			return pos;
		}

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

	void print(const vector<int>& v)
	{
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

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

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

		for (size_t i = 0; i < v1.size(); i++)
		{
			v1[i]++;
		}

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

		print(v1);
	}

	void test_vector2()
	{
		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(5);
		v1.push_back(5);
		v1.push_back(5);

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

		v1.insert(v1.begin(), 100);

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

		/*vector<int>::iterator p = v1.begin() + 3;
		v1.insert(p, 300);*/

		xny::vector<int>::iterator p = v1.begin() + 3;
		//v1.insert(p+3, 300);

		// insert以后迭代器可能会失效(扩容)
		// 记住，insert以后就不要使用这个形参迭代器了，因为他可能失效了
		v1.insert(p, 300);

		// 高危行为
		// *p += 10;

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

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

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

		// v1.erase(v1.begin());

		auto it = v1.begin() + 4;
		v1.erase(it);

		// erase之后，迭代器失效了，不能访问
		// vs进行强制检查，访问会直接报错
		cout << *it << endl;
		++it;
		cout << *it << endl;

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

	void test_vector4()
	{
		vector<int> v;
		v.resize(10, 0);

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << 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);

		vector<int> v2(v1);

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

		vector<int> v3 = v1;
		for (auto e : v3)
		{
			cout << e << " ";
		}
		cout << endl;
	};

	void test_vector6()
	{
		vector<string> v;
		v.push_back("11111");
		v.push_back("22222");
		v.push_back("33333");
		v.push_back("44444");
		v.push_back("55555");

		// 自定义类型最好加引用
		for (auto& e : v)
		{
			cout << e << " ";
		}
		cout << endl;

		vector<string> v1(v);
		for (auto& e : v1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_vector7()
	{
		vector<int> v(10u, 1);
		vector<string> v1(10, "111");

		// vector<int> v2(10, 1);

	}
}

4.2 源文件

#include"vector.h"
#include <bits/stdc++.h>
using namespace std;

int main()
{
	xny::test_vector7();
	// ...其他测试
    
	return 0;
}

标签：finish,v1,STL,代码,back,start,vector,size
From： https://blog.csdn.net/suye050331/article/details/142579458

相关文章

  • 不用写一行Python代码，“Excel” 能直接爬虫了!
    家人们，要爬虫——现在用一个电子表格就行了。一行代码也别写，第三方软件也甭安。只需在表格里点几下就ok。不信，你瞧：就这么两下，网页上的商品信息都有了。网友看完都惊呆了，码个不停。一看到这是来自谷歌的产品（GoogleSheet，谷歌的“Excel”），大家就立马cue起了微软，问它慌......
  • 百度智能体搭建指南-不用一行代码，教你如何创建智能体！
    今天这篇文章，为大家介绍我制作的智能体怎么制作一个智能体我们直接打开“文心智能体平台”，选择“零代码”创建一个智能体。此时，我们可以为你的智能体命名，当然你需要给他一个设定，让智能体明白自己是干嘛的。一、步骤1:定义智能体的基本属性命名：选择一个有吸引力且符合主题的名字—......
  • 低代码革命：重塑工业互联网的未来版图
    在数字化转型的浪潮中，低代码应用正以前所未有的速度席卷各行各业，尤其是在工业互联网领域，它正悄然改变着企业的技术架构和业务模式。本文将深入探讨低代码应用如何成为工业互联网的技术趋势，并展望其未来的辉煌前景，揭示这场“低代码革命”如何重塑工业互联网的未来版图。低代码......
  • Gitlab分支管理规范和提交代码规范
    gitlab分支管理规范分支说明：测试代码库共有三个分支，main分支、dev分支、release分支--main分支：存放运行稳定的最新代码，一般不直接将未审核的代码合入到main分支--dev分支：存放个人开发的用例脚本，可用于用例故障修复，新的用例开发等--release分支：对应上线的产品版本，在发布......
  • 第二部分 项目结构、代码风格与标识符命名
    目录第5条使用得到公认且广泛使用的项目结构第6条提交前使用gofmt格式化源码第7条使用Go命名惯例对标识符进行命名第5条使用得到公认且广泛使用的项目结构第6条提交前使用gofmt格式化源码第7条使用Go命名惯例对标识符进行命名......
  • CS 168 Distance-Vector Routing
    CS168Fall2024Project 2:Distance-Vector RoutingInthis project,youwillwriteadistance-vectorroutingprotocol.We have provided simulatorcodethatyoucanusetovisualizeyour protocol in action.Lecturesneededforthisproject:Lecture6(Rou......
  • 如何利用Pycharm对远端已部署代码进行调式
    我们知道,java通过启动项jdwp开启一个监听端口,我们就可以idea去远程连接该端口,并对线上代码进行在线调式,那么pythonweb服务,比如一个已经部署的django应用我们是否也可以通过ide工具进行在线调式呢,当然是可以的.通过pycharm对远端已部署的django应用进行在线调式1,点击编辑器F......
  • JavaScript 网页设计经典案例代码全览
    一、响应式导航栏HTML结构：<nav><!--这是一个导航栏的容器--><divclass="logo">YourLogo</div><!--用于显示logo的div元素--><divclass="menu-icon">&#9776;</div><!--显示菜单图标（通常用于触发菜单的显示/隐藏）-->......
  • 【C++篇】从零实现 C++ Vector：深度剖析 STL 的核心机制与优化
    文章目录从零实现C++Vector前言1.基本结构与初始化细分1.1空构造函数的实现与测试实现代码：测试用例：输出：1.2带大小和默认值的构造函数实现代码：测试用例：输出：1.3拷贝构造函数实现代码：测试用例：输出：1.4赋值操作符的实现实现代码：测试用例：输出：2.容量管理的实现与测......
  • C++ 标准模板库（STL）之集合（set）
    啊，哈喽，小伙伴们大家好。我是#张亿，今天呐，学的n钱买n鸡是集合（set）C++标准模板库（STL）之集合（set）(下面代码中的std::要去掉)在C++标准模板库（STL）中，set 是一种非常有用的容器，用于存储唯一元素的集合。set 内部自动对元素进行排序，通常使用红黑树（Red-BlackTree）实现，以保证元素以升......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99