标签:
1 vector
#include <vector>
vector属于std命名域的,因此需要通过命名限定,如下完成你的代码:
using std::vector; vector<int> v;
或者连在一起,使用全名:
std::vector<int> v;
建议使用全局的命名域方式:
using namespace std;
1.vector的声明
vector<ElemType> c; 创建一个空的vector
vector<ElemType> c1(c2); 创建一个vector c1,并用c2去初始化c1
vector<ElemType> c(n) ; 创建一个含有n个ElemType类型数据的vector;
vector<ElemType> c(n,elem); 创建一个含有n个ElemType类型数据的vector,并全部初始化为elem;
c.~vector<ElemType>(); 销毁所有数据,释放资源;
2.vector容器中常用的函数。(c为一个容器对象)
c.push_back(elem); 在容器最后位置添加一个元素elem
c.pop_back(); 删除容器最后位置处的元素
c.at(index); 返回指定index位置处的元素
c.begin(); 返回指向容器最开始位置数据的指针
c.end(); 返回指向容器最后一个数据单元的指针+1
c.front(); 返回容器最开始单元数据的引用
c.back(); 返回容器最后一个数据的引用
c.max_size(); 返回容器的最大容量
c.size(); 返回当前容器中实际存放元素的个数
c.capacity(); 同c.size()
c.resize(); 重新设置vector的容量
c.reserve(); 同c.resize()
c.erase(p); 删除指针p指向位置的数据,返回下指向下一个数据位置的指针(迭代器)
c.erase(begin,end) 删除begin,end区间的数据,返回指向下一个数据位置的指针(迭代器)
c.clear(); 清除所有数据
c.rbegin(); 将vector反转后的开始指针返回(其实就是原来的end-1)
c.rend(); 将vector反转后的结束指针返回(其实就是原来的begin-1)
c.empty(); 判断容器是否为空,若为空返回true,否则返回false
c1.swap(c2); 交换两个容器中的数据
c.insert(p,elem); 在指针p指向的位置插入数据elem,返回指向elem位置的指针
c.insert(p,n,elem); 在位置p插入n个elem数据,无返回值
c.insert(p,begin,end) 在位置p插入在区间[begin,end)的数据,无返回值
3.vector中的操作
operator[] 如: c.[i];
同at()函数的作用相同,即取容器中的数据。
在上大致讲述了vector类中所含有的函数和操作,下面继续讨论如何使用vector容器;
1.数据的输入和删除。push_back()与pop_back()

2.元素的访问

3.排序和查询

4.二维容器

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>
using namespace std;
//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;
//创建一个list容器的实例LISTCHAR
typedef list<char> LISTCHAR;
void main(void)
{
//--------------------------
//用list容器处理整型数据
//--------------------------
//用LISTINT创建一个名为listOne的list对象
LISTINT listOne;
//声明i为迭代器
LISTINT::iterator i;
//从前面向listOne容器中添加数据
listOne.push_front (2);
listOne.push_front (1);
//从后面向listOne容器中添加数据
listOne.push_back (3);
listOne.push_back (4);
//从前向后显示listOne中的数据
cout<<"listOne.begin()--- listOne.end():"<<endl;
for (i = listOne.begin(); i != listOne.end(); ++i)
cout << *i << " ";
cout << endl;
//从后向后显示listOne中的数据
LISTINT::reverse_iterator ir;
cout<<"listOne.rbegin()---listOne.rend():"<<endl;
for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
cout << *ir << " ";
}
cout << endl;
//使用STL的accumulate(累加)算法
int result = accumulate(listOne.begin(), listOne.end(),0);
cout<<"Sum="<<result<<endl;
cout<<"------------------"<<endl;
//--------------------------
//用list容器处理字符型数据
//--------------------------
//用LISTCHAR创建一个名为listOne的list对象
LISTCHAR listTwo;
//声明i为迭代器
LISTCHAR::iterator j;
//从前面向listTwo容器中添加数据
listTwo.push_front (‘A‘);
listTwo.push_front (‘B‘);
//从后面向listTwo容器中添加数据
listTwo.push_back (‘x‘);
listTwo.push_back (‘y‘);
//从前向后显示listTwo中的数据
cout<<"listTwo.begin()---listTwo.end():"<<endl;
for (j = listTwo.begin(); j != listTwo.end(); ++j)
cout << char(*j) << " ";
cout << endl;
//使用STL的max_element算法求listTwo中的最大元素并显示
j=max_element(listTwo.begin(),listTwo.end());
cout << "The maximum element in listTwo is: "<<char(*j)<<endl;
}
#include <iostream>
#include <list>
using namespace std;
typedef list<int> INTLIST;
//从前向后显示list队列的全部元素
void put_list(INTLIST list, char *name)
{
INTLIST::iterator plist;
cout << "The contents of " << name << " : ";
for(plist = list.begin(); plist != list.end(); plist++)
cout << *plist << " ";
cout<<endl;
}
//测试list容器的功能
void main(void)
{
//list1对象初始为空
INTLIST list1;
//list2对象最初有10个值为6的元素
INTLIST list2(10,6);
//list3对象最初有3个值为6的元素
INTLIST list3(list2.begin(),--list2.end());
//声明一个名为i的双向迭代器
INTLIST::iterator i;
//从前向后显示各list对象的元素
put_list(list1,"list1");
put_list(list2,"list2");
put_list(list3,"list3");
//从list1序列后面添加两个元素
list1.push_back(2);
list1.push_back(4);
cout<<"list1.push_back(2) and list1.push_back(4):"<<endl;
put_list(list1,"list1");
//从list1序列前面添加两个元素
list1.push_front(5);
list1.push_front(7);
cout<<"list1.push_front(5) and list1.push_front(7):"<<endl;
put_list(list1,"list1");
//在list1序列中间插入数据
list1.insert(++list1.begin(),3,9);
cout<<"list1.insert(list1.begin()+1,3,9):"<<endl;
put_list(list1,"list1");
//测试引用类函数
cout<<"list1.front()="<<list1.front()<<endl;
cout<<"list1.back()="<<list1.back()<<endl;
//从list1序列的前后各移去一个元素
list1.pop_front();
list1.pop_back();
cout<<"list1.pop_front() and list1.pop_back():"<<endl;
put_list(list1,"list1");
//清除list1中的第2个元素
list1.erase(++list1.begin());
cout<<"list1.erase(++list1.begin()):"<<endl;
put_list(list1,"list1");
//对list2赋值并显示
list2.assign(8,1);
cout<<"list2.assign(8,1):"<<endl;
put_list(list2,"list2");
//显示序列的状态信息
cout<<"list1.max_size(): "<<list1.max_size()<<endl;
cout<<"list1.size(): "<<list1.size()<<endl;
cout<<"list1.empty(): "<<list1.empty()<<endl;
//list序列容器的运算
put_list(list1,"list1");
put_list(list3,"list3");
cout<<"list1>list3: "<<(list1>list3)<<endl;
cout<<"list1<list3: "<<(list1<list3)<<endl;
//对list1容器排序
list1.sort();
put_list(list1,"list1");
//结合处理
list1.splice(++list1.begin(), list3);
put_list(list1,"list1");
put_list(list3,"list3");
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<string,float> m ;
//插入元素,按键值的由小到大放入黑白树中
m["Jack"] = 98.5 ;
m["Bomi"] = 96.0 ;
m["Kate"] = 97.5 ;
//先前遍历元素
map<string,float> :: iterator it ;
for(it = m.begin() ; it != m.end() ; it ++)
{
cout << (*it).first << " : " << (*it).second << endl ;
}
return 0 ;
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<int, char> m ;
//插入元素,按键值的由小到大放入黑白树中
m[25] = ‘m‘ ;
m[28] = ‘k‘ ;
m[10] = ‘x‘ ;
m[30] = ‘a‘ ;
//删除键值为28的元素
m.erase(28) ;
//向前遍历元素
map<int, char> :: iterator it ;
for(it = m.begin() ; it != m.end() ; it ++)
{
//输出键值与映照数据
cout << (*it).first << " : " << (*it).second << endl ;
}
return 0 ;
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<int, char> m ;
//插入元素,按键值的由小到大放入黑白树中
m[25] = ‘m‘ ;
m[28] = ‘k‘ ;
m[10] = ‘x‘ ;
m[30] = ‘a‘ ;
//反向遍历元素
map<int, char> :: reverse_iterator rit ;
for( rit = m.rbegin() ; rit != m.rend() ; rit ++)
{
//输入键值与映照数据
cout << (*rit).first << " : " << (*rit).second << endl ;
}
return 0 ;
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<int, char> m ;
//插入元素,按键值的由小到大放入黑白树中
m[25] = ‘m‘ ;
m[28] = ‘k‘ ;
m[10] = ‘x‘ ;
m[30] = ‘a‘ ;
map<int, char> :: iterator it ;
it = m.find(28) ;
if(it != m.end()) //搜索到该键值
cout << (*it).first << " : " << ( *it ).second << endl ;
else
cout << "not found it" << endl ;
return 0 ;
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
//自定义比较函数 myComp
struct myComp

{
bool operator() (const int &a, const int &b)
{
if(a != b) return a > b ;
else return a > b ;
}
} ;
int main()

{
//定义map对象,当前没有任何元素
map<int, char> m ;
//插入元素,按键值的由小到大放入黑白树中
m[25] = ‘m‘ ;
m[28] = ‘k‘ ;
m[10] = ‘x‘ ;
m[30] = ‘a‘ ;
//使用前向迭代器中序遍历map
map<int, char,myComp> :: iterator it ;
for(it = m.begin() ; it != m.end() ; it ++)
cout << (*it).first << " : " << (*it).second << endl ;
return 0 ;
}
#include <map>
#include <string>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
struct Info

{
string name ;
float score ;
//重载 “<”操作符,自定义排列规则
bool operator < (const Info &a) const
{
//按score由大到小排列。如果要由小到大排列,使用“>”号即可
return a.score < score ;
}
} ;
int main()

{
//定义map对象,当前没有任何元素
map<Info, int> m ;
//定义Info结构体变量
Info info ;
//插入元素,按键值的由小到大放入黑白树中
info.name = "Jack" ;
info.score = 60 ;
m[info] = 25 ;
info.name = "Bomi" ;
info.score = 80 ;
m[info] = 10 ;
info.name = "Peti" ;
info.score = 66.5 ;
m[info] = 30 ;
//使用前向迭代器中序遍历map
map<Info,int> :: iterator it ;
for(it = m.begin() ; it != m.end() ; it ++)
{
cout << (*it).second << " : " ;
cout << ((*it).first).name << " : " << ((*it).first).score << endl ;
}
return 0 ;
}
#include <string>
#include <map>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<char, int> m ;
//赋值:字符映射数字
m[‘0‘] = 0 ;
m[‘1‘] = 1 ;
m[‘2‘] = 2 ;
m[‘3‘] = 3 ;
m[‘4‘] = 4 ;
m[‘5‘] = 5 ;
m[‘6‘] = 6 ;
m[‘7‘] = 7 ;
m[‘8‘] = 8 ;
m[‘9‘] = 9 ;
/**//*上面的10条赋值语句可采用下面这个循环简化代码编写
for(int j = 0 ; j < 10 ; j++)
{
m[‘0‘ + j] = j ;
}
*/
string sa, sb ;
sa = "6234" ;
int i ;
int sum = 0 ;
for ( i = 0 ; i < sa.length() ; i++ )
sum += m[sa[i]] ;
cout << "sum = " << sum << endl ;
return 0 ;
}
#include <string>
#include <map>
#include <iostream>
using std :: cout ;
using std :: endl ;
using std :: string ;
using std :: map ;
int main()

{
//定义map对象,当前没有任何元素
map<int, char> m ;
//赋值:字符映射数字
m[0] = ‘0‘ ;
m[1] = ‘1‘ ;
m[2] = ‘2‘ ;
m[3] = ‘3‘ ;
m[4] = ‘4‘ ;
m[5] = ‘5‘ ;
m[6] = ‘6‘ ;
m[7] = ‘7‘ ;
m[8] = ‘8‘ ;
m[9] = ‘9‘ ;
/**//*上面的10条赋值语句可采用下面这个循环简化代码编写
for(int j = 0 ; j < 10 ; j++)
{
m[j] = ‘0‘ + j ;
}
*/
int n = 7 ;
string s = "The number is " ;
cout << s + m[n] << endl ;
return 0 ;
}
标签:
原文地址:http://www.cnblogs.com/liaocheng/p/4352986.html