C++ STL 序列性容器之 std::vector 容器

vector，一種隨機訪問的數組類型，它提供了對數組元素的快速、隨機訪問，以及在序列尾部快速、隨機的插入和刪除操作。當然，它也支持在序列中的其他地方插入和刪除元素，但是這時效率會有所降低，這是因爲 vector 對象必須移動對象位置以容納新的元素或要收回被刪除元素的空間。此外，由於所有元素佔用連續空間，所以一旦進行插入或刪除動作，有可能使原本的某些 iterators 失效。

請看下面 vector 容器定義：

template<class T, class A = allocator<T> >    
class vector 
{
public:
    //定義內存分配器類型 A 的別名
	typedef A allocator_type;   
    
	//定義內存分配器 A 大小的別名, 可以代表容器的長度的類型, uint
	typedef A::size_type size_type;
    
	//代表兩個不同的元素之前地址差異的類型, int
	typedef A::difference_type difference_type;
    
	//T的引用類型
	typedef A::reference reference;
    
	//T的常量引用類型
	typedef A::const_reference const_reference;
    
	//對象類型T, 存儲在 vector 容器中
	typedef A::value_type value_type;    
	
	//定義訪問 vector 的迭代器類型
	typedef T0 iterator; 
    
	//定義訪問 vector 的常量迭代器類型
	typedef T1 const_iterator; 
	
	//定義訪問 vector 的反向迭代器類型
	typedef reverse_iterator<iterator, value_type, reference, A::pointer, difference_type> reverse_iterator;
    
	//定義訪問 vector 的常量反向迭代器類型
	typedef reverse_iterator<const_iterator, value_type, const_reference, A::const_pointer, difference_type> const_reverse_iterator; 
	
	//默認構造函數, A爲內存分配器
	explicit vector(const A& al = A());
    
	//構造函數, 構造 n 個值爲 x 的元素
	explicit vector(size_type n, const T& v = T(), const A& al = A());
    
	//拷貝構造函數
	vector(const vector& x);

	//構造函數, 範圍爲 [first, last)
    vector(const_iterator first, const_iterator last, const A& al = A());
    
	//預留元素最大容量數量爲 n, 確保 capacity() 返回值爲 n
	void reserve(size_type n);
	
	//返回當前所能容納的最多元素個數
	size_type capacity() const;
    
	//返回 vector 的頭指針
	iterator begin();

	//返回 vector 的常量頭指針
	const_iterator begin() const;
	
	//返回 vector 的尾指針
	iterator end();
    
	//返回 vector 的尾指針
	iterator end() const;

	//返回反向迭代器引用, 它指向 vector 的尾部
	reverse_iterator rbegin();

	//返回反向迭代器常量引用, 它指向 vector 的尾部
    const_reverse_iterator rbegin() const;
	
	//返回反向迭代器引用, 它指向 vector 第一個元素
	reverse_iterator rend();

	//返回反向迭代器常量引用, 它指向 vector 第一個元素
    const_reverse_iterator rend() const;
	
	//重新設置元素個數爲 n, 確保 size() 返回值爲 n 
	void resize(size_type n, T x = T());

	//返回 vector 元素數量
    size_type size() const;
	
	//返回最大可允許的 vector 元素數量值
	size_type max_size() const;

	//判斷 vector 是否爲空
    bool empty() const;

	//返回保護成員, 內存分配器
	A get_allocator() const;
    
	//返回位置在 pos 的元素的引用
	reference at(size_type pos);

	//返回位置在 pos 的元素的常量引用
	const_reference at(size_type pos) const;
    
	//重載 [], 返回位置在 pos 的元素的引用
	reference operator[](size_type pos);

	//重載 [], 返回位置在 pos 的元素的常量引用
    const_reference operator[](size_type pos); 
	
	//返回第一個元素的引用
	reference front();

	//返回第一個元素的常量引用
    const_reference front() const;
	
	//返回最後一個元素的引用
	reference back();
    
	//返回最後一個元素的常量引用
	const_reference back() const;    
	
	//在 vector 的尾部插入一個元素 x
	void push_back(const T& x);
    
	//刪除最後一個元素
	void pop_back();
	
	//清空 vector 以前的內容, 並重新將範圍爲 [first, last) 的元素賦值給容器
	void assign(const_iterator first, const_iterator last);
    
	//清空 vector 以前的內容, 並重新將 n 個 x 賦值給 vector
	void assign(size_type n, const T& x = T());
    
	//在位置 it 前插入 x
	iterator insert(iterator it, const T& x = T());

	//在位置 it 前插入 n 個 x
    void insert(iterator it, size_type n, const T& x);
	
	//在位置 it 前插入範圍爲 [first, last) 的元素
    void insert(iterator it, const_iterator first, const_iterator last);    
	
	//刪除位置在 it 的元素
	iterator erase(iterator it);
	
	//刪除在 [first, last) 範圍內的元素
    iterator erase(iterator first, iterator last);
	
	//刪除所有元素
	void clear(); 
	
	//交換兩個 vector 的元素
    void swap(vector& x);

protected:
	//內存分配器, 允許你自定義一個內存分配器. 如果不自定義, 就用默認的
	//對內存分配會有特別的要求, 這時候就要自定一個分配器
	A allocator;    
};

vector 容器將其元素置於一個 dynamic array 中加以管理。它允許隨機存取，也就是說可以利用對於的索引直接存取每一個元素。在 array 尾部附加或刪除元素均非常的快速，但是在 array 的中間或者頭部插入元素就比較費時，因爲爲了保持原來的相對次序，新元素插入之後的原來的所有元素都必須移動，挪出位子來。

(1)vector 容器的初始化

#include <string>
#include <vector>
#include <iostream>

int main()
{
	//定義並初始化
	std::vector<std::string> vec;
	vec.push_back("Element 0");
	vec.push_back("Element 1");
	vec.push_back("Element 2");

	std::vector<std::string>::iterator iter;
	for (iter = vec.begin(); iter != vec.end(); iter++)
	{
		std::cout << *iter << std::endl;
	}
}

#include <string>
#include <vector>
#include <iostream>

int main()
{
	//定義並初始化
	std::vector<size_t> vec;
	vec.resize(4);
	for (size_t i = 0; i < vec.size(); i++)
	{
		vec[i] = i;
	}

	std::vector<size_t>::iterator iter;
	for (iter = vec.begin(); iter != vec.end(); iter++)
	{
		std::cout << *iter << std::endl;
	}
}

(2) vector容器size()、max_size()、capacity()方法的使用：

#include <vector>
#include <string>
#include <iostream>

int main(int argc, char* argv[])
{
	std::vector<std::string> vec;
	
	//壓入一個元素
	vec.push_back("Element 1");
	//.size(): 當前元素的個數
	std::cout << "size() = " << vec.size() << std::endl;         //Output:1
	//.max_size: 序列可控對象的個數, 允許開闢元素最大數量
	std::cout << "max_size() = " << vec.max_size() << std::endl; //Output:134217727
	//當前 vector 容器的開闢的內存, 容納元素的容量
	std::cout << "capacity() = " << vec.capacity() << std::endl; //OutPut:1

	//預留, 也就是重新開闢內存的容量, 新開闢的內存爲空, 其中沒有放置新元素
	vec.reserve(1000);
	std::cout << "size() = " << vec.size() << std::endl;         //Output:1
	std::cout << "max_size() = " << vec.max_size() << std::endl; //Output:134217727
	std::cout << "capacity() = " << vec.capacity() << std::endl; //Output:1000

	//重新調整元素數量; 它不僅開闢了內存, 而且放置了空的新元素
	vec.resize(2000);
	std::cout << "size() = " << vec.size() << std::endl;         //Output:2000
	std::cout << "max_size() = " << vec.max_size() << std::endl; //Output:134217727
	std::cout << "capacity() = " << vec.capacity() << std::endl; //Output:2000

	return 0;
}

(3) 判斷容器是否爲空：

vec.empty();  //判斷容器是否爲空

(4) 循環遍歷成員

std::vector<std::string>::iterator iter;
for (iter = vec.begin(); iter != vec.end(); iter++)
{
	std::cout << *iter << std::endl;
}

(5) 使用迭代器和簡單算法：

#include <vector>
#include <string>
#include <iostream>
#include <algorithm>

void std_print(int text)
{
	std::cout << text << std::endl;
}

bool IsPass(int score)
{
	return score > 60 ? true : false; 
}

class CIsPass
{
public:
	bool operator() (int score)
	{
		return score > 60 ? true : false;
	}
};

int main(int argc, char* argv[])
{
	std::vector<int> vec;
	vec.push_back(100);
	vec.push_back(90);
	vec.push_back(80);
	vec.pop_back();       //彈出尾部最後的一個元素
	vec.push_back(100); //vector 容易允許出現相同內容的元素
	
	//for_each 算法: 循環, 每個元素都需要執行 std_print 函數
	std::for_each (vec.begin(), vec.end(), std_print);

	//count 算法: 統計迭代器[first, last)內相同元素的個數
	std::cout << std::count(vec.begin(), vec.end(), 100) << std::endl;

	//count_if 算法: 統計迭代器[first, last)內, 使用函數 IsPass 後返回1(true)的元素個數
	//注意: count_if 統計的是函數返回值的真值的個數
	std::cout << std::count_if(vec.begin(), vec.end(), CIsPass()) << std::endl;
	std::cout << std::count_if(vec.begin(), vec.end(), IsPass) << std::endl;
	return 0;
}

(6)vector中使用find/ find_if/ search算法：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

bool IsPass(int score)
{
	return score >= 60 ? true : false;
}

bool average(int x, int y)
{
	return (y == x / 2) ? true : false;
}

int main()
{
	std::vector<int> vec;
	vec.push_back(80);
	vec.push_back(20);
	vec.push_back(90);

	std::vector<int>::iterator iter;
	
	//find 算法, 主要是搜索針對單個元素
	iter = std::find(vec.begin(), vec.end(), 20);
	if (vec.end() == iter)
	{
		std::cout << "can't find it." << std::endl;
	}
	else
	{
		std::cout << "find it." << std::endl;//Output
	}

	//find_if 算法: 查找符合函數 IsPass() 要求的結果, 主要是搜索針對單個元素
	iter = std::find_if(vec.begin(), vec.end(), IsPass);
	if (vec.end() == iter)
	{
		std::cout << "can't find it." << std::endl;
	}
	else
	{
		std::cout << "find it." << std::endl;//Output
	}

	std::vector<int> desc;
	desc.push_back(10);
	desc.push_back(45);
	
	//search 算法: 搜索整個容器, 主要是針對整個容器
	iter = std::search(vec.begin(), vec.end(), desc.begin(), desc.end());
	if (vec.end() == iter)
	{
		std::cout << "can't find it." << std::endl;//Output
	}
	else
	{
		std::cout << "find it." << std::endl;
	}
	//search 算法: 搜索整個容器, 將容器 vec 使用函數 average 換算, 並確認是否能搜索到目標容器, 主要是針對整個容器
	//注意, 函數 average 必須帶兩個參數, 分別對應兩個容器內的元素
	iter = std::search(vec.begin(), vec.end(), desc.begin(), desc.end(), average);
	if (vec.end() == iter)
	{
		std::cout << "can't find it." << std::endl;
	}
	else
	{
		std::cout << "find it." << std::endl;//Output
	}

	return 0;
}

(7)vector中使用排序算法：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

void std_print(const std::string& str)
{
	std::cout << str.c_str() << std::endl;
}

int main()
{
	std::vector<std::string> vec;
	vec.push_back("John");
	vec.push_back("Bill");
	vec.push_back("Tony");
	vec.push_back("Fidel");
	vec.push_back("Nelson");
	std::cout << "the unsorted vector: " << std::endl;
	for_each(vec.begin(), vec.end(), std_print);

	std::cout << "the sorted vector: " << std::endl;
	//排序, 也可以自己寫算法
	std::sort(vec.begin(), vec.end());
	for_each(vec.begin(), vec.end(), std_print);

	return 0;
}

(8) vector 元素增加：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main()
{
	std::vector<int> vec;
	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);   //{0, 1, 2, ..., 9}
	}
	//頭部插入元素
	vec.insert(vec.begin(), -1);
	//尾部插入元素
	vec.insert(vec.end(), 10);

	int int_array[2] = {11, 12};
	//頭部插入2個元素, 注意迭代器的範圍是: [&int_array[0], &int_array[2]）
	vec.insert(vec.begin(), &int_array[0],  &int_array[2]);
	return 0;
}

(9) vector 元素刪除：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main()
{
	std::vector<int> vec;
	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);   //{0, 1, 2, ..., 9}
	}

	//彈出最後一個元素, 改變容器的size()大小
	vec.pop_back();         //{0, 1, 2, ..., 8}
	//移除迭代器所指的元素, 也就是第一個元素, 改變容器的size()大小
	vec.erase(vec.begin()); //{1, 2, ..., 8}
	//移除迭代器所指範圍內[vec.begin(), vec.begin() + 5)的所有元素
	vec.erase(vec.begin(), vec.begin() + 5);
	//移除容器內所有元素, 它實際調用的是 erase(vec.begin(), vec.end())
	vec.clear();

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i);   //{0, 1, 2, ..., 9}
	}
	//移除匹配元素值的元素, 並在容器的末尾追加一個元素, 其最後追加的元素與前一元素一致
	//remove 算法, 它不改變容器的大小
	std::remove(vec.begin(), vec.end(), 0); //{1, 2, ..., 8, 9, 9}
	std::remove(vec.begin(), vec.end(), 1); //{2, 3, ..., 9, 9, 9}
	
	return 0;
}

(10) vector 對象交換：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main()
{
	std::vector<int> vec1, vec2;
	for (int i = 0; i < 5; i++)
	{
		vec1.push_back(i);   //vec1 = {0, 1, 2, 3, 4}
	}
	for (int i = 5; i < 9; i++)
	{
		vec2.push_back(i);   //vec2 = {5, 6, 7, 8}
	}
	//兩個容器內的元素完全交換
	std::swap(vec1, vec2);   //vec1 = {5, 6, 7, 8}; vec2 = {0, 1, 2, 3, 4}
	return 0;
}

至此，vector 容器的使用基本上已總結完畢，最後回顧下：vector，一種隨機訪問的數組類型，它提供了對數組元素的快速、隨機訪問，以及在序列尾部快速、隨機的插入和刪除操作。當然，它也支持在序列中的其他地方插入和刪除元素，但是這時效率會有所降低，這是因爲 vector 對象必須移動對象位置以容納新的元素或要收回被刪除元素的空間。如果是需要在尾部插入或刪除操作，可以考慮使用此容器。

C++ STL 序列性容器之 std::vector 容器

Kafka存儲機制

aws語音呼叫調用，告警電話

【轉】[C#] WebAPI 防止併發調用二（冥等性）

HTTP URL 詳解

創新工具：2024年開發者必備的一款表格控件（二）

車牌識別控制檯可快速整合二次開發

C++ STL 序列性容器之 std::vector 容器

C++基礎之宏的使用

Python3.7.3 + Pycharm2019.1.1 + PyQt5 環境搭建詳解！

字符編碼 ASCII/ UNICODE/ Multi-Byte （一）

操作文本文件簡介

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結