vector

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量529 收藏 7
点赞数 8
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78524918/article/details/137382557
版权

vector

是一个按照顺序排列，且会自动调整大小的数组，其内置接口与用法讲解

1.vector的定义

ps: 包含头文件：include <vector>

1.1.声明定义（只使用常用型）

(constructor)构造函数声明

接口说明

vector()（重点）

无参构造

vector（size_type n, const value_type& val = value_type()）

构造并初始化n个val

vector (const vector& x); （重点）

拷贝构造

vector (InputIterator first, InputIterator last);

使用迭代器进行初始化构造

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v;
    vector<int> ret(10,1);
    vector<int> ren(ret);
}

1.2 vector iterator 的使用

也可以使用下标【】。

iterator的使用

接口说明

begin +

end（重点）

获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置

的iterator/const_iterator

rbegin + rend

获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

范围for

迭代器调用

1.3 vector 空间增长问题

容量空间

接口说明

size

获取数据个数

capacity

获取容量大小

empty

判断是否为空

resize（重点）

改变vector的size

reserve （重点）

改变vector的capacity

// 测试vector的默认扩容机制
void TestVectorExpand(){
  size_t sz;
  vector<int> v;
  sz = v.capacity(); 
  cout << "making v grow:\n"; 
  for (int i = 0; i < 100; ++i)  
  { 
    v.push_back(i); 
    if (sz != v.capacity()) 
     { 
       sz = v.capacity();
       cout << "capacity changed: " << sz << '\n';
     }
  }
}
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
1.4. vector 增删查改

vector增删查改

接口说明

push_back（重点）

尾插

pop_back （重点)

尾删

find

查找。（注意这个是算法模块实现，不是vector的成员接口）

insert

在position之前插入val

erase

删除position位置的数据

swap

交换两个vector的数据空间

operator[]（重点）

像数组一样访问

2.vector的使用 （浅代入）

杨辉三角

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
    vector<vector<int>> ret(numRows);
    for (int i = 0; i < numRows; i++)
    {
        ret[i].resize(i+1);
        ret[i][0]=ret[i][i] = 1;
        for (int j = 1; j <i; j++)
        {
                ret[i][j]=ret[i - 1][j]+ret[i-1][j-1];
        }
    }
    return ret;
  }
};

3.模拟实现

namespace bit
{
   template<class T>
   class vector
{
     public:
        typedef T* iterator;
    typedef const T* const_iterator;
        //迭代器
        iterator begin()
        iterator end()
        //构造
        vector()
        //迭代构造
        template <class InputIterator>
    vector(InputIterator first, InputIterator last)
        //。。。。
        vector<T>& operator=(vector<T> v)
        //析构
        ~vector()
        void swap(vector<T>& v)
        size_t size() const
        T& operator[](size_t pos)
        size_t capacity() const
        void reserve(size_t n)
        void resize(size_t n, const T& val = T())
        void insert(iterator pos, const T& val)
        iterator erase(iterator pos)
        private:
        iterator _start = nullptr;
        iterator _finish = nullptr;
        iterator _endofstorage = nullptr;
    };
 }

迭代器：

迭代器返回的需求是地址。

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()
{}

// v2(v1)
vector(const vector<T>& v)
{
    reserve(v.capacity());
    for (auto& e : v)
    {
        push_back(e);
    }
}
 //c++11

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

// 类模板的成员函数可以是函数模板
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);
        }
}
//对上函数不足的bug修补
vector(int n, const T& val = T())
{
    reserve(n);
    for (int i = 0; i < n; i++)
    {
        push_back(val);
    }
}
//赋值重载：将需拷贝变量的临时变量的空间值进行交互
vector<T>& operator=(vector<T> v)
{
    swap(v);
    return *this;
}
//析构函数：释放使用空间

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

函数接口：

//size:数组大小（长度）
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];
}
//数组空间大小（可容纳值）

size_t capacity() const
{
    return _endofstorage - _start;
}
//修改空间大小

void reserve(size_t n)
{
    if (n > capacity())
 {
    T* tmp = new T[n];
    size_t old_size = size();
    //memcpy(tmp, _start, size() * sizeof(T));
    for (size_t 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())
{
    if (n > size())
    {
            reserve(n);
            // 插入
        while (_finish < _start + n)
        {
            *_finish = val;
            ++_finish;
        }
    }
    else
    {
        // 删除
        _finish = _start + n;
    }
}
//尾插数据

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(pos >= _start);
    assert(pos <= _finish);

    if (_finish == _endofstorage)
    {
        size_t len = pos - _start;
        reserve(capacity() == 0 ? 4 : capacity() * 2);

        // 如果扩容了要更新pos
        pos = _start + len;
    }

    iterator it = _finish - 1;
    while (it >= pos)
    {
        *(it + 1) = *it;
        --it;
    }
    *pos = val;
    ++_finish;
}
指定删除
iterator erase(iterator pos)
{
    assert(pos >= _start);
    assert(pos < _finish);

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

    --_finish;

    return pos;
}

全代码加模拟测试：

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
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()
        {}

        // v2(v1)
        vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto& e : v)
            {
                push_back(e);
            }
        }

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

        // 类模板的成员函数可以是函数模板
        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);
            }
        }

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

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

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

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

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

        void reserve(size_t n)
        {
            if (n > capacity())
            {
                T* tmp = new T[n];
                size_t old_size = size();
                //memcpy(tmp, _start, size() * sizeof(T));
                for (size_t 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())
        {
            if (n > size())
            {
                reserve(n);
                // 插入
                while (_finish < _start + n)
                {
                    *_finish = val;
                    ++_finish;
                }
            }
            else
            {
                // 删除
                _finish = _start + n;
            }
        }

        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(pos >= _start);
            assert(pos <= _finish);

            if (_finish == _endofstorage)
            {
                size_t len = pos - _start;
                reserve(capacity() == 0 ? 4 : capacity() * 2);

                // 如果扩容了要更新pos
                pos = _start + len;
            }

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

        iterator erase(iterator pos)
        {
            assert(pos >= _start);
            assert(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;
    };

    //template<typename T>
    // 函数模板
    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 test_vector1()
    {
        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(4);
        print_vector(v1);

        vector<double> v2;
        v2.push_back(1.1);
        v2.push_back(2.2);
        v2.push_back(3.1);
        print_vector(v2);

        v2.insert(v2.begin(), 11.11);
        print_vector(v2);

        v2.insert(v2.begin(), 11.11);
        print_vector(v2);

        v2.insert(v2.begin(), 11.11);
        print_vector(v2);

        v2.insert(v2.begin(), 11.11);
        print_vector(v2);

        v2.insert(v2.begin(), 11.11);
        print_vector(v2);

        v2.erase(v2.begin());
        print_vector(v2);

        v2.erase(v2.begin() + 4);
        print_vector(v2);

        /*for (size_t i = 0; i < v.size(); i++)
        {
            cout << v[i] << " ";
        }
        cout << endl;

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

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

}

墨客 了
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
VectorCAST License安装手册.pdf
04-11
VectorCAST License安装手册.pdf
C++_vector操作
刘同学的博客
05-28 45万+
vector说明： vector是向量类型，可以容纳许多类型的数据，因此也被称为容器 (可以理解为动态数组，是封装好了的类） vector头文件-vector vector初始化： 方式1. vector<int>a(10);//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定 方式2. vector<int>a...
Vector
Dazhu233的博客
03-17 5177
Vector        Vector非常类似ArrayList，都继承自AbstractList并且都实现了List接口，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用I...
C++ vector
m0_61548909的博客
04-16 1万+
目录 1.vector的介绍及使用 1.1 vector的介绍 1.2 vector的使用 1.2.1 vector的定义 1.2.2vector itertor的使用 1.2.3 vector空间增长问题 1.2.3vector增删查改 1.2.4 vector 迭代器失效问题。（重点） 1.2.5 vector 在OJ中的使用。（见博客） 2.vector深度剖析及模拟实现 2.1使用memcpy拷贝问题 2.2 对bit::vector核心接口的测试 2.3 ...
c++ vector详解
m0_62870588的博客
03-24 12万+
vector的创建和初始化、vector的遍历、向vector添加元素、从vector移除元素、vector相等判断与赋值。
C++ vector容器详解
qq_52324409的博客
10-29 7万+
C++ vector容器详解目录vector容器的基本概念1.vector的构造函数2.vector的赋值操作3.vector的容量与大小4.vector的插入和删除5.vector数据存取6.vector互换容器7.vector预留空间写在最后 目录 vector容器的基本概念 功能：vector容器的功能和数组非常相似，使用时可以把它看成一个数组 vector和普通数组的区别： 1.数组是静态的，长度不可改变，而vector可以动态扩展，增加长度 2.数组内数据通常存储在栈上，而vector中数
C++ STL之vector详解
行码棋
01-04 5万+
本文介绍了STL的vector的常用操作以及相关的注意事项
C++ vector用法详解
wxy2020915的博客
09-08 9万+
C++ vector用法详解
c++ vector用法 入门必看 超详细
weixin_52115456的博客
07-29 6万+
vector容器名如储存int型的值vectorv;储存double型的值vectorv;储存string型的值vectorv;储存结构体或者类的值的值vectorv;当然也可以定义vector数组储存int型的值vectorv[n];储存double型的值vectorv[n];等等，n为数组的大小。...
C++ vector的用法（整理）
热门推荐
wkq0825的专栏
08-31 63万+
C++ vector的用法（整理） vector 是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件： #include&lt;vector&gt;; 一、vector 的初始化：可以有五种方式,举例说明如下： (1) vector&lt;int&gt; a(10); //定义了10个整型元素...
C++——vector
qwjy的博客
03-27 5551
  文章目录vector 构造vector 非更易型操作vector 赋值vector 元素访问vector 安插和移除元素        vector 包含在头文件< vector >中： #include <vector> 在此头文件内，类型 vector 是一个定义于 namespace std 内的 template： namespace std { template <typename T, typename Alloca
C语言头文件 VECTOR
06-13
C语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC语言头文件 VECTORC...
Vector Calculus
11-25
Vector Calculus Michael Corral Page：222 This book covers calculus in two and three variables. It is suitable for a one-semester course, normally known as “Vector Calculus”, “Multivariable Calculus...
Vector产品手册电子版
05-09
Vector产品手册电子版
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值