C++ Vector用法深入剖析

最新推荐文章于 2024-09-16 16:07:55 发布

蓝宇

最新推荐文章于 2024-09-16 16:07:55 发布

阅读量682

点赞数

文章标签： vector c++ iterator reference insert allocation

本文链接：https://blog.csdn.net/ll365594480/article/details/6405703

版权

C++编程语言中有一种叫做Vector的应用方法，它的作用在实际编程中是非常重要的。在这里我们将会为大家详细介绍一下C++ Vector的相关应用技巧及基本内容，希望能给大家带来一些帮助。

(1)vector< 类型 > 标识符 ;

(2)vector< 类型 > 标识符(最大容量) ；

(3)vector< 类型 > 标识符（最大容量，初始所有值）；

(4) int i[4] = {12,3,4,5};

1. vector< 类型 > vi(i , i+2); //得到i索引值为3以后的值；

(5)vector< vector<int> > //vi 定义2维的容器；记得一定要有空格，不然会报错

1. vector< int > line

2. // 在使用的时候一定要首先将vi个行进行初始化;

3. for(int i = 0 ; i < 10 ; i ++)

4. {

5. vector.push_back(line);

6. }

7. /// 个人认为使用vector定义二维数组很好，
因为是长度可以不预先确定。很好。

(6)C++ Vector排序

1. vector< int > vi ;

2. vi.push_back(1);

3. vi.push_back(3);

4. vi.push_back(0);

5. sort(vi.begin() , vi.end()); /// /小到大

6. reverse(vi.begin(),vi.end()) /// 从大道小

(7)顺序访问

1. vector < int > vi ;

2. for( int i = 0 ; i < 10 ; i ++)

3. {

4. vector.push_back(i);

5. }

6. for(int i = 0 ; i < 10 ; i ++) /// 第一种调用方法

7. {

8. cout <<vector[i] <<" " ;

9. }

10.for(vector<int>::iterator it = vi.begin() ;

11.it !=vi.end() ; it++) ///第二种调用方法

12.{

13.cout << *it << " " ;

14.}

(8)寻找

1. vector < int > vi ;

2. for( int i = 0 ; i < 10 ; i ++)

3. {

4. vector.push_back(i);

5. }

6. vector < int >::interator it = find(vi.begin() , vi.end,3) ;

7. cout << *it << endl ; ///返回容器内找到值的位置。

(9)使用数组对C++ Vector进行初始化

1. int i[10] ={1,2,3,4,5,6,7,78,8} ;

2. ///第一种

3. vector<int> vi(i+1,i+3); ///从第2个元素到第三个元素

4. for(vector <int>::interator it = vi.begin() ;

5. it != vi.end() ; it++)

6. {

7. cout << *it <<" " ;

8. }

(10) 结构体类型

1. struct temp

2. {

3. public :

4. string str ;

5. public :

6. int id ;

7. }tmp;

9. int main()

10.{

11.vector <temp> t ;

12.temp w1 ;

13.w1.str = "Hellowor" ;

14.w1.id = 1 ;

15.t.push_back(t1);

16.cout << w1.str << "," <<w1.id <<endl ;

17.return 0 ;

18.}

C++ Vector的基本介绍就为大家介绍到这里。

vector::push_back

public member function

void push_back ( const T& x );

Add element at the end

Adds a new element at the end of the vector, after its current last element. The content of this new element is initialized to a copy of x.

This effectively increases the vector size by one, which causes a reallocation of the internal allocated storage if the vector size was equal to the vector capacity before the call. Reallocations invalidate all previously obtained iterators, references and pointers.

Parameters

Value to be copied to the new element.
T is the first template parameter (the type of the elements stored in the vector).

Return value

none

If a reallocation happens, it is performed using Allocator::allocate(), which may throw exceptions (for the default allocator, bad_alloc is thrown if the allocation request does not succeed).

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// vector::push_back

#include <iostream>

#include <vector>

using namespace std;

int main ()

{

vector<int> myvector;

int myint;

cout << "Please enter some integers (enter 0 to end):/n";

do {

cin >> myint;

myvector.push_back (myint);

} while (myint);

cout << "myvector stores " << (int) myvector.size() << " numbers./n";

return 0;

}

The example uses push_back to add a new element to the vector each time a new integer is read.

Complexity

Constant (amortized time, reallocation may happen).

See also

vector::pop_back		Delete last element (public member function)
vector::insert	Insert elements (public member function)

file:///D|/Users/YangPing/Desktop/C++_Vector用法深入剖析.txt[2011/3/10 17:14:52]

C++编程语言中有一种叫做Vector的应用方法，它的作用在实际编程中是非常重要的。在这里我们将会为大家

详细介绍一下C++ Vector的相关应用技巧及基本内容，希望能给大家带来一些帮助。

(1)vector< 类型 > 标识符 ;

(2)vector< 类型 > 标识符(最大容量) ；

(3)vector< 类型 > 标识符（最大容量，初始所有值）；

(4) int i[4] = {12,3,4,5};

vector< 类型 > vi(i , i+2); //得到i索引值为3以后的值；

(5)vector< vector<int> > //vi 定义2维的容器,记得一定要有空格，不然会报错

vector< int > line // 在使用的时候一定要首先将vi个行进行初始化; for(int i = 0 ; i < 10 ; i

++) { vector.push_back(line); } /// 个人认为使用vector定义二维数组很好，因为是长度可以不预先

确定。很好。 (6)C++ Vector排序

vector< int > vi ; vi.push_back(1); vi.push_back(3); vi.push_back(0); sort(vi.begin() ,

vi.end()); /// /小到大 reverse(vi.begin(),vi.end()) /// 从大道小 (7)顺序访问

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

0 ; i < 10 ; i ++) /// 第一种调用方法 { cout <<vector[i] <<" " ; }

for(vector<int>::iterator it = vi.begin() ; it !=vi.end() ; it++) ///第二种调用方法 { cout <<

*it << " " ; } (8)寻找

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

>::interator it = find(vi.begin() , vi.end,3) ; cout << *it << endl ; ///返回容器内找到值的位

置。 (9)使用数组对C++ Vector进行初始化

C++ vector 类学习笔记

作者： tyc611, 2007-01-15
发表于: http://blog.chinaunix.net/u/18517/showart_232126.html

vector容器类型

vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。

vector的构造

函数原型：

template<typename T>
   explicit vector();                                 // 默认构造函数，vector对象为空
   explicit vector(size_type n, const T& v = T());    // 创建有n个元素的vector对象
   vector(const vector& x);
   vector(const_iterator first, const_iterator last);

注：vector容器内存放的所有对象都是经过初始化的。如果没有指定存储对象的初始值，那么对于内置类型将用0初始化，对于类类型将调用其默认构造函数进行初始化（如果有其它构造函数而没有默认构造函数，那么此时必须提供元素初始值才能放入容器中）。

举例：
vector<string> v1; // 创建空容器，其对象类型为string类
vector<string> v2(10); // 创建有10个具有初始值（即空串）的string类对象的容器
vector<string> v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器
vector<string> v4(v3.begin(), v3.end()); // v4是与v3相同的容器（完全复制）

vector的操作（下面的函数都是成员函数）

bool empty() const;                    // 如果为容器为空，返回true；否则返回false
size_type max_size() const;            // 返回容器能容纳的最大元素个数
size_type size() const;                // 返回容器中元素个数
size_type capacity() const;            // 容器能够存储的元素个数，有：capacity() >= size()
void reserve(size_type n);             // 确保capacity() >= n
void resize(size_type n, T x = T());   // 确保返回后，有：size() == n；如果之前size()<n，那么用元素x的值补全。

reference front();                     // 返回容器中第一个元素的引用（容器必须非空）
const_reference front() const;
reference back();                      // 返回容器中最后一个元素的引用（容器必须非空）
const_reference back() const;

reference operator[](size_type pos);   // 返回下标为pos的元素的引用（下标从0开始；如果下标不正确，则属于未定义行为。
const_reference operator[](size_type pos) const;
reference at(size_type pos);           // 返回下标为pos的元素的引用；如果下标不正确，则抛出异常out_of_range
const_reference at(size_type pos) const;

void push_back(const T& x);            // 向容器末尾添加一个元素
void pop_back();                       // 弹出容器中最后一个元素（容器必须非空）

// 注：下面的插入和删除操作将发生元素的移动（为了保持连续存储的性质），所以之前的迭代器可能失效
iterator insert(iterator it, const T& x = T()); // 在插入点元素之前插入元素（或者说在插入点插入元素）
void insert(iterator it, size_type n, const T& x); // 注意迭代器可能不再有效（可能重新分配空间）
void insert(iterator it, const_iterator first, const_iterator last);

iterator erase(iterator it); // 删除指定元素，并返回删除元素后一个元素的位置（如果无元素，返回end()）
iterator erase(iterator first, iterator last); // 注意：删除元素后，删除点之后的元素对应的迭代器不再有效。

void clear() const; // 清空容器，相当于调用erase( begin(), end())

void assign(size_type n, const T& x = T()); // 赋值，用指定元素序列替换容器内所有元素
void assign(const_iterator first, const_iterator last);

const_iterator begin() const; // 迭代序列
iterator begin();
const_iterator end() const;
iterator end();

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
const_reverse_iterator rend() const;
reverse_iterator rend();

vector对象的比较（非成员函数）

针对vector对象的比较有六个比较运算符：operator==、operator!=、operator<、operator<=、operator>、operator>=。

其中，对于operator==和operator!=，如果vector对象拥有相同的元素个数，并且对应位置的元素全部相等，则两个vector对象相等；否则不等。

对于operator<、operator<=、operator>、operator>=，采用字典排序策略比较。

注：其实只需要实现operator==和operator!=就可以了，其它可以根据这两个实现。因为，operator!= (lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs < lhs)，operator>(lhs, rhs) 就是 (rhs < lhs)，operator>=（lhs, rhs) 就是 !(lhs, rhs)。

vector类的迭代器

vector类的迭代器除了支持通用的前缀自增运算符外，还支持算术运算：it + n、it - n、it2 - it1。注意it2 - it1返回值为difference_type（signed类型）。

注意，任何改变容器大小的操作都可能造成以前的迭代器失效。

应用示例

#include <iostream>
#include <cassert>
#include <vector>

using namespace std;

int main()
{
    vector<string> v(5, "hello");
    vector<string> v2(v.begin(), v.end());

    assert(v == v2);

    cout<<"> Before operation"<<endl;
    for(vector<string>::const_iterator it = v.begin(); it < v.end(); ++it)
        cout<<*it<<endl;

    v.insert(v.begin() + 3, 4, "hello, world");
    cout<<"> After insert"<<endl;
    for(vector<string>::size_type i = 0; i < v.size(); ++i)
        cout<<v[i]<<endl;

    vector<string>::iterator it = v.erase(v.begin() + 3, v.begin() + 6);
    assert(*it == "hello, world");
    cout<<"> After erase"<<endl;
    for(vector<string>::size_type i = 0; i != v.size(); ++i)
        cout<<v[i]<<endl;

    assert(v.begin() + v.size() == v.end());
    assert(v.end() - v.size() == v.begin());
    assert(v.begin() - v.end() == -vector<string>::difference_type(v.size()));

    return 0;
}

程序说明：上面程序中用了三个循环输出容器中的元素，每个循环的遍历方式是不一样的。特别需要说明的是，第二个循环在条件判断中使用了size() 函数，而不是在循环之前先保存在变量中再使用。之所以这样做，有两个原因：其一，如果将来在修改程序时，在循环中修改了容器元素个数，这个循环仍然能很好地工作，而如果先保存size()函数值就不正确了；其二，由于这些小函数（其实现只需要一条返回语句）基本上都被声明为inline，所以不需要考虑效率问题。