C++ 容器操作

1、容器的初始化、赋值

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

int main(int argc,char **argv)
{
	char *words[] = {"cat","birds","slog","mouse","pig","dog"};
	int len = sizeof(words)/sizeof(char*);
	vector<string> vs(words,words+len);//给vector容器赋值
	for(vector<string>::iterator iter = vs.begin(); iter != vs.end(); ++iter)
	{
		cout<<*iter<<endl;
	}

	cout<<"\n\n"<<endl;
	/**
	 * 将一个容器的指定内容赋值给另一个容器
	 * 迭代器标记出要复制的第一个元素和最后一个元素（最后一个元素是指超出数组末端的下一位置的指针）
	 */
	list<string> ls(vs.begin()+vs.size()/2 , vs.end());
	for(list<string>::iterator iter = ls.begin(); iter != ls.end(); ++iter)
	{
		cout<<*iter<<endl;
	}
	return 0;
}

C<T> c 创建一个空容器，适用于所有容器

C<T> c(c2) 创建c2的副本，c与c2必须具有相同的容器类型，并存放相同类型的元素，使用于所有容器

C<T> c(begin,end)  创建容器c, 其元素是迭代器begin和end标示的范围内元素的副本，适用于所有容器

C<T> c(n,t) 用n个值为t的元素创建容器c，只适用于顺序容器

C<T> c(n) 创建有n个值初始化元素的容器c ，只适用于顺序容器

使用默认初始化值时，元素类型必须是内置或复合类型，或者是提供了默认构造函数的类类型。如果元素类型没有默认构造函数，则必须显示指定其元素的初始化格式。

2、容器内元素的类型约束

(1)元素类型必须支持赋值运算。 所以没有元素是引用类型的容器。

(2)元素类型的对象必须可以复制。

这两个类型约束都可以从容器的定义出发，找到答案。

3、迭代器的范围

[ first , last )

它们指向同一个容器中的元素或超出末端的下一个位置

在容器中，first决不能位于last之后

while( firlst != last){
        //safe to use *first
        ++first;
}

4、顺序容器的操作

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

int main(int argc,char **argv)
{
	list<string> vs;
	string words;
	list<string>::iterator iter = vs.begin();
	while(getline(cin,words)){
		if(words.empty()){
			break;
		}
//		vs.push_back(words);
		iter = vs.insert(iter,words);//插入到链表头
	}
//	vs.insert(vs.end(),3,"yangjie");
	string array[4] = {"first","second","third","four"};
	vs.insert(vs.end(),array,array+4);//返回void，所以下一次使用迭代器之前必须初始化
	for(list<string>::const_iterator c_iter = vs.begin(); c_iter != vs.end(); ++c_iter)
	{
		cout<< *c_iter <<endl;
	}
	return 0;
}

5、容器元素的访问

c.back 返回容器c最后一个元素的引用

c.front 返回容器c第一个元素的引用

c[n]  vector && deque

c.at(n)  vector && deque

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

int main(int argc,char **argv)
{

	list<string> ls;
	string words;
	list<string>::iterator iter = ls.begin();
	while(getline(cin,words)){
		if(words.empty())
			break;

		iter = ls.insert(iter,words);
	}

	list<string>::reference rf = *ls.begin(); //取得第一个元素的引用
	cout<<rf<<endl;
	list<string>::reference rf2 = ls.front(); //取得第一个元素的引用
	cout << (rf == rf2) <<endl; // true
	list<string>::reference end = *--ls.end(); //取得最后一个元素的引用
	cout<<end<<endl;
	list<string>::reference end2 = ls.back(); //取得最后一个元素的引用
	cout<< (end == end2) <<endl; // true
	return 0;
}

6、删除元素

c.erase(p)   删除迭代器p所指的元素，返回一个迭代器，它指向被删除元素后面的元素

c.erase(b,e)

c.clear()

c.pop_back() 删除c的最后一个元素

c.pop_front() 删除容器c的第一个元素       只适用与list &&  deque

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <algorithm>
using namespace std;

int main(int argc,char **argv)
{

	list<string> ls;
	string words;
	list<string>::iterator iter = ls.begin();
	while(getline(cin,words)){ //从标准输入读取字符串，每一次都插入到链表头
		if(words.empty())
			break;

		iter = ls.insert(iter,words);
	}

	cout<<"\n\n"<<endl;

	string searchValue("third");
	list<string>::iterator find_iter = find(ls.begin(),ls.end(),searchValue);//返回一个迭代器，指向具有指定值的第一个元素
	if( find_iter != ls.end()) //必须确保迭代器不是end迭代器
	{
		cout<< *find_iter <<endl; //对找到的指定值进行操作
	}

	ls.clear();//删除容器所有元素
	ls.erase(ls.begin(),ls.end());//同上
	return 0;
}

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <algorithm>
using namespace std;

int main(int argc,char **argv)
{

	int ia[] = {1,2,3,4,5,6,7,8,9,10};
	int len = sizeof(ia)/sizeof(int);
	list<int> li(ia,ia+len);//把数组的值赋值给容器

	/**
	 * 删除list中的奇数
	 */
	/*
	for(list<int>::iterator iter = li.begin(); iter != li.end(); ++iter)
	{
		if((*iter) % 2)
		{
			iter = li.erase(iter); //这样也可以
		}
	}
	*/
	list<int>::iterator l_first = li.begin();
	while( l_first != li.end())
	{
		if((*l_first) % 2)
		{
			l_first = li.erase(l_first); //删除奇数，返回到指向下一个元素的迭代器
		}else{
			l_first++;//如果不是奇数，则指向下一个元素
		}

	}
	for(list<int>::iterator iter = li.begin(); iter != li.end(); ++iter)
	{
		cout<< *iter <<endl;
	}
	/**
	 * 删除vector中的偶数
	 */
	return 0;
}

7、vector自增长

#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <algorithm>
using namespace std;

void display(const vector<int>& vi)
{
	cout<< "size:"<<vi.size()<<"  "<<"capacity "<<vi.capacity()<<endl;
}
int main(int argc,char **argv)
{
	vector<int> vi;
	display(vi); //size:0  capacity 0 size是指容器中当前拥有元素的个数，capacity指在必须分配新的存储空间前可以存储的元素总数
	for(vector<int>::size_type sz = 0; sz != 24 ; sz++)
	{
		vi.push_back(sz);
	}
	display(vi);//size:24  capacity 32 一般编译器会指定一定的预留空间
	vi.reserve(50);//设置预留额外存储空间
	display(vi); //size:24  capacity 50
	while(vi.size() != vi.capacity())
	{
		vi.push_back(0);
	}
	display(vi);//size:50  capacity 50
	vi.push_back(1); //再添加一个元素，则需要重新分配内存了
	display(vi);//size:51  capacity 100
	return 0;
}