STL C++之序列式容器vector使用

vector

std::vector

向量是表示可以改变大小的数组的序列容器。

就像数组一样，向量对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问它们的元素，并且与在数组中一样有效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。

在内部，向量使用动态分配的数组来存储它们的元素。当插入新元素时，可能需要重新分配该数组以增加大小，这意味着分配一个新数组并将所有元素移至该数组。就处理时间而言，这是一项相对昂贵的任务，因此，向量不会在每次将元素添加到容器时重新分配。

相反，向量容器可能会分配一些额外的存储空间来适应可能的增长，因此容器的实际容量可能大于包含其元素所严格需要的存储空间（即其大小）。库可以实施不同的增长策略来平衡内存使用和重新分配，但无论如何，重新分配应该只发生在对数增长的大小间隔上，以便可以为向量末尾的单个元素插入提供摊销常数时间复杂性（参见 push_back）。

因此，与数组相比，向量消耗更多内存以换取管理存储和以有效方式动态增长的能力。

std::vector::push_back

void push_back (const value_type& val);
void push_back (value_type&& val);

在当前最后一个元素之后，在向量的末尾添加一个新元素。 val 的内容被复制（或移动）到新元素。

这有效地将容器大小增加了 1，当且仅当新向量大小超过当前向量容量时，这会导致分配的存储空间的自动重新分配。

// vector::push_back
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector;
    int myint;

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

    do {
        std::cin >> myint;
        myvector.push_back(myint);
    } while (myint);

    std::cout << "myvector stores " << int(myvector.size()) << " numbers.\n";

    return 0;
}

std::vector::pop_back

void pop_back();

删除向量中的最后一个元素，有效地将容器大小减小一。

// vector::pop_back
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector;
    int sum(0);
    myvector.push_back(100);
    myvector.push_back(200);
    myvector.push_back(300);

    while (!myvector.empty())
    {
        sum += myvector.back();
        myvector.pop_back();
    }

    std::cout << "The elements of myvector add up to " << sum << '\n';

    return 0;
}

输出结果

The elements of myvector add up to 600

std::vector::insert

single element (1)	iterator insert (const_iterator position, const value_type& val);
fill (2)	iterator insert (const_iterator position, size_type n, const value_type& val);
range (3)	template <class InputIterator>iterator insert (const_iterator position, InputIterator first, InputIterator last);
move (4)	iterator insert (const_iterator position, value_type&& val);
initializer list (5)	iterator insert (const_iterator position, initializer_list<value_type> il);

通过在指定位置的元素之前插入新元素来扩展向量，从而通过插入的元素数量有效地增加容器大小。

当且仅当新向量大小超过当前向量容量时，这将导致分配的存储空间的自动重新分配。

因为向量使用数组作为其底层存储，所以在向量末端以外的位置插入元素会导致容器将位置之后的所有元素重新定位到它们的新位置。 与其他类型的序列容器（例如 list 或 forward_list）为相同操作执行的操作相比，这通常是一种低效的操作。

// inserting into a vector
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector(3, 100);
    std::vector<int>::iterator it;

    it = myvector.begin();
    it = myvector.insert(it, 200);

    myvector.insert(it, 2, 300);

    // "it" no longer valid, get a new one:
    it = myvector.begin();

    std::vector<int> anothervector(2, 400);
    myvector.insert(it + 2, anothervector.begin(), anothervector.end());

    int myarray[] = { 501,502,503 };
    myvector.insert(myvector.begin(), myarray, myarray + 3);

    std::cout << "myvector contains:";
    for (it = myvector.begin(); it < myvector.end(); it++)
        std::cout << ' ' << *it;
    std::cout << '\n';

    return 0;
}

输出结果

myvector contains: 501 502 503 300 300 400 400 200 100 100 100

std::vector::size

size_type size() const noexcept;

返回向量中的元素数。

这是向量中保存的实际对象的数量，不一定等于它的存储容量。

// vector::size
#include <iostream>
#include <vector>

int main()
{
	std::vector<int> myints;
	std::cout << "0. size: " << myints.size() << '\n';

	for (int i = 0; i < 10; i++) myints.push_back(i);
	std::cout << "1. size: " << myints.size() << '\n';

	myints.insert(myints.end(), 10, 100);
	std::cout << "2. size: " << myints.size() << '\n';

	myints.pop_back();
	std::cout << "3. size: " << myints.size() << '\n';

	return 0;
}

输出结果

0. size: 0
1. size: 10
2. size: 20
3. size: 19

std::vector::capacity

size_type capacity() const noexcept;

返回当前为向量分配的存储空间大小，以元素表示。

这个容量不一定等于向量大小。 它可以相等或更大，额外的空间允许适应增长，而无需在每次插入时重新分配。

请注意，此容量不假设向量大小的限制。 当这个容量用完并且需要更多时，容器会自动扩展它（重新分配它的存储空间）。 向量大小的理论限制由成员 max_size 给出。

可以通过调用成员 vector::reserve 显式更改向量的容量。

// comparing size, capacity and max_size
#include <iostream>
#include <vector>

int main()
{
	std::vector<int> myvector;
	std::vector<int> othervector;

	// set some content in the vector:
	for (int i = 0; i < 100; i++) {
		myvector.push_back(i);
		std::cout << (int)myvector.capacity() << ' ';
	}

	std::cout << std::endl << std::endl;

	for (int i = 0; i < 100; i++) {
		othervector.push_back(i);
		std::cout << (int)othervector.size() << ' ';
	}

	return 0;
}

输出结果

1 2 3 4 6 6 9 9 9 13 13 13 13 19 19 19 19 19 19 28 28 28 28 28 28 28 28 28 42 42 42 42 42 42 42 42 42 42 42 42 42 42 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 94 141 141 141 141 141 141

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

可见，添加元素时，vector并不是每次均匀的给一份存储空间，而是当前插入元素后大于当前分配存储空间时，系统会多分配存储空间。

std::vector::resize

void resize (size_type n);void resize (size_type n, const value_type& val);

更改大小调整容器的大小，使其包含 n 个元素。

如果 n 小于当前容器大小，则内容将减少到它的前 n 个元素，删除超出的那些（并销毁它们）。

如果 n 大于当前容器大小，则通过在末尾插入所需数量的元素来扩展内容，以达到 n 的大小。 如果指定了 val，则将新元素初始化为 val 的副本，否则，将它们初始化为值。

如果 n 也大于当前容器容量，则会自动重新分配已分配的存储空间。

请注意，此函数通过插入或删除元素来更改容器的实际内容。

// resizing vector
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector;

    // set some initial content:
    for (int i = 1; i < 10; i++) myvector.push_back(i);

    myvector.resize(5);
    myvector.resize(8, 100);
    myvector.resize(12);

    std::cout << "myvector contains:";
    for (int i = 0; i < myvector.size(); i++)
        std::cout << ' ' << myvector[i];
    std::cout << '\n';

    return 0;
}