1、基本函数实现

1.push_back     在数组的最后添加一个数据
2.pop_back         去掉数组的最后一个数据
3.at             得到编号位置的数据
4.begin         得到数组头的指针
5.end             得到数组的最后一个单元+1的指针
6.front         得到数组头的引用
7.back             得到数组的最后一个单元的引用
8.max_size         得到vector最大可以是多大
9.capacity         当前vector分配的大小
10.size         当前使用数据的大小
11.resize         改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
12.reserve         改变当前vecotr所分配空间的大小
13.erase         删除指针指向的数据项
14.clear         清空当前的vector
15.rbegin         将vector反转后的开始指针返回(其实就是原来的end-1)
16.rend         将vector反转构的结束指针返回(其实就是原来的begin-1)
17.empty         判断vector是否为空
18.swap         与另一个vector交换数据

1.构造函数

vector():创建一个空vector
vector(int nSize):创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

2.增加函数

void push_back(const T& x):向量尾部增加一个元素X
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.删除函数

iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素

4.遍历函数

reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

5.判断函数

bool empty() const:判断向量是否为空，若为空，则向量中无元素

6.大小函数

int size() const:返回向量中元素的个数
int capacity() const:返回当前向量张红所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值

7.其他函数

void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中第n个元素的值为x
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

2、使用

Vector<类型>标识符
Vector<类型>标识符(最大容量)
Vector<类型>标识符(最大容量,初始所有值)
Int i[5]={1,2,3,4,5}
Vector<类型>vi(I,i+2);//得到i索引值为3以后的值
Vector< vector< int> >v; 二维向量//这里最外的<>要有空格。否则在比较旧的编译器下无法通过

2.1插入删除

#include <string.h>
#include <vector>
#include <iostream>
using namespace std;

int main()
{
    vector<int>obj;//创建一个向量存储容器 int
    for(int i=0;i<10;i++) // push_back(elem)在数组最后添加数据 
    {
        obj.push_back(i);
        cout<<obj[i]<<",";    
    }

    for(int i=0;i<5;i++)//去掉数组最后一个数据 
    {
        obj.pop_back();
    }

    cout<<"\n"<<endl;

    for(int i=0;i<obj.size();i++)//size()容器中实际数据个数 
    {
        cout<<obj[i]<<",";
    }

    return 0;
}

运行结果：
0,1,2,3,4,5,6,7,8,9,

0,1,2,3,4,

2.2清空clear()

#include <string.h>
#include <vector>
#include <iostream>
using namespace std;

int main()
{
    vector<int>obj;
    for(int i=0;i<10;i++)//push_back(elem)在数组最后添加数据 
    {
        obj.push_back(i);
        cout<<obj[i]<<",";          0,1,2,3,4,5,6,7,8,9,
    }

    obj.clear();//清除容器中所以数据
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<endl;         清空后无输出
    }

    return 0;
}

2.3排序sort()

1.注意 sort 需要头文件 #include <algorithm>
2.sort默认升序、如果想 sort 来降序，可重写 sort 
#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>            
using namespace std;

int main()
{
    vector<int>obj;

    obj.push_back(1);
    obj.push_back(3);
    obj.push_back(0);

    sort(obj.begin(),obj.end());//从小到大

    cout<<"从小到大:"<<endl;
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<",";  
    } 

    cout<<"\n"<<endl;

    cout<<"从大到小:"<<endl;
    reverse(obj.begin(),obj.end());//从大到小 
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<",";
    }
    return 0;
}

运行结果：
从小到大:
0,1,3,

从大到小:
3,1,0,

重写sort()
bool compare(int a,int b) 
{ 
    return a< b; //升序排列，如果改为return a>b，则为降序 
} 
int a[20]={2,4,1,23,5,76,0,43,24,65},i; 
for(i=0;i<20;i++) 
    cout<< a[i]<< endl; 
sort(a,a+20,compare);

2.4 访问（直接数组访问&迭代器访问）

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    //顺序访问
    vector<int>obj;
    for(int i=0;i<10;i++)
    {
        obj.push_back(i);   
    } 

    cout<<"直接利用数组："; 

    方法一，直接访问
    for(int i=0;i<10;i++)
    {
        cout<<obj[i]<<" ";
    }

    cout<<endl; 
    cout<<"利用迭代器：" ;


    方法二，使用迭代器将容器中数据输出 
    vector<int>::iterator it;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素 
    for(it=obj.begin();it!=obj.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}
运行结果：
直接利用数组：0 1 2 3 4 5 6 7 8 9 
利用迭代器：0 1 2 3 4 5 6 7 8 9

2.5 二维数组两种定义方法（结果一样）

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int N=5, M=6; 
    vector<vector<int> > obj(N); //定义二维动态数组大小5行 
    for(int i =0; i< obj.size(); i++)//动态二维数组为5行6列，值全为0 
    { 
        obj[i].resize(M); 
    } 

    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int N=5, M=6; 
    vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列 

    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

结果：
0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0

黑马学习笔记

vector基本概念：
vector数据结构和数组非常相似，也称单端数组
vector与普通数组区别：
数组是静态空间，而vector可以动态扩展
动态扩展：
并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
v.begin();指向容器的首位
v.end();指向容器末尾的下一位
push_back();
pop_back();
insert();
//v.rbegin();指向容器的首位(右向左，相当于最后一个)
//v.end();指向容器末尾的下一位（右向左，相当于第一个的前一位）
特点：vector容器的迭代器支持随机访问的迭代器

STL中最常用的容器：Vector,可以理解为数组
容器：Vector
算法：for_each
迭代器：vector<int>::iterator
//01 STL初识_STL_vector存放内置数据类型
#include<iostream>
using namespace std;
#include<vector>//声明迭代器
#include<algorithm>//标准算法头文件

void MyPrint(int val)
{
    cout << val << endl;
}
void test01()
{
    vector<int> v;//创建一个vector容器，数组
    //向数组中插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);

    //第一种遍历方式
    cout << "第一种遍历方式\n";
    //通过迭代器访问数组数据
    vector<int>::iterator itBegin = v.begin();    //起始迭代器、指向第一个元素(当作指针来用)
    vector<int>::iterator itEnd = v.end();        //结束迭代器 指向最后一位的下一位
    while (itBegin != itEnd)
    {
        cout << *itBegin<<endl;//itBegin 当作指针
        itBegin++;
    }

    //第二种遍历方式
    cout << "\n第二种遍历方式\n";
    for (vector<int>::iterator it= v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }

    //第三种遍历方式
    cout << "\n第三种遍历方式\nSTL中提供的遍历算法\n";
    //STL中提供的遍历算法（包含头文件：<algorithm>标准算法头文件）
    for_each(v.begin(), v.end(),MyPrint);
}

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

#include<iostream>
using namespace std;
#include<string>
#include<vector>

//自定义数据类型
class Person
{
public:
    Person(string name,int age)
    {
        m_name = name;
        m_age = age;
    }
    string m_name;
    int m_age;
};


void test01()
{
    //定义一个容器
    vector<Person>v;

    //
    Person P1("aaa", 10);
    Person P2("bbb", 20);
    Person P3("ccc", 30);
    Person P4("ddd", 40);
    Person P5("eee", 50);

    //向容器数组中插入数据
    v.push_back(P1);//尾插法
    //v.push_back(10);错误
    v.push_back(P2);
    v.push_back(P3);
    v.push_back(P4);
    v.push_back(P5);

    //遍历容器中的数据
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        //it可以当作指针使用
        cout << "姓名：" << (*it).m_name << "年龄：" << (*it).m_age << endl;//解引用法
        cout << "姓名：" << it->m_name << "年龄：" << it->m_age << endl << endl;    //指针指向法
    }
}

void test02()
{
    vector<Person*> V;
    Person P1("aaa", 10);
    Person P2("bbb", 20);
    Person P3("ccc", 30);
    Person P4("ddd", 40);
    Person P5("eee", 50);

    //向容器数组中插入数据
    V.push_back(&P1);
    V.push_back(&P2);
    V.push_back(&P3);
    V.push_back(&P4);
    V.push_back(&P5);

    //遍历容器中的数据
    for (vector<Person*>::iterator it = V.begin(); it != V.end(); it++)
    {
        //it是二级指针
        cout << "::姓名：" << (*it)->m_name << "年龄：" << (*it)->m_age << endl;
    }
}

int main()
{
    test01();
    test02();
    return 0;
}

#include<iostream>
using namespace std;
#include<string>
#include<vector>

//容器嵌套容器
void test01()
{
    vector< vector<int>>v;//大容器

    vector<int>v1;//小容器
    vector<int>v2;
    vector<int>v3;
    vector<int>v4;
    vector<int>v5;

    //给小容器初值
    for (int i = 0; i < 4; i++)
    {
        v1.push_back(i + 1);//1 2 3 4
        v2.push_back(i + 2);//2 3 4 5
        v3.push_back(i + 3);//3 4 5 6
        v4.push_back(i + 4);//4 5 6 7
        v5.push_back(i + 5);//5 6 7 8
    }

    //插入大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);
    v.push_back(v5);

    //利用大容器输出所有值
    for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    {
        //(*it)是一个小容器
        for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            //vit是整形指针
            cout << *vit << " ";
        }
        cout << endl;
    }

}

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

/*
    创建vector容器

函数原型：
    1、vector<T> v;                    采用模板实现类实现，默认构造函数
    2、vector(v.begin(),v.end());        将v[begin(),end()]区间中元素拷贝给自身
    3、vetor(n,elem);                    构造函数将n个elem拷贝给自身
    4、vector(const vector &vec);        拷贝构造函数
*/

#include<iostream>
#include<vector>
using namespace std;

void myPrint(vector<int> V)
{
    for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    //1、vector<T> v;采用模板实现类实现，默认构造函数
    vector<int> v1;//默认构造函数
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    myPrint(v1);

    //2、vector(v.begin(),v.end());将v[begin(),end()]区间中元素拷贝给自身
    vector<int> v2(v1.begin(),v1.end());//通过区间方式构造
    myPrint(v2);

    //3、vetor(n,elem);构造函数将n个elem拷贝给自身
    vector<int> v3(10, 100);//n个elem的方式构造(10个100)
    myPrint(v3);

    //4、vector(const vector &vec);拷贝构造函数
    vector<int> v4(v3);//拷贝构造函数
    myPrint(v4);

}

#include<iostream>
using namespace std;
#include<vector>

//vector赋值操作
/*
    1、vector& operator=(const vector &vec);        重载等号操作符
    2、assign(beg,end);                            将[beg,end]区间中的数据拷贝赋值给自己
    3、assign(n,elem);                                将n个elem拷贝赋值给自己
*/
void PrintVector(vector<int>& v)
{
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
        cout << *it << " " ;
    cout << endl;
}

int main()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i + 1);//1-10
    }
    PrintVector(v1);//1 2 3 4 5 6 7 8 9 10

    //1、vector & operator=(const vector & vec);        重载等号操作符
    vector<int> v2 = v1;//operator=
    PrintVector(v2);//1 2 3 4 5 6 7 8 9 10

    //2、assign(beg,end);    将[beg,end]区间中的数据拷贝赋值给自己
    vector<int> v3(v1.begin(),v1.end());
    PrintVector(v3);//1 2 3 4 5 6 7 8 9 10

    //3、assign(n,elem);    将n个elem拷贝赋值给自己
    vector<int> v4(3, 10);//3个10
    PrintVector(v4);//10 10 10
    return 0;
}

#include<iostream>
#include<vector>
using namespace std;

//vector_容器的容量和大小
/*
    函数原型：
    empty();            判断容器是否为空(空返回true)
    capacity();            容器的容量
    size();                元素个数
    resize(int num);    重新指定容器的长度为num,若容器变长，则以默认值0填充新位置
                        若变短，超出部分被删除
    resize(int num,elem);重新指定容器的长度为num,若容器变长，则以elem填充新位置
                        若变短，超出部分被删除

*/
void PrintVector(vector<int>& V)
{
    for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
        cout << *it << " ";
    cout << endl;
}

int main()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i + 1);
    }
    cout << v1.empty() << endl;//0(v1不为空)

    vector<int>v2;
    cout << v2.empty() << endl;//1(v2为空)

    if(!v1.empty())
    {
        cout << "容器不为空\n";
        PrintVector(v1);//1 2 3 4 5 6 7 8 9 10

        cout << "v1的容量" << v1.capacity() << endl;
        cout << "v1的大小" << v1.size() << endl;
    }

    v1.resize(15);
    //resize(int num);    重新指定容器的长度为num,若容器变长，则以默认值填充新位置
    //                    若变短，超出部分被删除
    PrintVector(v1);//1 2 3 4 5 6 7 8 9 10 0 0 0 0 0
    v1.resize(5);//变短
    PrintVector(v1);//1 2 3 4 5

    v1.resize(15,1);
    //resize(int num,elem);重新指定容器的长度为num,若容器变长，则以elem填充新位置
    //                        若变短，超出部分被删除
    PrintVector(v1);//1 2 3 4 5 1 1 1 1 1 1 1 1 1 1
    return 0;
}

#include<iostream>
#include<vector>
using namespace std;

//对vector插入和删除
/*
    push_back(ele);                尾插
    pop_back();                    删除最后一个元素
    insert(const_iterator pos,ele);                        迭代器指向位置pos插入元素ele
    insert(const_iterator pos,int count,ele);            迭代器指向位置pos插入count个元素ele
    erase(const_iterator pos);                            删除迭代器指向的元素
    erase(const_iterator start,const_iterator end);        删除迭代器从start到end之间的元素
    clear();                    删除所有元素
*/
void PrintVector(vector<int>& V)
{
    for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
        cout << *it << " ";
    cout << endl;
}

int main()
{
    vector<int> v1;
    v1.push_back(10);//尾插
    v1.push_back(20);
    v1.push_back(30);
    PrintVector(v1);//10 20 30

    v1.pop_back();//尾删
    PrintVector(v1);//10 20

    //insert(const_iterator pos, ele);                        迭代器指向位置pos插入元素ele
    v1.insert(v1.begin(), 100);//在v1.begin()处插入100
    PrintVector(v1);//100 10 20

    //insert(const_iterator pos, int count, ele);            迭代器指向位置pos插入count个元素ele
    v1.insert(v1.begin()+1, 3, 1000);//在v1.begin()+1处插入3个1000    //第一个参数是迭代器
    PrintVector(v1);//100 1000 1000 1000 10 20

    //erase(const_iterator pos);                            删除迭代器指向的元素
    v1.erase(v1.begin());//删除v1.begin()处数据    //参数是迭代器
    PrintVector(v1);//1000 1000 1000 10 20

    //erase(const_iterator start, const_iterator end);        删除迭代器从start到end之间的元素
    v1.erase(v1.begin(),v1.begin()+2);//删除v1.begin()到begin()+2处数据
    PrintVector(v1);//1000 10 20

    //clear();    删除所有元素
    v1.clear();
    if (v1.empty())
        cout << "v1为空\n";
    return 0;
}

#include<iostream>
using namespace std;
#include<vector>

//vector数据存取
/*
函数原型：
    1、operator[];        返回索引idx所指的数据
    2、at(int idx);        返回索引idx所指的数据
    3、front();            返回容器中的第一个数据元素
    4、back();            返回容器中的最后一个数据元素
*/

int main()
{
    vector<int> v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i + 1);
    }

    //1、operator[];    返回索引idx所指的数据
    for (int i = 0; i < v1.size(); i++)
        cout << v1[i] << " ";//通过[]遍历
    cout << endl;

    //2、at(int idx);    返回索引idx所指的数据
    for (int i = 0; i < v1.size(); i++)
        cout << v1.at(i) << " ";//通过at函数
    cout << endl;

    //3、front();    返回容器中的第一个数据元素
    cout << "vector的第一个数据元素: " << v1.front() << endl;//vector的第一个数据元素: 1

    //4、back();    返回容器中的最后一个数据元素
    cout << "vector的最后一个数据元素: " << v1.back() << endl;//vector的最后一个数据元素: 10

    return 0;
}

#include<iostream>
using namespace std;
#include<vector>
//容器互换
/*
实现两个容器内元素进行互换
    swap(vec);//将vec与本身的元素进行互换
*/
void PrintVector(vector<int> V)
{
    for (int i = 0; i < V.size(); i++)
        cout << V[i] << " ";
    cout << endl;

    /*
    for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
        cout << *it << " ";
    cout << endl;
    */
}
void test01()//1、交换基本语法概念
{
    vector<int>V1;
    for (int i = 0; i < 10; i++)
        V1.push_back(++i);
    cout << "V1:";
    PrintVector(V1);

    vector<int>V2;
    for (int i = 0; i < 10; i++)
        V2.push_back(i);
    cout << "V2:";
    PrintVector(V2);

    //swap(vec);//将vec与本身的元素进行互换
    V1.swap(V2);
    cout << "交换后\n";
    cout << "V1:";
    PrintVector(V1);
    cout << "V2:";
    PrintVector(V2);
}

//实际用途
//巧用swap可以收缩内存空间
void test02()
{
    vector<int>v1;
    for (int i = 0; i < 10000; i++)
        v1.push_back(i + 1);
    cout << "v1的容量为：" << v1.capacity() << endl;//v1的容量为：12138
    cout << "v1的大小为：" << v1.size() << endl;//v1的大小为：10000

    v1.resize(3);
    cout << "v1的容量为：" << v1.capacity() << endl;//v1的容量为：12138
    cout << "v1的大小为：" << v1.size() << endl;//v1的大小为：3

    vector<int>(v1).swap(v1);//vector<int>(v1);匿名对象        //实现内存收缩.
    cout << "v1的容量为：" << v1.capacity() << endl;//v1的容量为：3
    cout << "v1的大小为：" << v1.size() << endl;//v1的大小为：3
}

int main()
{
    test01();
    test02();
    return 0;
}

#include<iostream>
using namespace std;
#include<vector>

//vector容器预留空间
    //减少vector在动态扩展容量的扩展次数
//函数原型
    //reserve(int len);容器预留len个元素长度，预留位置不初始化，元素不可访问

int main()
{
    vector<int> v1;

    //预留内存空间
    v1.reserve(1000000);
    int num = 0;
    int* p = NULL;
    for (int i = 0; i < 1000000; i++)
    {
        v1.push_back(i);
        if (p != &v1[0])
        {
            num++;
            p = &v1[0];
        }
    }
    cout << num << endl;//1（当数据比较大时，应先预留内存空间减少动态分配次数）

    num = 0;//初始化
    p = NULL;
    vector<int> v2;
    //未预留内存空间
    //v.reserve(1000000);
    for (int i = 0; i < 1000000; i++)
    {
        v2.push_back(i);
        if (p != &v2[0])
        {
            num++;
            p = &v2[0];
        }
    }
    cout << num << endl;//35
    return 0;
}