C++中所有器皿及算法的详细列子（包括其函数的使用）
C++中所有容器及算法的详细列子（包括其函数的使用）
在学C++的时候学到了容器和算法。看了资料，将所有的demo罗列出来，其中代码中全部注释，没一个带有=============的为一个main函数，用到的头文件都写在最前面，将注释去掉就可以直接运行。
//============================================================================
// Name : ACC.cpp
// Author : zhubin
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
#include <string>
#include <numeric>
#include <list>
#include <set>
#include <stack>
#include <valarray>
#include <math.h>
#include <map>
#include <deque>
using namespace std;
///**
// *
// * //========================= list 容器数据===================================
// * */
/*//创建一个 list 容器的实例 LISTINT
typedef list<int> LISTINT;
//创建一个 list 容器的实例 LISTCHAR
typedef list<int> 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;
}*/
///**
// *
// * //========================= vector 容器数据===================================
// * */
/*
typedef vector<int> INTVECTOR;
//测试 vector 容器的功能
void main(void)
{
//vec1 对象初始为空
INTVECTOR vec1;
//vec2 对象最初有 10 个值为 6 的元素
INTVECTOR vec2(10,6);
//vec3 对象最初有 3 个值为 6 的元素
INTVECTOR vec3(vec2.begin(),vec2.begin()+3);
//声明一个名为 i 的双向迭代器
INTVECTOR::iterator i;
//从前向后显示 vec1 中的数据
cout<<"vec1.begin()--vec1.end():"<<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//从前向后显示 vec2 中的数据
cout<<"vec2.begin()--vec2.end():"<<endl;
for (i =vec2.begin(); i !=vec2.end(); ++i)
cout << *i << " ";
cout << endl;
//从前向后显示 vec3 中的数据
cout<<"vec3.begin()--vec3.end():"<<endl;
for (i =vec3.begin(); i !=vec3.end(); ++i)
cout << *i << " ";
cout << endl;
//测试添加和插入成员函数
vec1.push_back(2);
vec1.push_back(4);
vec1.insert(vec1.begin()+1,5);
vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end());
cout<<"push() and insert():" <<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//测试赋值成员函数
vec2.assign(8,1);
cout<<"vec2.assign(8,1):" <<endl;
for (i =vec2.begin(); i !=vec2.end(); ++i)
cout << *i << " ";
cout << endl;
//测试引用类函数
cout<<"vec1.front()="<<vec1.front()<<endl;
cout<<"vec1.back()="<<vec1.back()<<endl;
cout<<"vec1.at(4)="<<vec1.at(4)<<endl;
cout<<"vec1[4]="<<vec1[4]<<endl;
//测试移出和删除
vec1.pop_back();
vec1.erase(vec1.begin()+1,vec1.end()-2);
cout<<"vec1.pop_back() and vec1.erase():" <<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//显示序列的状态信息
cout<<"vec1.capacity(): "<<vec1.capacity()<<endl;
cout<<"vec1.max_size(): "<<vec1.max_size()<<endl;
cout<<"vec1.size(): "<<vec1.size()<<endl;
cout<<"vec1.empty(): "<<vec1.empty()<<endl;
//vector 序列容器的运算
cout<<"vec1==vec3: "<<(vec1==vec3)<<endl;
cout<<"vec1<=vec3: "<<(vec1<=vec3)<<endl;
}
*/
///**
// *
// * //========================= deque 容器数据===================================
// * */
/*typedef deque<int> INTDEQUE;
//从前向后显示 deque 队列的全部元素
void put_deque(INTDEQUE deque, char *name) {
INTDEQUE::iterator pdeque;
cout << "The contents of " << name << " : ";
for (pdeque = deque.begin(); pdeque != deque.end(); pdeque++)
cout << *pdeque << " ";
cout << endl;
}
//测试 deqtor 容器的功能
void main(void) {
//deq1 对象初始为空
INTDEQUE deq1;
//deq2 对象最初有 10 个值为 6 的元素
INTDEQUE deq2(10, 6);
//deq3 对象最初有 3 个值为 6 的元素
INTDEQUE deq3(deq2.begin(), deq2.begin() + 3);
//声明一个名为 i 的双向迭代器变量
INTDEQUE::iterator i;
//从前向后显示 deq1 中的数据
put_deque(deq1, "deq1");
//从前向后显示 deq2 中的数据
put_deque(deq2, "deq2");
//从前向后显示 deq3 中的数据
put_deque(deq3, "deq3");
//从 deq1 序列后面添加两个元素
deq1.push_back(2);
deq1.push_back(4);
cout << "deq1.push_back(2) and deq1.push_back(4):" << endl;
put_deque(deq1, "deq1");
//从 deq1 序列前面添加两个元素
deq1.push_front(5);
deq1.push_front(7);
cout << "deq1.push_front(5) and deq1.push_front(7):" << endl;
put_deque(deq1, "deq1");
//在 deq1 序列中间插入数据
deq1.insert(deq1.begin() + 1, 3, 9);
cout << "deq1.insert(deq1.begin()+1,3,9):" << endl;
put_deque(deq1, "deq1");
//测试引用类函数
cout << "deq1.front()=" << deq1.front() << endl;
cout << "deq1.back()=" << deq1.back() << endl;
cout << "deq1.at(4)=" << deq1.at(4) << endl;
cout << "deq1[4]=" << deq1[4] << endl;
deq1.at(1) = 10;
deq1[2] = 12;
cout << "deq1.at(1)=10 and deq1[2]=12 :" << endl;
put_deque(deq1, "deq1");
//从 deq1 序列的前后各移去一个元素
deq1.pop_front();
deq1.pop_back();
cout << "deq1.pop_front() and deq1.pop_back():" << endl;
put_deque(deq1, "deq1");
//清除 deq1 中的第 2 个元素
deq1.erase(deq1.begin() + 1);
cout << "deq1.erase(deq1.begin()+1):" << endl;
put_deque(deq1, "deq1");
//对 deq2 赋值并显示
deq2.assign(8, 1);
cout << "deq2.assign(8,1):" << endl;
put_deque(deq2, "deq2");
//显示序列的状态信息
cout << "deq1.max_size(): " << deq1.max_size() << endl;
cout << "deq1.size(): " << deq1.size() << endl;
cout << "deq1.empty(): " << deq1.empty() << endl;
//deqtor 序列容器的运算
cout << "deq1==deq3: " << (deq1 == deq3) << endl;
cout << "deq1<=deq3: " << (deq1 <= deq3) << endl;
}*/
///**
// *
// * //========================= list 容器数据===================================
// * */
/*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");
}*/
///**
// *
// * //========================= set 容器数据===================================
// * */
/*//创建 set 模板的实例
typedef set<int> SET_INT;
//put_HTset 函数，从头向尾显示 set 容器的所有元素
void put_HTset(SET_INT set1, char *name) {
SET_INT::iterator it;
cout << name << ": ";
cout << "Head to Tail=";
for (it = set1.begin(); it != set1.end(); ++it)
cout << (*it) << " ";
cout << endl;
}
//put_THset 函数，从尾向头显示 set 容器的所有元素
void put_THset(SET_INT s1, char *name) {
SET_INT::reverse_iterator i;
cout << name << ": ";
cout << "Tail to Head=";
for (i = s1.rbegin(); i != s1.rend(); i++)
cout << (*i) << " ";
cout << endl;
}
//测试 set 模板
void main(void) {
int i;
//声明 set 的对象和迭代器
SET_INT s1; //容器初始尾空
SET_INT::iterator it;
//向 s1 对象中插入值
for (i = 1; i < 20; i = i + 2) {
s1.insert(i);
}
//正向显示 s1 中的数据
put_HTset(s1, "s1");
//反向显示 s1 中的数据
put_THset(s1, "s1");
//构造含有元素的序列并显示
SET_INT s2(s1);
put_HTset(s2, "s2");
//删除 s2 的第 2 个元素并显示
s2.erase(++s2.begin());
put_HTset(s2, "s2");
//向 s2 插入 8 和 9 并显示
s2.insert(8);
s2.insert(9);
put_HTset(s2, "s2");
//清空 s2 的序列
s2.clear();
put_HTset(s2, "s2");
//按关键给定的区间显示序列中的元素
cout << "[s1.lower_bound(5),s1.upper_bound(15)] :";
for (it = s1.lower_bound(4); it != s1.upper_bound(16); it++)
cout << (*it) << " ";
cout << endl;
//显示 s1 的状态信息
cout << "s1.size():" << s1.size() << endl;
cout << "s1.max_size():" << s1.max_size() << endl;
cout << "s1.count(15):" << s1.count(15) << endl;
//交换两个 set 容器的元素并显示
s1.swap(s2);
put_HTset(s1, "s1");
put_HTset(s2, "s2");
//关系运算
s1.insert(5);
cout << "s1>s2 = " << (s1 > s2) << endl;
}*/
///**
// *
// * //========================= multiset 容器数据===================================
// * */
/*//创建 multiset 模板的实例
typedef multiset<int> MULTISET_INT;
//put_HTset 函数，从头向尾显示 multiset 容器的所有元素
void put_HTset(MULTISET_INT set1, char *name) {
MULTISET_INT::iterator it;
cout << name << ": ";
cout << "Head to Tail=";
for (it = set1.begin(); it != set1.end(); ++it)
cout << (*it) << " ";
cout << endl;
}
//put_THset 函数，从尾向头显示 multiset 容器的所有元素
void put_THset(MULTISET_INT s1, char *name) {
MULTISET_INT::reverse_iterator i;
cout << name << ": ";
cout << "Tail to Head=";
for (i = s1.rbegin(); i != s1.rend(); i++)
cout << (*i) << " ";
cout << endl;
}
//测试 multiset 模板
void main(void) {
int i;
//声明 multiset 的对象和迭代器
MULTISET_INT s1; //容器初始尾空
MULTISET_INT::iterator it;
//向 s1 对象中插入值
for (i = 1; i < 20; i = i + 2) {
s1.insert(i);
}
//正向显示 s1 中的数据
put_HTset(s1, "s1");
//反向显示 s1 中的数据
put_THset(s1, "s1");
//构造含有元素的序列并显示
MULTISET_INT s2(s1);
put_HTset(s2, "s2");
//删除 s2 的第 2 个元素并显示
s2.erase(++s2.begin());
put_HTset(s2, "s2");
//向 s2 插入 8 和 9 并显示
s2.insert(8);
s2.insert(9);
put_HTset(s2, "s2");
//清空 s2 的序列
s2.clear();
put_HTset(s2, "s2");
//按键给定的区间显示序列中的元素
cout << "[s1.lower_bound(5),s1.upper_bound(15)] :";
for (it = s1.lower_bound(4); it != s1.upper_bound(16); it++)
cout << (*it) << " ";
cout << endl;
//显示 s1 的状态信息
cout << "s1.size():" << s1.size() << endl;
cout << "s1.max_size():" << s1.max_size() << endl;
cout << "s1.count(15):" << s1.count(15) << endl;
//交换两个 multiset 容器的元素并显示
s1.swap(s2);
put_HTset(s1, "s1");
put_HTset(s2, "s2");
//关系运算
s1.insert(2);
put_HTset(s1, "s1");
put_HTset(s2, "s2");
cout << "s1>s2 = " << (s1 > s2) << endl;
}*/
///**
// *
// * //========================= map 容器数据===================================
// * */
/*//创建 map 的实例，整数(int)映射字符串(string)
typedef map<int, string> INT2STRING;
//测试 map 容器
void main() {
//创建 map 对象 theMap
INT2STRING theMap;
INT2STRING::iterator theIterator, it;
//向 theMap 容器中添入数据，数字和字符串配对
//每个元素是一个映射对
theMap.insert(INT2STRING::value_type(0, "Zero"));
theMap.insert(INT2STRING::value_type(2, "Two"));
theMap.insert(INT2STRING::value_type(4, "Four"));
theMap.insert(INT2STRING::value_type(6, "Six"));
theMap.insert(INT2STRING::value_type(8, "Eight"));
//显示 map 容器的所有对象
cout << "theMap.begin()--theMap.end():" << endl;
for (theIterator = theMap.begin(); theIterator != theMap.end();
++theIterator) {
cout << (*theIterator).first;
cout << "," << (*theIterator).second << " ";
}
cout << endl;
//测试 map 容器 key 的惟一性
theMap.insert(INT2STRING::value_type(0, "Zero"));
theMap.insert(INT2STRING::value_type(1, "One"));
theMap.insert(INT2STRING::value_type(2, "Two"));
theMap.insert(INT2STRING::value_type(3, "Three"));
theMap.insert(INT2STRING::value_type(4, "Four"));
theMap.insert(INT2STRING::value_type(5, "Five"));
theMap.insert(INT2STRING::value_type(6, "Six"));
theMap.insert(INT2STRING::value_type(7, "Seven"));
theMap.insert(INT2STRING::value_type(8, "Eight"));
theMap.insert(INT2STRING::value_type(9, "Nine"));
//下列语句将不能插入到 map 容器中
theMap.insert(INT2STRING::value_type(5, "AAA"));
//显示 map 容器的所有对象
cout << "theMap.begin()--theMap.end():" << endl;
for (theIterator = theMap.begin(); theIterator != theMap.end();
++theIterator) {
cout << (*theIterator).first;
cout << "," << (*theIterator).second << " ";
}
cout << endl;
//按键给定的区间显示序列中的元素
cout << "[theMap.lower_bound(3),theMap.upper_bound(8)] :" << endl;
for (it = theMap.lower_bound(3); it != theMap.upper_bound(8); it++) {
cout << (*it).first;
cout << "," << (*it).second << " ";
}
cout << endl;
//显示 theMap 的状态信息
cout << "theMap.size():" << theMap.size() << endl;
cout << "theMap.max_size():" << theMap.max_size() << endl;
cout << "theMap.count(15):" << theMap.count(15) << endl;
// 从键盘上输入数字，显示对应的字符串
string theString = "";
int index;
for (;;) {
cout << "Enter \"q\" to quit, or enter a Number: ";
cin >> theString;
if (theString == "q")
break;
for (index = 0; index < theString.length(); index++) {
theIterator = theMap.find(theString[index] - '0');
if (theIterator != theMap.end())
cout << (*theIterator).second << " ";
else
cout << "[err] ";
}
cout << endl;
}
}*/
///**
// *
// * //========================= multimap 容器数据===================================
// * */
/*//创建 multimap 的实例，整数(int)映射字符串(string)
typedef multimap<int, string> INT2STRING;
//测试 multimap 容器
void main() {
//创建 multimap 对象 theMap
INT2STRING theMap;
INT2STRING::iterator theIterator, it;
//向 theMap 容器中添入数据，数字和字符串配对
//每个元素是一个映射对
theMap.insert(INT2STRING::value_type(90, "张卫"));
theMap.insert(INT2STRING::value_type(85, "李华"));
theMap.insert(INT2STRING::value_type(73, "赵明"));
theMap.insert(INT2STRING::value_type(96, "郝名"));
//显示 multimap 容器的所有对象
cout << "theMap.begin()--theMap.end():" << endl;
for (theIterator = theMap.begin(); theIterator != theMap.end();
++theIterator) {
cout << (*theIterator).second;
cout << "\t" << (*theIterator).first << endl;
}
//测试 multimap 容器 key 的非惟一性
theMap.insert(INT2STRING::value_type(90, "李朋"));
theMap.insert(INT2STRING::value_type(85, "钱德"));
theMap.insert(INT2STRING::value_type(93, "赵刚"));
//按成绩高低输出 multimap 容器的所有对象
INT2STRING::reverse_iterator i;
cout << "theMap.rbegin()--theMap.rend():" << endl;
for (i = theMap.rbegin(); i != theMap.rend(); ++i) {
cout << (*i).second;
cout << "\t" << (*i).first << endl;
}
//按关键给定的区间显示序列中的元素
cout << "[theMap.lower_bound(80),theMap.upper_bound(90)]:" << endl;
for (it = theMap.lower_bound(80); it != theMap.upper_bound(90); it++) {
cout << (*it).second;
cout << "\t" << (*it).first << endl;
}
//显示 theMap 的状态信息
cout << "theMap.size():" << theMap.size() << endl;
cout << "theMap.max_size():" << theMap.max_size() << endl;
cout << "theMap.count(90):" << theMap.count(90) << endl;
//清除 90 分以下的数据,并显示结果
theMap.erase(theMap.lower_bound(60), theMap.upper_bound(89));
cout << "theMap.rbegin()--theMap.rend():" << endl;
for (i = theMap.rbegin(); i != theMap.rend(); ++i) {
cout << (*i).second;
cout << "\t" << (*i).first << endl;
}
}*/
///**
// *
// * //=========================valarray 容器数据===================================
// * */
/*#define ARRAY_SIZE 3 //array size
//测试 valarray 容器
void main() {
//创建具有 3 个元素的数组 val_array
valarray<double> val_array(ARRAY_SIZE);
//设置数组的值为 1, 4, 9
for (int i = 0; i < ARRAY_SIZE; i++)
val_array[i] = (i + 1) * (i + 1);
//显示 val_array 数组的大小
cout << "Size of val_array = " << val_array.size() << endl;
// 显示 val_array 数组的值
cout << "The values in val_array before calling sqrt() and pow():"
<< endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << val_array[i] << " ";
cout << endl;
//声明一个 rev_valarray 数组，其保存对数组 val_array 的取反
valarray<double> rev_valarray(ARRAY_SIZE);
for (int i = 0; i < ARRAY_SIZE; i++)
rev_valarray[i] = val_array[ARRAY_SIZE - i - 1];
//显示 rev_valarray 数组的大小和元素
cout << "Size of rev_valarray = " << rev_valarray.size() << endl;
cout << "The values in rev_valarray:" << endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << rev_valarray[i] << " ";
cout << endl;
// 声明 rvalue_array 数组，其存放调用 sqrt()和 pow()函数的返回值
valarray<double> rvalue_array;
//调用 sqrt()函数并显示结果
rvalue_array = sqrt(val_array);
cout << "The result of rvalue_array after calling sqrt():" << endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << rvalue_array[i] << " ";
cout << endl;
//对 val_array 数组元素计算幂函数并显示
rvalue_array = pow(val_array, rev_valarray);
cout << "The result after calling pow(val_array, rev_valarray):"
<< endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << rvalue_array[i] << " ";
cout << endl;
//对 val_array 数组元素计算幂函数，指数均为 2.0，并显示
rvalue_array = pow(val_array, 2.0);
cout << "The result after calling pow(val_array, 2.0):" << endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << rvalue_array[i] << " ";
cout << endl;
//对 2.0 进行幂函数运算，指数均为数组 val_array 的各元素值
rvalue_array = pow(2.0, val_array);
cout << "The result after calling pow(2.0, val_array):" << endl;
for (int i = 0; i < ARRAY_SIZE; i++)
cout << rvalue_array[i] << " ";
cout << endl;
//对 val_array 和 rvalue_array 求和
cout << "val_array.sum()=" << val_array.sum() << endl;
cout << "rvalue_array.sum()=" << rvalue_array.sum() << endl;
//求最大值并显示
cout << "val_array.max()=" << val_array.max() << endl;
cout << "rvalue_array.max()=" << rvalue_array.max() << endl;
}*/
///**
// *
// * //=========================STACK添加数据===================================
// * */
/*typedef stack<int> STACK_INT;
void main() {
STACK_INT stack1;
int i;
//判断栈是否空
cout << "stack1.empty() returned " << (stack1.empty() ? "true" : "false")
<< endl;
//0,2,4,6...入栈
for (i = 0; i < 10; i = i + 2)
stack1.push(i);
//top()函数
if (!stack1.empty())
cout << "stack1.top() returned " << stack1.top() << endl;
//计算栈的长度
cout << "stack1.size(): " << stack1.size() << endl;
//改变栈顶的值 20.
if (!stack1.empty()) {
cout << "stack1.top()=20;" << endl;
stack1.top() = 20;
}
//弹出栈中所有的数据并显示
cout << "stack1: ";
while (!stack1.empty()) {
cout << stack1.top() << " ";
stack1.pop();
}
cout << endl;
}*/
///**
// *
// * //=========================list添加数据===================================
// * */
/*//创建一个 list 容器的实例 LISTINT，其存放 int 型数据
typedef list<int> LISTINT;
void main(void) {
//用 LISTINT 创建一个名为 listOne 的 list 对象
LISTINT listOne;
//指定 i 为迭代器变量
LISTINT::iterator i;
LISTINT::reverse_iterator ir;
//从前面向 listOne 容器中添加数据
listOne.push_front(2);
listOne.push_front(1);
//从后面向 listOne 容器中添加数据
listOne.push_back(3);
listOne.push_back(4);
//从前向后显示 listOne 中的数据
for (i = listOne.begin(); i != listOne.end(); ++i)
cout << *i << " ";
cout << endl;
//从后向后显示 listOne 中的数据
for (ir = listOne.rbegin(); ir != listOne.rend(); ++ir)
cout << *ir << " ";
cout << endl;
//从键盘上输入数据
for (i = listOne.begin(); i != listOne.end(); ++i) {
cout << "listOne :";
cin >> (*i);
}
//从前向后显示 listOne 中的数据
for (i = listOne.begin(); i != listOne.end(); ++i)
cout << *i << " ";
cout << endl;
//bidirectional 迭代器不允许加减运算
// i=listOne.begin()+1;
}*/
///**
// *
// * //========================= accumulate 算法对普通数组及vector的处理===================
// * */
/*//利用类模板生成类实例
typedef vector<int> IntArray;
typedef list<int> LISTINT;
typedef set<int> SET_INT;
int add(int a, int b) {
return a + b;
}
//在 main()函数中测试 accumulate 算法
void main() {
//--------------------------------------------
// accumulate 算法对于普通数组的计算
//---------------------------------------------
int x[] = { 1, 3, 5, 7, 9 };
cout << "x[]:";
for (int i = 0; i < 5; i++)
cout << x[i] << " ";
cout << endl;
cout << "accumulate(x,x+5,0)=";
cout << accumulate(x, x + 5, 0) << endl;
int val = 100;
cout << "val=" << val << endl;
cout << "accumulate(x,x+5,val)=";
cout << accumulate(x, x + 5, val) << endl;
//--------------------------------------------
// accumulate 算法对于 vector 容器的计算
//---------------------------------------------
//声明 intvector 容器和迭代器 ii
IntArray intvector;
IntArray::iterator ii;
//向 intvector 容器中插入元素
for (int i = 1; i <= 5; i++) {
intvector.push_back(i);
};
//显示 intvector 容器中的元素值和累加结果
cout << "intvector: " << endl;
for (ii = intvector.begin(); ii != intvector.end(); ++ii)
cout << (*ii) << " ";
cout << endl;
cout << "accumulate(intvector.begin(),intvector.end(),0)=";
cout << accumulate(intvector.begin(), intvector.end(), 0) << endl;
//--------------------------------------------
// accumulate 算法对于 list 容器的计算
//---------------------------------------------
//声明 list 容器对象和迭代器
LISTINT::iterator iL;
LISTINT list1;
//向 list1 容器对象中插入元素并显示
list1.push_front(1);
list1.push_front(3);
list1.push_front(5);
list1.push_back(2);
list1.push_back(6);
//显示 list1 容器的元素值和累加结果
cout << "list1: " << endl;
for (iL = list1.begin(); iL != list1.end(); ++iL)
cout << (*iL) << " ";
cout << endl;
cout << "accumulate(list1.begin(),list1.end(),0)=";
cout << accumulate(list1.begin(), list1.end(), 0) << endl;
//--------------------------------------------
// accumulate 算法对于 set 容器的计算
//---------------------------------------------
//声明 set 容器对象和迭代器
SET_INT set1;
SET_INT::iterator si;
//向 set1 容器中插入元素
set1.insert(5);
set1.insert(20);
set1.insert(10);
set1.insert(15);
set1.insert(25);
//显示 set1 容器的元素值和累加结果
cout << "set1: " << endl;
for (si = set1.begin(); si != set1.end(); ++si)
cout << (*si) << " ";
cout << endl;
cout << "accumulate(set1.begin(),set1.end(),0)=";
cout << accumulate(set1.begin(), set1.end(), 0) << endl;
cout << "accumulate(set1.begin(),set1.end(),100)=";
cout << accumulate(set1.begin(), set1.end(), 100) << endl;
}*/
/**
*
* //========================= count 算法对普通数组及vector的处理========================
* */
/*#define size 10
//产生指定范围的整数随机数
int getrand(int min, int max) {
int m;
m = (max - min);
m = min + double(rand()) / RAND_MAX * m;
return m;
}
//利用类模板生成实例
typedef vector<int> IntArray;
typedef list<int> LISTINT;
typedef set<int> SET_INT;
//在 main()函数中测试 accumulate 算法
void main() {
//--------------------------------------------
// count 算法对于普通数组的计算
//---------------------------------------------
int x[size];
cout << "x[]:";
for (int i = 0; i < size; i++) {
x[i] = getrand(1, 3);
cout << x[i] << " ";
}
cout << endl;
cout << "count(x,x+size,2)=";
cout << count(x, x + size, 2) << endl;
cout << "count(x+2,x+8,2)=";
cout << count(x + 2, x + 8, 2) << endl;
//--------------------------------------------
// count 算法对于 vector 容器的计算
//---------------------------------------------
//声明 intvector 容器和迭代器 ii
IntArray intvector;
IntArray::iterator ii;
//向 intvector 容器中插入元素
for (int i = 1; i < size; i++) {
intvector.push_back(getrand(2, 6));
};
//显示 intvector 容器中的元素值和统计结果
cout << "intvector: ";
for (ii = intvector.begin(); ii != intvector.end(); ++ii)
cout << (*ii) << " ";
cout << endl;
cout << "count(intvector.begin(),intvector.end(),4)=";
cout << count(intvector.begin(), intvector.end(), 4) << endl;
//--------------------------------------------
// count 算法对于 list 容器的计算
//---------------------------------------------
//声明 list 容器对象和迭代器
LISTINT::iterator iL;
LISTINT list1;
//向 list1 容器对象中插入元素并显示
for (int i = 1; i < size; i++) {
list1.push_front(getrand(3, 5));
};
//显示 list1 容器的元素值和统计结果
cout << "list1: ";
for (iL = list1.begin(); iL != list1.end(); ++iL)
cout << (*iL) << " ";
cout << endl;
cout << "count(list1.begin(),list1.end(),3)=";
cout << count(list1.begin(), list1.end(), 3) << endl;
//--------------------------------------------
// count 算法对于 set 容器的计算
//---------------------------------------------
//声明 set 容器对象和迭代器
SET_INT set1;
SET_INT::iterator si;
//向 set1 容器中插入元素
for (int i = 1; i < size; i++) {
set1.insert(getrand(1, 10));
};
//显示 set1 容器的元素值和统计结果
cout << "set1: ";
for (si = set1.begin(); si != set1.end(); ++si)
cout << (*si) << " ";
cout << endl;
cout << "count(set1.begin(),set1.end(),5)=";
cout << count(set1.begin(), set1.end(), 5) << endl;
}*/
///**
// *
// * //========================= count_if 算法对普通数组及vector的处理======================
// * */
/*//如果字符串以'S'开头，则返回 true
int MatchFirstChar(const string& str) {
string s("S");
return s == str.substr(0, 1);
}
//测试 count_if 算法
int main() {
const int VECTOR_SIZE = 8;
//生成成员类型为 strings 的 vector 容器类
typedef vector<string> StringVector;
//定义迭代器类型
typedef StringVector::iterator StringVectorIt;
//声明 vector 容器的对象
StringVector NamesVect(VECTOR_SIZE);
//声明迭代器
StringVectorIt start, end, it;
int result = 0; // 存放统计数据
//初始化 vector 容器 NamesVect
NamesVect[0] = "She";
NamesVect[1] = "Sells";
NamesVect[2] = "Sea";
NamesVect[3] = "Shells";
NamesVect[4] = "by";
NamesVect[5] = "the";
NamesVect[6] = "Sea";
NamesVect[7] = "Shore";
//设置容器的起始位置和终止位置
start = NamesVect.begin();
end = NamesVect.end();
//显示 NamesVect 容器的元素
cout << "NamesVect: ";
for (it = start; it != end; it++)
cout << *it << " ";
cout << endl;
//统计并显示 NamesVect 容器的所有元素中以'S'字符开头的字符串
result = count_if(start, end, MatchFirstChar);
cout << "Number of elements that start with letter \"S\" = " << result
<< endl;
//显示 NamesVect 容器[1,6]之间的元素
cout << "NamesVect[1]--NamesVect[6]: ";
for (it = &NamesVect[1]; it != &NamesVect[7]; it++)
cout << *it << " ";
cout << endl;
//统计并显示 NamesVect 容器的所有元素中以'S'字符开头的字符串
result = count_if(&NamesVect[1], &NamesVect[7], MatchFirstChar);
cout << "Number of elements that start with letter \"S\" = " << result
<< endl;
return 1;
}*/
///**
// *
// * //========================= fill 和 fill_n算法对普通数组及vector的处理====================
// * */
/*//利用类模板生成实例
typedef vector<int> IntArray;
//显示数组
void put_array(int x[], int size) {
for (int i = 0; i < size; i++)
cout << x[i] << " ";
cout << endl;
}
//显示 vector 容器中的元素
void put_vector(IntArray v) {
IntArray::iterator theIterator;
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
cout << endl;
}
//在 main()函数中测试 fill 和 fill_n 算法
int main() {
//--------------------------------------------
// fill 和 fill_n 算法对普通数组的计算
//---------------------------------------------
int x[] = { 1, 3, 5, 7, 9 };
cout << "x[]: ";
put_array(x, 5);
//填数处理
fill(x + 1, x + 3, 2);
cout << "fill(x+1,x+3,2): " << endl;
put_array(x, 5);
fill_n(x, 3, 8);
cout << "fill_n(x,3,8): " << endl;
put_array(x, 5);
//--------------------------------------------
// fill 和 fill_n 算法对于 vector 容器的计算
//---------------------------------------------
//声明 intvector 容器和迭代器 ii
IntArray intvector;
//向 intvector 容器中插入元素
for (int i = 1; i <= 10; i++) {
intvector.push_back(i);
};
//显示 intvector 容器中的元素值和统计结果
cout << "intvector: " << endl;
put_vector(intvector);
//填数处理
fill(intvector.begin(), intvector.begin() + 3, 2);
cout << "fill(intvector.begin(),intvector.begin()+3,2): " << endl;
put_vector(intvector);
fill_n(&intvector[5], 3, 8);
cout << "fill_n(&intvector[5],3,8): " << endl;
put_vector(intvector);
return 0;
}*/
/**
*
* //========================= find()算法对普通数组及vector的处理=================
* */
/*#define ARRAY_SIZE 10
//利用类模板生成实例
typedef vector<int> IntArray;
//显示数组
void put_array(int x[], int size) {
for (int i = 0; i < size; i++)
cout << x[i] << " ";
cout << endl;
}
//显示 vector 容器中的元素
void put_vector(IntArray v) {
IntArray::iterator theIterator;
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
cout << endl;
}
//在 main()函数中测试 find()算法
int main() {
int i, value, *p;
//--------------------------------------------
// find()算法对于普通数组的处理
//---------------------------------------------
int x[ARRAY_SIZE] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
cout << "x[]: ";
put_array(x, ARRAY_SIZE);
//find()算法查找,并显示查找结果
for (i = 0; i <= 2; i++) {
cout << "value=";
cin >> value;
p = find(x, x + ARRAY_SIZE, value);
if (p != x + ARRAY_SIZE) { //查到
cout << "First element that matches " << value;
cout << " is at location " << p - x << endl;
} else { //未查到
cout << "The sequence does not contain any elements";
cout << " with value " << value << endl;
}
}
//--------------------------------------------
// find()算法对于 vector 容器的处理
//---------------------------------------------
//声明 intvector 容器对象
IntArray intvector;
//向 intvector 容器中插入元素
for (i = 1; i <= 10; i++) {
intvector.push_back(i);
};
//显示 intvector 容器中的元素值
cout << "intvector: ";
put_vector(intvector);
//find()算法查找,并显示查找结果
IntArray::iterator pos;
for (i = 0; i <= 2; i++) {
cout << "value=";
cin >> value;
pos = find(intvector.begin(), intvector.end(), value);
if (pos != intvector.end()) { //查到
cout << "First element that matches " << value;
cout << " is at location " << pos - intvector.begin() << endl;
} else { //未查到
cout << "The sequence does not contain any elements";
cout << " with value " << value << endl;
}
}
return 1;
}*/
/**
*
* //========================= find_end()算法对普通数组的处理====================
* */
/*#define ARRAY_SIZE 10
//利用类模板生成实例
typedef vector<int> IntArray;
//显示数组
void put_array(int x[], int size) {
for (int i = 0; i < size; i++)
cout << x[i] << " ";
}
//显示 vector 容器中的元素
void put_vector(IntArray v) {
IntArray::iterator theIterator;
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
}
//在 main()函数中测试 find()_end()算法
int main() {
//--------------------------------------------
// find_end()算法对普通数组的处理
//---------------------------------------------
int x[ARRAY_SIZE] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
cout << "x[]: ";
put_array(x, ARRAY_SIZE);
cout << endl;
int y[] = { 5, 7, 9 };
cout << "y[]: ";
put_array(y, 3);
cout << endl;
// find_end()算法查找,并显示查找结果
int *p = find_end(x, x + ARRAY_SIZE, &y[0], &y[2]);
if (p != x + ARRAY_SIZE) { //查到
cout << "The first element that matches :";
put_array(y, 3);
cout << " is at location in x" << p - x << endl;
} else { //未查到
cout << "The sequence does not contain any elements";
cout << " with value ";
put_array(&x[3], 3);
}
//--------------------------------------------
// find_end()算法对 vector 容器的处理
//---------------------------------------------
//声明 intvector 容器对象
IntArray intvector;
//向 intvector 容器中插入元素
for (int i = 1; i <= 10; i++) {
intvector.push_back(i);
};
//显示 intvector 容器中的元素值
cout << "intvector: ";
put_vector(intvector);
cout << endl;
IntArray temp;
temp.push_back(5);
temp.push_back(6);
temp.push_back(7);
cout << "temp: ";
put_vector(temp);
cout << endl;
// find_end()算法查找,并显示查找结果
IntArray::iterator pos;
pos = find_end(intvector.begin(), intvector.end(), temp.begin(),
temp.end());
if (pos != intvector.end()) { //查到
cout << "The first element that matches ";
put_vector(temp);
cout << " is at location in intvector " << pos - intvector.begin()
<< endl;
} else { //未查到
cout << "The sequence does not contain any elements";
cout << " with value ";
put_vector(temp);
cout << endl;
}
return 1;
}*/
/**
*
* //===============利用 generate_n 算法用 Fibonacci 数填充 vector 容器==================
* */
/*//返回一个 Fibonacci 数，其由 generate_n()算法调用
int Fibonacci1(void) {
static int r;
static int f1 = 0;
static int f2 = 1;
r = f1 + f2;
f1 = f2;
f2 = r;
return f1;
}
//返回一个 Fibonacci 数，其由 generate()算法调用
int Fibonacci2(void) {
static int r;
static int f1 = 0;
static int f2 = 1;
r = f1 + f2;
f1 = f2;
f2 = r;
return f1;
}
//定义整型数的 vector 容器类
typedef vector<int> IntVector;
//显示 vector 容器中的元素
void put_vector(IntVector v, char *name) {
IntVector::iterator theIterator;
cout << name << ":" << endl;
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
cout << endl;
}
//测试 generate()和 generate_n()算法
int main() {
const int VECTOR_SIZE = 15;
//定义迭代器类
typedef IntVector::iterator IntVectorIt;
//声明 vector 容器对象
IntVector Numbers1(VECTOR_SIZE), Numbers2(VECTOR_SIZE);
int i;
//初始化 vector 容器对象
for (i = 0; i < VECTOR_SIZE; i++)
Numbers1[i] = i;
//显示 vector 容器对象的元素
cout << "Before calling generate_n:" << endl;
put_vector(Numbers1, "Numbers1");
//利用 generate_n 算法用 Fibonacci 数填充 vector 容器
generate_n(Numbers1.begin(), VECTOR_SIZE, Fibonacci1);
//显示 vector 容器对象的元素
cout << "After calling generate_n:" << endl;
put_vector(Numbers1, "Numbers1");
//利用 generate 算法用 Fibonacci 数填充 vector 容器
generate(Numbers2.begin(), Numbers2.end(), Fibonacci2);
//显示 vector 容器对象的元素
cout << "After calling generate:" << endl;
put_vector(Numbers2, "Numbers2");
return 1;
}*/
/**
*
* //================reverse()和 reverse_copy()算法对 vector 容器的处理======================
* */
/*//利用类模板生成实例
typedef vector<int> IntArray;
//显示数组
void put_array(int x[], int size) {
for (int i = 0; i < size; i++)
cout << x[i] << " ";
cout << endl;
}
//显示 vector 容器中的元素
void put_vector(IntArray v) {
IntArray::iterator theIterator;
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
cout << endl;
}
//在 main()函数中测试 reverse()和 reverse_copy()算法
int main() {
//--------------------------------------------
// reverse()和 reverse_copy()算法对普通数组处理
//---------------------------------------------
int x[] = { 1, 3, 5, 7, 9 };
cout << "x[]:";
put_array(x, 5);
//reverse()反转 x 数组并显示
reverse(x, x + 5);
cout << "x[]:";
put_array(x, 5);
int y[] = { 2, 4, 6, 8, 10 };
cout << "y[]:";
put_array(y, 5);
//reverse_copy()反转 y 数组的部分元素并拷贝到 x 数组第 2个元素位置
reverse_copy(y + 1, y + 3, x + 1);
cout << "x[]:";
put_array(x, 5);
cout << "y[]:";
put_array(y, 5);
//--------------------------------------------
// reverse()和 reverse_copy()算法对 vector 容器的处理
//---------------------------------------------
//声明 intvector 容器和迭代器 ii
IntArray intvector;
//向 intvector 容器中插入元素
for (int i = 1; i <= 10; i++) {
intvector.push_back(i);
};
//显示 intvector 容器中的元素值
cout << "intvector: " << endl;
put_vector(intvector);
//reverse()对于 vector 容器的处理
reverse(intvector.begin(), intvector.end());
cout << "intvector: " << endl;
put_vector(intvector);
// reverse_copy 对于 vector 容器的处理
IntArray temp(5);
reverse_copy(intvector.begin() + 2, intvector.begin() + 7, temp.begin());
cout << "temp: " << endl;
put_vector(temp);
return 1;
}*/
/**
*
* //=================sort()和 partial_sort()算法对普通数组处理=====================
*
* */
/*#define ARRAY_SIZE 15
//定义整型数的 vector 容器类
typedef vector<int> IntVector;
//显示数组
void put_array(int x[], int size) {
for (int i = 0; i < size; i++)
cout << x[i] << " ";
cout << endl;
}
//显示 vector 容器中的元素
void put_vector(IntVector v, char *name) {
IntVector::iterator theIterator;
cout << name << ": ";
for (theIterator = v.begin(); theIterator != v.end(); ++theIterator) {
cout << (*theIterator) << " ";
}
cout << endl;
}
//产生指定范围的整数随机数
int getrand(int min, int max) {
int m;
m = (max - min);
m = int(min + double(rand()) / RAND_MAX * m);
return m;
}
//在 main()函数中测试 sort()和 partial_sort()算法
int main() {
int i;
//--------------------------------------------
sort()和 partial_sort()算法对普通数组处理
//---------------------------------------------
sort()算法处理数组，并显示
int x[ARRAY_SIZE];
for (i = 0; i < ARRAY_SIZE; i++) {
x[i] = getrand(1, 20);
}
cout << "x[]:";
put_array(x, ARRAY_SIZE);
sort(x, x + ARRAY_SIZE);
cout << "sort(x,x+ARRAY_SIZE):" << endl;
put_array(x, ARRAY_SIZE);
//partial_sort()算法对于数组进行处理
int y[ARRAY_SIZE];
for (i = 0; i < ARRAY_SIZE; i++) {
y[i] = getrand(1, 30);
}
cout << "y[]:";
put_array(y, ARRAY_SIZE);
partial_sort(y + 2, y + 7, y + ARRAY_SIZE);
cout << "partial_sort(y+2,y+7,y+ARRAY_SIZE):" << endl;
put_array(y, ARRAY_SIZE);
//--------------------------------------------
// sort()和 partial_sort()算法对 vector 容器的处理
//---------------------------------------------
IntVector Numbers1, Numbers2;
for (i = 0; i < 15; i++) {
Numbers1.push_back(getrand(1, 30));
Numbers2.push_back(getrand(1, 30));
}
put_vector(Numbers1, "Numbers1");
put_vector(Numbers2, "Numbers2");
//sort()算法处理并显示
sort(Numbers1.begin(), Numbers1.end());
cout << "After call sort():" << endl;
put_vector(Numbers1, "Numbers1");
//partial_sort()算法处理并显示
partial_sort(Numbers2.begin() + 2, Numbers2.begin() + 7, Numbers2.end());
cout << "After call partial_sort():" << endl;
put_vector(Numbers2, "Numbers2");
return 1;
}*/
//=================end=end=end=end=end===========================================================
C++模板类的使用：
//============================================================================
// Name : ACCD.cpp
// Author : zhubin
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include<string.h>
using namespace std;
/**
*
* =================C++ 模板类的使用==========================
* */
/*//声明函数模板的原型语句
template <class T> void swap(T *x, T *y);
//定义一个结构类型
struct student {
int n;
char name[20];
float grade;
};
//在 main()函数中测试 swap()函数模板
void main(void)
{
//交换两个 int 型变量中的数据
int m=3,n=5;
cout<<"m="<<m<<" n="<<n<<endl;
swap(&m,&n);
cout<<"m="<<m<<" n="<<n<<endl;
cout<<"-------------------"<<endl;
//交换两个 double 型变量中的数据
double x=3.5,y=5.7;
cout<<"x="<<x<<" y="<<y<<endl;
swap(&x,&y);
cout<<"x="<<x<<" y="<<y<<endl;
cout<<"-------------------"<<endl;
//交换两个 char 型变量中的数据
char c1='A',c2='a';
cout<<"c1="<<c1<<" c2="<<c2<<endl;
swap(&c1,&c2);
cout<<"c1="<<c1<<" c2="<<c2<<endl;
cout<<"-------------------"<<endl;
//交换两个结构变量中的数据
student s1={1001,"ZhangHua",90};
student s2={1011,"LiWei",95.5};
cout<<"s1: ";
cout<<s1.n<<" "<<s1.name<<" "<<s1.grade<<endl;
cout<<"s2: ";
cout<<s2.n<<" "<<s2.name<<" "<<s2.grade<<endl;
swap(&s1,&s2);
cout<<"swap(s1,s2):"<<endl;
cout<<"s1: ";
cout<<s1.n<<" "<<s1.name<<" "<<s1.grade<<endl;
cout<<"s2: ";
cout<<s2.n<<" "<<s2.name<<" "<<s2.grade<<endl;
}*/
/**
*
* =================C++ 模板类的使用==========================
* */
/*//定义名为 swap 的函数模板用于交换两个变量中的数据
template <class T> void swap(T *x, T *y)
{
T temp;
temp=*x;
*x=*y;
*y=temp;
}
//定义输入函数模板
template <class T> void input(char *str,T &x) {
cout<<str<<"=";
cin>>x;
}
//定义输出函数模板
template <class T> void output(char *str,T x) {
cout<<str<<"="<<x<<endl;
}
//在 main()函数中测试输入输出函数模板
void main(void)
{
//输入输出 int 型数据
int a,b;
input("a",a);
output("a",a);
b=3*a;
output("3*a",b);
output("a+b",a+b);
cout<<"-------------------"<<endl;
//输入输出 double 型数据
double x,y;
input("x",x);
output("x",x);
y=2*x;
output("y",y);
cout<<"-------------------"<<endl;
//输入输出 char 型数据
char c1;
input("c1",c1);
output("c1+2",char(c1+2));
cout<<"-------------------"<<endl;
//输入输出字符串数据
char string[80];
input("string",string);
output("string",string);
}*/
/**
*
* =================C++ 数组模板类的使用==========================
* */
/*//显示数组的函数模板
template<class T> void arr_put(T arr[], int size) {
for (int i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
//选择法对数组排序的函数模板
template<class T> void sort(T arr[], int size) {
T temp;
int i, j;
for (i = 0; i < size - 1; i++)
for (j = i + 1; j < size; j++)
if (arr[i] > arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//二分查找法的函数模板
template<class T> int binary_search(T array[], T value, int size) {
int found = 0;
int high = size, low = 0, mid;
mid = (high + low) / 2;
cout << "Looking for " << value << endl;
while ((!found) && (high >= low)) {
if (value == array[mid])
found = 1;
else if (value < array[mid])
high = mid - 1;
else
low = mid + 1;
mid = (high + low) / 2;
}
return ((found) ? mid : -1);
}
//main()函数中使用处理数组的函数模板
void main(void) {
//处理 int 型数组
int array[10] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
//显示数组初值
arr_put(array, 10);
//对数组排序并显示
sort(array, 10);
arr_put(array, 10);
//查找数组
cout << "Result of search: " << binary_search(array, 3, 10) << endl;
cout << "Result of search: " << binary_search(array, 2, 10) << endl;
cout << "Result of search: " << binary_search(array, 9, 10) << endl;
cout << "Result of search: " << binary_search(array, 5, 10) << endl;
cout << "------------------------------" << endl;
//处理字符串型数组
char ch1, str[] = "happy";
int size = strlen(str);
//显示数组初值
arr_put(str, size);
//对数组排序并显示
sort(str, size);
arr_put(str, size);
//查找数组
cout << "Input a char:";
cin >> ch1;
cout << "Result of search: " << binary_search(str, ch1, size) << endl;
}*/
/**
*
* =================C++ 模板类的使用==========================
* */
/*//定义名为 ex_class 的类模板
template<class T> class ex_class {
T value;
public:
ex_class(T v) {
value = v;
}
void set_value(T v) {
value = v;
}
T get_value(void) {
return value;
}
};
//main()函数中测试 ex_class 类模板
void main(void) {
//测试 int 类型数据
ex_class<int> a(5), b(10);
cout << "a.value:" << a.get_value() << endl;
cout << "b.value:" << b.get_value() << endl;
//测试 char 类型数据
ex_class<char> ch('A');
cout << "ch.value:" << ch.get_value() << endl;
ch.set_value('a');
cout << "ch.value:" << ch.get_value() << endl;
//测试 double 类型数据
ex_class<double> x(5.5);
cout << "x.value:" << x.get_value() << endl;
x.set_value(7.5);
cout << "x.value:" << x.get_value() << endl;
}*/
/**
*
* =================C++ stck模板类的使用==========================
* */
/*//定义栈的尺寸
const int SIZE = 100;
//定义处理栈的类模板接口
template<class T> class stack {
T stck[SIZE];
int tos;
public:
stack(void) {
tos = 0;
cout << "Stack Initialized." << endl;
}
~stack(void) {
cout << "Stack Destroyed." << endl;
}
void push(T);
T pop(void);
};
//定义栈的成员函数
template<class T> void stack<T>::push(T i) {
if (tos == SIZE) {
cout << "Stack is full." << endl;
return;
}
stck[tos++] = i;
}
template<class T> T stack<T>::pop(void) {
if (tos == 0) {
cout << "Stack underflow." << endl;
return 0;
}
return stck[--tos];
}
//main()函数中测试 stack 类模板
void main(void) {
//处理 int 类型数据的栈
cout << "stack<int> a :" << endl;
stack<int> a;
a.push(1);
a.push(2);
cout << a.pop() << " ";
cout << a.pop() << endl;
//处理 double 类型数据的栈
cout << "stack<double> b :" << endl;
stack<double> b;
b.push(99.3);
b.push(-12.23);
cout << b.pop() << " ";
cout << b.pop() << endl;
//处理 char 类型数据的栈
cout << "stack<char> c :" << endl;
stack<char> c;
for (int i = 0; i < 10; i++)
c.push((char) 'A' + i);
for (int i = 0; i < 10; i++)
cout << c.pop();
cout << endl;
}*/
/**
*
* =================C++模板类的使用==========================
* */
/*
//定义名为 ex_class 的类模板
template<class T1, class T2> class ex_class {
T1 value1;
T2 value2;
public:
ex_class(T1 v1, T2 v2) {
value1 = v1;
value2 = v2;
}
void set_value(T1 v1, T2 v2) {
value1 = v1;
value2 = v2;
}
void put_value(void) {
cout << "valu1=" << value1 << endl;
cout << "valu2=" << value2 << endl;
}
};
//main()函数中测试 ex_class 类模板
void main(void) {
//测试 int 和 double 类型数据
ex_class<int, double> a(5, 1.5);
cout << "ex_class <int,double> a:" << endl;
a.put_value();
a.set_value(100, 3.14);
a.put_value();
//测试 double 和 int 类型数据
ex_class<double, int> b(0.5, 5);
cout << "ex_class <double,int> b:" << endl;
b.put_value();
b.set_value(1.732, 100);
b.put_value();
//测试 char 和 int 类型数据
ex_class<char, int> c('a', 5);
cout << "ex_class <char,int> c:" << endl;
c.put_value();
c.set_value('B', 100);
c.put_value();
//测试 int 和 int 类型数据
ex_class<int, int> d(5, 10);
cout << "ex_class <int,int> d:" << endl;
d.put_value();
d.set_value(100, 200);
d.put_value();
}
*/