精华内容
下载资源
问答
  • 纯c语言的向量vector实现,实现c++中vector的一些基本的特性和操作,适用于一些只支持c语言的平台上使用vector数据结构,包含测试用例以及函数的使用范例
  • C++ STL VECTOR实现

    2018-06-25 15:56:15
    c++的STL的vector的一个实现。使用了c++11的大部分特性,包含vector的几乎所有功能。仅作学习之用。
  • Vector c++的简单实现

    2018-12-01 00:13:59
    简单的实现vector的功能,但有可能在扩容和缩容时降低效率
  • 《STL系列》之vector原理及实现
  • C++ 用vector实现

    2018-03-23 10:47:09
    C++ 用vector实现图,包括dijkstra算法,prim算法,以及拓扑排序等内容
  • VBA-Vector是一维数组的自定义实现,可以使编码过程更加舒适。 入门 下载,解压缩,然后将ClassVector.cls导入到您的VBA项目中。 初始化ClassVector新变量,并将标准数组(String,Variant,Double等)转换为此类...
  • c++ vector模拟实现代码

    2020-08-25 00:40:50
    vector是C++ STL中一个非常重要的容器,了解 vector 的底层实现原理,可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现,感兴趣的朋友跟随小编一起看看吧
  • Vector C++ 实现vector
  • 本文给大家介绍的是在C++中实现高效的vector四则运算的方法的相关资料,需要的朋友可以参考下
  • 这是自己用在不使用泛型的基础上,用c++实现的一个vector功能,经过10万测试考验,没问题可用,如果大家有更好的建议和意见,还请指出,有不对的地方也请指出,大家一起进步,学习,加油。
  • Vector

    千次阅读 多人点赞 2018-03-17 14:08:58
    Vector Vector非常类似ArrayList,都继承自AbstractList并且都实现了List接口,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator...

    Vector

            Vector非常类似ArrayList,都继承自AbstractList并且都实现了List接口,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

            Vector实现List接口,所以里面的元素是有序的。

     向Vector中加入的元素add()方法是有序的,后加入的排列在最后。

    我们也可以调用add(int index,E element)方法向指定位置加入元素。

    vector.elements()方法返回一个枚举类型,我们可以用来遍历整个vector。

    vector.iterator()方法返回一个迭代器,同样可以用来遍历整个vector

    vector.contains(E element)方法,如果vector中存在指定元素则返回true,否则false。

    vector.get(int index)方法,返回指定位置的元素,如果超过vector的capacity则报错。

    初始化vector时,默认不带参数的话,vector的初始capacity大小为10。当当前空间不足以加入新元素时,capacity会加倍,即从10变成20,40,80......

    当然我们也可以使用下面两种带参数的构造

    1.Vector vector=new Vector(int  capacity);指定初始化大小,不允许负数大小的初始化。如果初始化大小为0,则加入数据时大小变为1,然后每次扩充遵循加倍原则。

    2.Vector vector=new Vector(int capacity,int increasesize)指定初始化大小,并且以后每次容量不足时,大小每次增加increasesize。


    import java.util.Enumeration;
    import java.util.Iterator;
    import java.util.Vector;
    
    public class Test {
        public static void main(String[] args){
            Vector vector=new Vector(0);
            System.out.println("vector的初始大小: "+vector.capacity());
            vector.add("大家好"); //Appends the specified element to the end of this Vector.
            vector.add("111");  //add方法将新元素加到末尾
            vector.add("222");
            vector.add("你好");               //elements()返回这个向量内所有元素的枚举
            Enumeration e=vector.elements();//Returns an enumeration of the components of this vector.
            System.out.println(vector.capacity());
            while(e.hasMoreElements()){
                System.out.println(e.nextElement());
            }
            System.out.println("---------分界线----------------------");
            vector.add(2,"我在第三位"); //add(int index,E element)将新元素加入到指定位置
            Iterator iterator=vector.iterator(); //使用迭代器
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
            for(int i=0;i<100;i++) {
                vector.add(i);
                System.out.print(vector.capacity()+" ");
                if(i%10==0) System.out.println();
            }
            System.out.println(vector.capacity());
            System.out.println(vector.contains("你好"));
            System.out.println(vector.get(2));
        }
    }

    运行结果:

    vector的初始大小: 10
    10
    大家好
    111
    222
    你好
    ---------分界线----------------------
    大家好
    111
    我在第三位
    222
    你好
    10 
    10 10 10 10 20 20 20 20 20 20 
    20 20 20 20 40 40 40 40 40 40 
    40 40 40 40 40 40 40 40 40 40 
    40 40 40 40 80 80 80 80 80 80 
    80 80 80 80 80 80 80 80 80 80 
    80 80 80 80 80 80 80 80 80 80 
    80 80 80 80 80 80 80 80 80 80 
    80 80 80 80 160 160 160 160 160 160 
    160 160 160 160 160 160 160 160 160 160 
    160 160 160 160 160 160 160 160 160 160
    true
    我在第三位

    初始化大小为0

    vector的初始大小: 0
    capacity:1
    capacity:2
    capacity:4
    capacity:4
    大家好
    111
    222
    你好
    8 8 8 8 16 16 16 16 16 16 
    16 16 32 32 32 32 32 32 32 32 
    32 32 32 32 32 32 32 32 64 64 
    64 64 64 64 64 64 64 64 64 64 
    64 64 64 64 64 64 64 64 64 64 
    64 64 64 64 64 64 64 64 64 64 
    128 128 128 128 128 128 128 128 128 128 
    128 128 128 128 128 128 128 128 128 128 
    128 128 128 128 128 128 128 128 128 128 
    128 128 128 128 128 128 128 128 128 128 
    128
    true
    222


    展开全文
  • java中Vector实现

    千次阅读 2017-12-18 20:09:01
    Java的Vector底层实现

    本文介绍Vector容器在Java中的底层实现,首先看一下这个类的声明:

    public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    

    这个类继承了AbstractList<E>这个抽象类,这个抽象类实现了List<E>接口,实现了一些基本的方法,并且在add,remove,set方法中直接抛出了UnsupportedOperationException异常,这就意味着如果子类直接继承这个AbstractList然后不重写就直接使用这写方法就会抛出UnsupportedOperationException异常。


    这个类实现了List<E>接口,这个接口不用说了,约定了一些列表下面的方法。

    实现了RandomAccess接口,通常在对List进行遍历操作的时候我们最好判断这个List是不是实现了RandomAccess接口,如果实现了就尽量用for(int i = 0;i<size;i++)的形式来进行遍历,效率会高一点,否则就用Iterator迭代器来进行遍历,代码实现如下:

    if(list instanceof RandomAccess){
        for(int i = 0;i<size;i++){
            //遍历操作
        }
    }
    else{
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            //遍历操作
        }
    }


    实现了Cloneable接口,表示该对象是可以被克隆的,能够使用Object.clone()方法,如果没有实现这个接口就调用Object下的clone()方法就会抛出CloneNotSupportedException异常。克隆分为浅克隆和深克隆,浅克隆只拷贝基本数据类型而不拷贝引用指向的对象,而深克隆不仅拷贝对象本身,还拷贝对象包含的引用指向的对象。


    实现了java.io.Serializable表明这个类可以被序列化。


    这个类中的成员变量和构造函数如下

        protected Object[] elementData;//存放元素的数组 也就是vector底层是数组
        protected int elementCount;//记录存放的元素个数
        protected int capacityIncrement;//增长因子 和增长容量相关 下面会介绍
        private static final long serialVersionUID = -2767605614048989439L;//序列版本号
        public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
            this.capacityIncrement = capacityIncrement;
        }
    public Vector(int initialCapacity) {
            this(initialCapacity, 0);
        }
    public Vector() {
            this(10);
        }
    public Vector(Collection<? extends E> c) {
            elementData = c.toArray();
            elementCount = elementData.length;
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
        }
    从上面可以看出默认的初始容量是10,而默认加载因子是0。


    下面来看一下Vector下面的addElement()方法:

        public synchronized void addElement(E obj) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = obj;
        }
    可以看到实现方式为modCount加1,表示修改次数加了一次,这个字段的作用体现在了快速失败机制中,而所谓快速失败机制就是如果在迭代的过程中,这个Vector被修改了,就不冒险继续迭代,而是直接抛出ConcurrentModificationException异常结束。然后调用了一个ensureCapacityHelper(elementCount+1)以确保容量足够,最后将obj加入到存放元素的数组。整个方法是用synchronized关键字修饰的,所以是线程安全的。

    看看ensureCapacityHelper()方法发生了什么:

        private void ensureCapacityHelper(int minCapacity) {
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
    如果所需最小容量比当前存放的数组容量还要大,就调用grow()方法进行扩容,由于执行这个方法的时候已经是在synchronized方法内,所以这个ensureCapacityHelper()方法没有用synchronized关键字修饰。

    看看grow()方法:

        private void grow(int minCapacity) {
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    源码写得很清楚,如果capacityIncrement大于0,newCapacity为capacityIncrement+oldCapacity,否则直接等于oldCapacity的两倍。如果容量仍然不够,newCapacity直接等于所需最小容量。如果newCapacity这个时候比MAX_ARRAY_SIZE还大,也就是比Integer.MAX_VALUE-8还要大就通过hugeCapacity(minCapacity)方法返回一个合适的容量,作为newCapacity,最后使用Arrays.copyOf(elementData,newCapacity)方法来实现数组的扩容。

    hugeCapacity()方法如下:

        private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
        }
    可以看到当所需最小容量大于MAX_ARRAY_SIZE的时候就取Integer.MAX_VALUE,否则取MAX_ARRAY_SIZE也就是Integer.MAX_SIZE-8。


    看一下Vector中的removeElement(Object obj)方法:

        public synchronized boolean removeElement(Object obj) {
            modCount++;
            int i = indexOf(obj);
            if (i >= 0) {
                removeElementAt(i);
                return true;
            }
            return false;
        }
    通过indexOf(obj)方法查找obj的索引i,然后调用removeElementAt(i)进行删除。

    我们直接看removeElementAt(int i)方法:

        public synchronized void removeElementAt(int index) {
            modCount++;
            if (index >= elementCount) {
                throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                         elementCount);
            }
            else if (index < 0) {
                throw new ArrayIndexOutOfBoundsException(index);
            }
            int j = elementCount - index - 1;
            if (j > 0) {
                System.arraycopy(elementData, index + 1, elementData, index, j);
            }
            elementCount--;
            elementData[elementCount] = null; /* to let gc do its work */
        }
    删除就没有添加那么麻烦,只是判断一下索引的合法性,然后就使用System.arraycopy()方法进行删除了,注意这里有个小细节:elementData[elementCount] = null,如果没有这行代码会导致elementData[elementCount]这个元素虽然不会再被使用了,但是由于这个元素仍然被elementData这个数组维护着,所以导致这个元素无法被GC回收,当这种情况出现的次数太多,就有可能导致OOM。


    总结一下Vector这个容器:

    1、这是一个集合,底层是用数组实现的,不过是可变长的,默认初始容量是10,默认增长因子是0,如果想要加入新的元素而容量不足就需要进行扩容,如果增长因子大于0,就增长负载因子个数的容量,否则增长为原来容量的两倍,如果容量仍然不够,就直接增长为所需最小容量。频繁地扩容容易引起效率问题,所以最好在调用构造函数的时候指定一个合适的容量或者调用ensureCapacity()方法进行扩容到适当的容量。

    2、这个类是线程安全的,采用了快速失败机制,提供了增加、删除元素,更加方便快捷。

    3、线程安全不意味着对于这个容器的任何操作都是线程安全的,比如在进行迭代的时候,如果不增加一些代码保证其线程安全,其他线程是可以对这个容器做出修改的,这样也就会导致抛出ConcurrentModificationException异常。

    展开全文
  • 用c++开发语言,模拟是下std标准库中的Vector基本的功能,复习下Vector标准库的相关知识,特留下此笔记
  • Vector CCP协议实现源码,ASAM CCP 2.1 Specification,Reference Documentation for the CCP Driver
  • 自己动手实现vector

    千次阅读 2019-03-09 14:04:02
    有了实现string的基础,在加上一点点模板的知识,就可以自己动手实现一个vector了。下面是我实现的代码,比较简单。有点犯懒了,讲解以后再写吧! #ifndef MY_VECTOR_H #define MY_VECTOE_H #include&amp;lt;...

    有了实现string的基础,在加上一点点模板的知识,就可以自己动手实现一个vector了。下面是我实现的代码,比较简单。有点犯懒了,讲解以后再写吧!

    #ifndef MY_VECTOR_H
    #define MY_VECTOE_H
    #include<cassert>
    typedef unsigned int  size_t;
    template < class T>
    class Vector {
    public:
        typedef T * iterator;
        
        Vector();
        Vector(int size, T const& a);
        Vector(const Vector<T> & a);
        ~Vector();
        size_t size() const;
        size_t capacity() const;
        size_t max_capacity() const;
        void push_back(const T& val);
        void pop_back();
        T& operator[](int index);
        Vector<T>& operator=(const Vector<T>& a);
        bool empty() const;
        iterator begin() const;
        iterator end() const;
    private:
        size_t  _size;
        size_t  _capacity;
        T*      _buf;
        const size_t _max_capacity = 65536;
    };
    template<class T>
    Vector<T>::Vector()
    {   
        _size = 0;
        _buf = new T[1];
        _capacity = 1;
    }
    
    template<class T>
    Vector<T>::Vector(int s, const T& a)
    {   
        if (s > _max_capacity) {
            s = _max_capacity;
        }
        _size = s;
        _capacity = 1;
        while (_capacity < _size) {
            _capacity *= 2;
        }
        _buf = new T[_capacity];
        for (size_t i = 0; i < _size; i++) {
            _buf[i] = a;
        }
    }
    template<class T>
    Vector<T>::Vector(const Vector<T> & a)
    {
        _size = a._size;
        _capacity = a._capacity;
        _buf = new T[_capacity];
        for (size_t i = 0; i < _size; i++) {
            _buf[i] = a._buf[i];
        }
    }
    template<class T>
    Vector<T>::~Vector()
    {
        delete[] _buf;
    }
    
    template<class T>
    size_t Vector<T>::size() const
    {
        return _size;
    }
    
    template<class T>
    size_t Vector<T>::capacity() const
    {
        return _capacity;
    }
    template<class T>
    size_t Vector<T>::max_capacity() const
    {
        return _max_capacity;
    }
    template<class T>
    T& Vector<T>::operator[](int index)
    {
        assert(index >= 0 && index < _size);
        return _buf[index];
    }
    
    template<class T>
    void Vector<T>::push_back(const T& val)
    {
        if (_size < _capacity) {
            _buf[_size] = val;
            _size++;
            return ;
        } else if (_size == _max_capacity) {
            return ;
        }
        _capacity *= 2;
        if (_capacity >= _max_capacity) {
            _capacity = _max_capacity;
        }
        T * tmp = new T[_capacity];
        for (size_t i = 0; i < _size; i++) {
            tmp[i] = _buf[i];
        }
        tmp[_size] = val;
        _size++; 
        delete[] _buf;
        _buf = tmp; 
    }
    
    template<class T>
    void Vector<T>::pop_back()
    {
        assert(_size > 0);
        _size--;
    }
    template<class T>
    bool Vector<T>::empty() const
    {
        if (_size == 0) {
            return true;
        }
        return false;
    }
     // 迭代器的实现
    template<class T>
    typename Vector<T>::iterator Vector<T>::begin() const
    {
        return _buf;
    }
    template<class T>
    typename Vector<T>::iterator Vector<T>::end() const
    {
        return _buf + _size;
    }
    template<class T>
    Vector<T>& Vector<T>::operator=(const Vector<T> & a)
    {
        if (this == &a) {
            return *this ;
        }
        delete[] _buf;
        _size = a._size;
        _capacity = a._capacity;
        _buf = new T[_capacity];
        for (size_t i = 0; i < _size; i++) {
            _buf[i] = a._buf[i];
        }
        return *this;
    }
    #endif
    

    测试代码:

    #include <iostream>
    #include "myvector.h"
    #include<string>
    using namespace std;
    int main()
    {
        int c = 20;
        Vector<string> a;
        Vector<string> b;
        for (int i = 0 ; i < 3; i++) {
            a.push_back("hello");
        }
        b = a;
        for (Vector<string>::iterator it = b.begin(); it != b.end(); it++) {
            cout << *it << " " << endl;
        }
        return 0;
    }
    

    运行结果:

    $ ./a.out
    hello
    hello
    hello
    
    展开全文
  • C++ vector的使用总结及常用vector操作

    千次阅读 多人点赞 2019-09-07 00:48:48
    C++ vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分,使用时需包含头文件: #include <vector> 二、使用方式 C++ vector类有两种使用方式: 第一种:...

    一、介绍

    C++ vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分,使用时需包含头文件:

    #include <vector>

    二、使用方式

    C++ vector类有两种使用方式:

    第一种:STL方式

    vector< string > text;

    1.  我们向 vector 中插入元素,而不再是索引元素,以及向元素赋值,例如 push_back()操作,就是在 vector 的后面插入一个元素下面的 while 循环从标准输入读入一个字符串序列并每次将一个字符串插入到 vector 中  

    string word; 
    while ( cin >> word ) { 
    text.push_back( word ); 
    // ... 
    }

    虽然我们仍可以用下标操作符来迭代访问元素  

    cout << "words read are: \n"; 
     
    for ( int ix = 0; ix < text.size(); ++ix ) 
          cout << text[ ix ] << ' '; 
     
    cout << endl; 


    但是 更典型的做法是使用vector 操作集中的begin()和 end()所返回的迭代器 iterator  
    对 :

    cout << "words read are: \n"; 
     
    for ( vector<string>::iterator it = text.begin(); 
        it != text.end(); ++it ) 
               cout << *it<< ' '; 
     
    cout << endl 


    iterator 是标准库中的类,它具有指针的功能 

    *it; 
    对迭代器解引用,并访问其指向的实际对象  
    ++it;

    向前移动迭代器 it 使其指向下一个元素  

    2.  注意 不要混用这两种习惯用法, 例如,下面的定义  
    vector< int > ivec; 
    定义了一个空vector 再写这样的语句  
    ivec[ 0 ] = 1024; 
    就是错误的 ,因为 ivec 还没有第一个元素,我们只能索引 vector 中已经存在的元素 size()操作返回 vector 包含的元素的个数。

    3. 类似地 当我们用一个给定的大小定义一个vector 时,例如  :
    vector<int> ia( 10 ); 
    任何一个插入操作都将增加vector 的大小,而不是覆盖掉某个现有的元素,这看起来好像是很显然的,但是下面的错误在初学者中并不少见:

    const int size = 7; 
    int ia[ size ] = { 0, 1, 1, 2, 3, 5, 8 }; 
    vector< int > ivec( size ); 
    for ( int ix = 0; ix < size; ++ix ) 
        ivec.push_back( ia[ ix ]); 

    程序结束时ivec 包含 14 个元素, ia 的元素从第八个元素开始插入。

    第二种:类数组使用

    1. 定义一个已知长度的 vector :

    vector< int > ivec( 10 );  //类似数组定义int ia[10 ];

    可以通过ivec[索引号] 来访问元素

    使用 if ( ivec.empty() ) 判断是否是空,ivec.size()判断元素个数。

     

    2. vector的元素被初始化为与其类型相关的缺省值:算术和指针类型的缺省值是 0,对于class 类型,缺省值可通过调用这类的缺省构造函数获得,我们还可以为每个元素提供一个显式的初始值来完成初始化,例如  
    vector< int > ivec( 10, -1 ); 
    定义了 ivec 它包含十个int型的元素每个元素都被初始化为-1 

    对于内置数组我们可以显式地把数组的元素初始化为一组常量值,例如: 
    int ia[ 6 ] = { -2, -1, 0, 1, 2, 1024 };


    我们不能用同样的方法显式地初始化 vector ,但是可以将 vector 初始化为一个已有数组的全部或一部分,只需指定希望被用来初始化 vector 的数组的开始地址以及数组最末元的下一位置来实现,例如:  
    // 把 ia 的 6 个元素拷贝到 ivec 中 
    vector< int > ivec( ia, ia+6 );  


    被传递给ivec 的两个指针标记了用来初始化对象的值的范围,第二个指针总是指向要拷贝的末元素的下一位置,标记出来的元素范围也可以是数组的一个子集,例如 :

    // 拷贝 3 个元素 ia[2],ia[3], ia[4] 
    vector< int > ivec( &ia[ 2 ], &ia[ 5 ] );


    3. 与内置数组不同 vector 可以被另一个 vector 初始化或被赋给另一个 vector 例如  

    vector< string > svec; 
    void init_and_assign() 
    { 
        // 用另一个 vector 初始化一个 vector 
        vector< string > user_names( svec ); 
        // ... 
     
        // 把一个 vector 拷贝给另一个 vector 
        svec = user_names; 
    }

     三、vector使用总结:

    1. vector的初始化:

    可以有五种方式,举例说明如下:

    (1) vector<int> a(10); //定义了10个整型元素的向量(尖括号中为元素类型名,它可以是任何合法的数据类型),但没有给出初值,其值是不确定的。
    (2)vector<int>a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
    (3)vector<int>a(b); //用b向量来创建a向量,整体复制性赋值
    (4)vector<int>a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个(共3个)元素
    (5)intb[7]={1,2,3,4,5,9,8};vector<int> a(b,b+7); //从数组中获得初值

    2. vector对象的几个重要操作

    举例说明如下:

    (1)a.assign(b.begin(), b.begin()+3);//b为向量,将b的0~2个元素构成的向量赋给a
    (2)a.assign(4,2);//是a只含4个元素,且每个元素为2
    (3)a.back();//返回a的最后一个元素
    (4)a.front();//返回a的第一个元素
    (5)a[i]; //返回a的第i个元素,当且仅当a[i]存在2013-12-07
    (6)a.clear();//清空a中的元素
    (7)a.empty();//判断a是否为空,空则返回ture,不空则返回false
    (8)a.pop_back();//删除a向量的最后一个元素
    (9)a.erase(a.begin()+1,a.begin()+3);//删除a中第1个(从第0个算起)到第2个元素,也就是说删除的元素从a.begin()+1算起(包括它)一直到a.begin()+3(不包括它)
    (10)a.push_back(5);//在a的最后一个向量后插入一个元素,其值为5
    (11)a.insert(a.begin()+1,5);//在a的第1个元素(从第0个算起)的位置插入数值5,如a为1,2,3,4,插入元素后为1,5,2,3,4
    (12)a.insert(a.begin()+1,3,5);//在a的第1个元素(从第0个算起)的位置插入3个数,其值都为5
    (13)a.insert(a.begin()+1,b+3,b+6);//b为数组,在a的第1个元素(从第0个算起)的位置插入b的第3个元素到第5个元素(不包括b+6),如b为1,2,3,4,5,9,8,插入元素后为1,4,5,9,2,3,4,5,9,8
    (14)a.size();//返回a中元素的个数;
    (15)a.capacity();//返回a在内存中总共可以容纳的元素个数
    (16)a.rezize(10);//将a的现有元素个数调至10个,多则删,少则补,其值随机
    (17)a.rezize(10,2);//将a的现有元素个数调至10个,多则删,少则补,其值为2
    (18)a.reserve(100);//将a的容量(capacity)扩充至100,也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义,因为这将避免内存多次容量扩充操作(当a的容量不足时电脑会自动扩容,当然这必然降低性能) 
    (19)a.swap(b);//b为向量,将a中的元素和b中的元素进行整体性交换
    (20)a==b; //b为向量,向量的比较操作还有!=,>=,<=,>,<

    3. 顺序访问vector的几种方式

    举例说明如下:
    1、向向量a中添加元素

    vector<int> a;
    for(int i=0;i<10;i++)
    a.push_back(i);

    2、也可以从数组中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int> b;
    for(int i=1;i<=4;i++)
    b.push_back(a[i]);

    3、也可以从现有向量中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int> b;
    vector<int> c(a,a+4);
    for(vector<int>::iterator it=c.begin();it<c.end();it++)
    b.push_back(*it);

    4、也可以从文件中读取元素向向量中添加

    ifstream in("data.txt");
    vector<int> a;
    for(int i; in>>i)
    a.push_back(i);

    5、易犯错误

    vector<int> a;
    for(int i=0;i<10;i++)
    a[i]=i;
    //这种做法以及类似的做法都是错误的。下标只能用于获取已存在的元素,而现在的a[i]还是空的对象

    (2)从向量中读取元素
    1、通过下标方式读取

    int a[6]={1,2,3,4,5,6};
    vector<int> b(a,a+4);
    for(vector<int>::iterator it=b.begin();it!=b.end();it++)
    cout<<*it<<" ";

    四、几种重要的算法

    使用时需要包含头文件:
    #include<algorithm>
    (1)sort(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素进行从小到大排列
    (2)reverse(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素倒置,但不排列,如a中元素为1,3,2,4,倒置后为4,2,3,1
    (3)copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()(包括它)到a.end()(不包括它)的元素复制到b中,从b.begin()+1的位置(包括它)开始复制,覆盖掉原有元素
    (4)find(a.begin(),a.end(),10); //在a中的从a.begin()(包括它)到a.end()(不包括它)的元素中查找10,若存在返回其在向量中的位置


    五、其它使用举例:


    (1)把一个vector中元素追加到另外一个容器vector,示例程序如下:

    #include <vector>
    
    #include <iostream>
    
    template <typename type> void printvector(std::vector<type> const &v, std::ostream &os = std::cout)
    
    {
    
        for (typename std::vector<type>::size_type sz = 0; sz != v.size(); ++sz)
    
            os << v[sz] << " ";
    
        os << std::endl;
    
    }
    
    int main()
    
    {
    
        int a[5] = {1, 2, 3, 4, 5};
    
        std::vector<int> v1(a, a + 3), v2(a + 3, a + 5);
    
        printvector(v1); // 结果是1 2 3
    
        printvector(v2); // 结果是4 5
    
        v1.insert(v1.end(), v2.begin(), v2.end()); // 把v2加到v1末尾
    
        printvector(v1); // 结果是1 2 3 4 5
    
        return 0;
    
    }

     (2)类和结构体存vector入实例:由于vector只允许一个占位,所以才将struct塞进vector,以弥补vector的不足。

    #include "stdafx.h"
    #include <vector>
    #include <string>
    using namespace std;
    class AClass
    {
    public:
        int num;
        string name;
    };
    struct AStruct 
    {
        int num;
        string name;
    };
    void TestStruct()
    {
     //类的使用
        AClass Ac;
        vector<AClass> vc;
        Ac.num=10;
        Ac.name="name";
        vc.push_back(Ac);
        AClass d;  
        for (vector<AClass>::iterator it=vc.begin();it<vc.end();++it)  
        {  
            d=*it;  
            cout<<d.num<<endl; 
        } 
     //结构体的使用
        AStruct As;
        vector<AStruct> vs;
        As.num=10;
        As.name="name";
        vs.push_back(As);
        AStruct ds;  
        for (vector<AStruct>::iterator it=vs.begin();it<vs.end();++it)  
        {  
            ds=*it;  
            cout<<ds.num<<endl; 
        } 
    }
    void TestPoint()
    {
     //类的使用
        AClass *Ac=new AClass;
        vector<AClass *> vc;
        Ac->num=10;
        Ac->name="name";
        vc.push_back(Ac);
        AClass *d;  
        for (vector<AClass*>::iterator it=vc.begin();it<vc.end();++it)  
        {  
            d=*it;  
            cout<<d->num<<endl; 
        } 
    }
    int _tmain(int argc, _TCHAR* argv[])
    {
        TestStruct();
        TestPoint();
        int n;
        cin>>n;
        return 0;
    }

    (3)C++中将两个vector中的值整合到另一个vector中,vecB和vecA中有相同的struct个数,现在想将每个vecA中的每个a的值传给vecC中c1,每个vecB中的每个b的值传给vecC中c2,也就是将两个容器中的内容整合到新的容器C中

    struct A
    {
    int a;
    };
    vector<A> vecA;
    struct B
    {
    int b;
    };
    vector<B> vecB;
    struct C
    {
    int c1;
    int c2;
    };
    vector<C> vecC;
    容器C和A、B中元素类型不同,迭代器类型就不同,所以不能用容器算法,使用迭代器遍历赋值,合并代码如下:
    第一种方法:
    for(vecA::const_iterator itA = vecA.begin(), VecB::const_iterator itB = vecB.begin();
            itA != vecA.end() && itB != vecB.end(); itA++, itB++){
            C c;
            c.c1 = (*itA).a;
            c.c2 = (*itB).b;
            vecC.push_back(c);
    }

    第二种方法:

    void MergeVector(vector<A> &vectorA,vector<B> &vectorB,vector<C> &vectorC)
    {
    vector<A>::iterator pva;
    vector<B>::iterator pvb;
    vector<C>::iterator pvc;
    pva = vectorA.begin();
    pvb = vectorB.begin();
    pvc = vectorC.begin();
    while(pva!=vectorA.end())
    {
    *pvc->c1 = *pva->a;
    *pvc->c2 = *pvb->b;
    pva++;
    pvb++;
    pvc++;
    }
    }

    (4)建立两个int类型的向量vector,利用merge算法合并,再用sort算法对合并后算法排序

    #include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    vector<int> merge(vector<int> ,vector<int> );
    int main()
    {
    vector<int> v1;
    v1.push_back(4);
    v1.push_back(6);
    v1.push_back(2);
    vector<int> v2;
    v2.push_back(3);
    v2.push_back(1);
    v2.push_back(5);
    vector<int> v3=merge(v1,v2);
    sort(v3.begin(),v3.end());
    for(vector<int>::iterator it=v3.begin();it!=v3.end();++it){
    cout<<*it<<endl;
    }
    }
    vector<int> merge(vector<int> v1,vector<int> v2)
    {
    v1.insert(v1.end(),v2.begin(),v2.end());
    return v1;
    }

    转自:https://blog.csdn.net/fanyun_01/article/details/56842637

    展开全文
  • c++ vector的底层实现

    万次阅读 多人点赞 2019-08-16 17:03:57
    最近看面经,很多公司都很喜欢问c++vector底层是怎么实现的。记录一下,想大致写个子集vector估计会印象深刻一点吧! 简单来说就是,每个动态数组都分配有一定容量,当存储的数据达到容量的上限的时候,就重新分配...
  • Deep Learning using Linear Support Vector Machines的简单实现代码
  • STL中vector实现原理

    千次阅读 2018-10-09 09:01:14
    STL中vector实现原理 vector的数据安排以及操作方式,与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间,一旦配置了就不能改变;要换个大(或小)一点的房子,可以,一切琐细都得由...
  • 由Java实现的二维向量类,包含向量的所有基本运算。可以表示平面中的一个点或一个向量。
  • vector类 代码实现

    2013-08-04 16:19:26
    使用C++语言实现标准库容器vector类代码,虽然与标准库源码有点出入,但功能已经大部分实现
  • C++ vector STL实现详解

    千次阅读 2017-11-19 21:25:38
    vector变量gdb输出总结0.前言  早前使用gdb调试特别不习惯,1)没有具备图形界面IDE(比如Visual Studio)的强大功能:边打断点边代码跟进,退出断点保存,可以随时查看当前变量数据,对stl变量显示友好。2)gdb...
  • C++vector的使用总结及常用vector操作

    万次阅读 多人点赞 2018-07-12 22:10:22
    一、C++ vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分,使用时需包含头文件: #include &lt;vector&gt; 二、C++ vector类有两种使用方式: 第一种...
  • C++中标准模板库std::vector实现

    千次阅读 2018-07-25 21:59:03
    以下实现了C++标准模板库std::vector的部分实现,参考了 cplusplus. 关于C++中标准模板库std::vector的介绍和用法可以参考 https://blog.csdn.net/fengbingchun/article/details/51510916 实现代码vector.hpp内容...
  • STL之Vector实现原理

    千次阅读 2017-08-01 23:24:31
    Vector的基本知识  在C++中,我们使用信息隐藏技术和封装技术把数据隐藏在类内部不许外部直接操作,同时提供访问器(如get_xxx成员函数)和修改器(如set_xxx成员函数)。STL容器的设计原理如出一辙,只是它们在...
  • C++ vector的内部实现原理及基本用法

    千次阅读 2020-08-03 22:10:22
    本文基于STL vector源代码,但是不考虑分配器allocator,迭代器iterator,异常处理try/catch等内容,同时对_Ucopy()、 _Umove()、 _Ufill()函数也不会过度分析。 一、vector的定义 template<class _Ty, ...
  • STL中vector实现以及面试问题

    千次阅读 2018-03-22 11:22:35
    关于STL在《STL源码剖析》这本书中侯捷先生讲的很清楚,今天我就关于STL中的vector实现以及面试中的一些相关的问题做一个详细解释。在网上看人家的面试经验的时候,看到C++关于vector是作为基础知识经常被问到的,...
  • 自己在学习的过程中写的,拿出来现一下,其实我是想拿分。。。
  • vector是指能够存放任意类型的动态数组,而C语言中并没有面向对象的C++那样内置vector类,所以我们接下来就来看一下使用C语言实现vector动态数组的实例,需要的朋友可以参考下
  • Java集合,Vector底层实现和原理

    千次阅读 2018-02-27 19:44:00
    Vector作为List的另外一个典型实现类,完全支持List的全部功能,Vector类也封装了一个动态的,允许在分配的Object[]数组,Vector是一个比较古老的集合,JDK1.0就已经存在,建议尽量不要使用这个集合,Vector与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 447,402
精华内容 178,960
关键字:

vector是怎么实现的