C++一些库函数的使用方法

1.标准C++库字符串类std::string的用法

begin       得到指向字符串开头的Iterator(迭代器)

end       得到指向字符串结尾的Iterator

rbegin       得到指向反向字符串开头的Iterator

rend       得到指向反向字符串结尾的Iterator

size       得到字符串的大小

length()       和size函数功能相同

max_size       字符串可能的最大大小

capacity       在不重新分配内存的情况下，字符串可能的大小

empty       判断是否为空

operator[]       取第几个元素，相当于数组

c_str       取得C风格的const char* 字符串

data       取得字符串内容地址

operator=       赋值操作符

reserve       预留空间

swap       交换函数

insert       插入字符

append       追加字符

push_back       追加字符

erase       删除字符串

clear       清空字符容器中所有内容

resize       重新分配空间

assign       和赋值操作符一样

replace       替代

copy       字符串到空间

find       查找,返回基于0的索引号

rfind       反向查找

find_first_of       查找包含子串中的任何字符，返回第一个位置

find_first_not_of       查找不包含子串中的任何字符，返回第一个位置

find_last_of       查找包含子串中的任何字符，返回最后一个位置

find_last_not_of       查找不包含子串中的任何字符，返回最后一个位置

substr(n1,len)       得到字符串从n1开始的长度为len的子串

比较字符串(支持所有的关系运算符)

compare       比较字符串

operator+       字符串链接

operator+=       += 操作符

operator==       判断是否相等

operator!=       判断是否不等于

operator<       判断是否小于

operator>>       从输入流中读入字符串

operator<<       字符串写入输出流

getline       从输入流中读入一行

 

2.cctype库
using ::isalpha; //是否字母
using ::iscntrl; //是否控制符
using ::isdigit; //是否是数字
using ::isgraph; //是否字母、数字或标点
using ::islower; //是否小写
using ::isprint; //是否可打印字符
using ::ispunct; //是否标点
using ::isspace; //是否空格
using ::isupper; //是否大写
using ::isxdigit; //是否十六进制数字
using ::tolower; //转为小写
using ::toupper; //转为大写

 

3 algorithm.库
 

1）循环

对序列中的每个元素执行某项操作 for_each() 
 
2）查找 在序列中找出某个值的第一次出现的位置
  find(a,a+size,n)
return b;
当b=a+size
即没找到n这个值，a为指针
 
在序列中找出符合某谓词的第一个元素 find_if()
在序列中找出一子序列的最后一次出现的位置 find_end()
在序列中找出第一次出现指定值集中之值的位置 find_first_of()
在序列中找出相邻的一对值 adjacent_find()
计数 在序列中统计某个值出现的次数 count()
在序列中统计与某谓词匹配的次数 count_if()
比较 找出两个序列相异的第一个元素 mismatch()
两个序列中的对应元素都相同时为真
在序列中找到等于某值的连续n次出现的位置 equal(a,a+n,b,cmp)
equal_range(a,a+n,x)
搜索 在序列中找出一子序列的第一次出现的位置 search()
在序列中找出一值的连续n次出现的位置 search_n()
　 修改性序列操作（27个）
复制 从序列的第一个元素起进行复制 copy()
从序列的最后一个元素起进行复制 copy_backward()
交换 交换两个元素 swap()
交换指定范围的元素 swap_ranges()
交换由迭代器所指的两个元素 iter_swap()
变换 将某操作应用于指定范围的每个元素 transform()
替换 用一个给定值替换一些值 replace()
替换满足谓词的一些元素 replace_if()
复制序列时用一给定值替换元素 replace_copy()
复制序列时替换满足谓词的元素 replace_copy_if()
填充 用一给定值取代所有元素 fill()
用一给定值取代前n个元素 fill_n()
生成 用一操作的结果取代所有元素 generate()
用一操作的结果取代前n个元素 generate_n()
删除 删除具有给定值的元素 remove()
删除满足谓词的元素 remove_if()
复制序列时删除具有给定值的元素 remove_copy()
复制序列时删除满足谓词的元素 remove_copy_if()
唯一 删除相邻的重复元素 unique()
复制序列时删除相邻的重复元素 unique_copy()
反转 反转元素的次序 reverse(a,a+n)
复制序列时反转元素的次序 reverse_copy()
环移 循环移动元素 rotate(a,a+m,a+n)
以m位置为界交换前后序列
复制序列时循环移动元素 rotate_copy()
随机 采用均匀分布来随机移动元素 random_shuffle()
划分 将满足某谓词的元素都放到前面 partition()
将满足某谓词的元素都放到前面并维持原顺序 stable_partition()
　 序列排序及相关操作（27个）
排序 以很好的平均效率排序 sort(a,a+20,cmp)
bool cmp( int a,
 int b )
{ return a>b; }
在容器中或string用begin（）
 
排序，并维持相同元素的原有顺序 stable_sort()
将序列的前一部分排好序 partial_sort()
复制的同时将序列的前一部分排好序 partial_sort_copy()
第n个元素 将第n各元素放到它的正确位置 nth_element()
二分检索 找到大于等于某值的第一次出现 lower_bound()
找到大于某值的第一次出现 upper_bound()
找到（在不破坏顺序的前提下）可插入给定值的最大范围 equal_range()
在有序序列中确定给定元素是否存在 binary_search()
归并 归并两个有序序列 merge()
归并两个接续的有序序列 inplace_merge()
有序结构上的集合操作 一序列为另一序列的子序列时为真 includes()
构造两个集合的有序并集 set_union()
构造两个集合的有序交集 set_intersection()
构造两个集合的有序差集 set_difference()
构造两个集合的有序对称差集（并-交） set_symmetric_difference()
堆操作 向堆中加入元素 push_heap()
从堆中弹出元素 pop_heap()
从序列构造堆 make_heap()
给堆排序 sort_heap()
最大和最小 两个值中较小的 min()
两个值中较大的 max()
序列中的最小元素 min_element(a,a+n)
序列中的最大元素 max_element()
词典比较 两个序列按字典序的第一个在前 lexicographical_compare()
排列生成器 按字典序的下一个排列 next_permutation()
按字典序的前一个排列 prev_permutation()
    

 

4 cmath库
using ::abs; //绝对值
using ::acos; //反余弦
using ::acosf; //反余弦
using ::acosl; //反余弦
using ::asin; //反正弦
using ::asinf; //反正弦
using ::asinl; //反正弦
using ::atan; //反正切
using ::atan2; //y/x的反正切
using ::atan2f; //y/x的反正切
using ::atan2l; //y/x的反正切
using ::atanf; //反正切
using ::atanl; //反正切
using ::ceil; //上取整
using ::ceilf; //上取整
using ::ceill; //上取整
using ::cos; //余弦
using ::cosf; //余弦
using ::cosh; //双曲余弦
using ::coshf; //双曲余弦
using ::coshl; //双曲余弦
using ::cosl; //余弦
using ::exp; //指数值
using ::expf; //指数值
using ::expl; //指数值
using ::fabs; //绝对值
using ::fabsf; //绝对值
using ::fabsl; //绝对值
using ::floor; //下取整
using ::floorf; //下取整
using ::floorl; //下取整
using ::fmod; //求余
using ::fmodf; //求余
using ::fmodl; //求余
using ::frexp; //返回value=x*2n中x的值,n存贮在eptr中
using ::frexpf; //返回value=x*2n中x的值,n存贮在eptr中
using ::frexpl; //返回value=x*2n中x的值,n存贮在eptr中
using ::ldexp; //返回value*2exp的值
using ::ldexpf; //返回value*2exp的值
using ::ldexpl; //返回value*2exp的值
using ::log; //对数
using ::log10; //对数
using ::log10f; //对数
using ::log10l; //对数
using ::logf; //对数
using ::logl; //对数
using ::modf; //将双精度数value分解成尾数和阶
using ::modff; //将双精度数value分解成尾数和阶
using ::modfl; //将双精度数value分解成尾数和阶
using ::pow; //计算幂
using ::powf; //计算幂
using ::powl; //计算幂
using ::sin; //正弦
using ::sinf; //正弦
using ::sinh; //双曲正弦
using ::sinhf; //双曲正弦
using ::sinhl; //双曲正弦
using ::sinl; //正弦
using ::sqrt; //开方
using ::sqrtf; //开方
using ::sqrtl; //开方
using ::tan; //正切
using ::tanf; //正切
using ::tanh; //双曲正切
using ::tanhf; //双曲正切
using ::tanhl; //双曲正切
using ::tanl; //正切
5..cstdlib库
double atof(const char *str);
把字符串str转换成double类型。等价于：strtod(str, (char**)NULL)。
 
5.2 atoi
int atoi(const char *str);
把字符串str转换成int类型。等价于：(int)strtol(str, (char**)NULL, 10)。
 
5.3 atol
long atol(const char *str);
把字符串str转换成long类型。等价于：strtol(str, (char**)NULL, 10)。
 
5.4 strtod
double strtod(const char *start, char **end);
把字符串start的前缀转换成double类型。在转换中跳过start的前导空白符，然后逐个读入构成数的字符，任何非浮点数成分的字符都会终止上述过程。如果end不为NULL，则把未转换部分的指针保存在*end中。
如果结果上溢，返回带有适当符号的HUGE_VAL，如果结果下溢，那么函数返回0。在这两种情况下，errno均被置为ERANGE。
 
5.5 strtol
long int strtol(const char *start, char **end, int radix);
把字符串start的前缀转换成long类型，在转换中跳过start的前导空白符。如果end不为NULL，则把未转换部分的指针保存在*end中。
如果radix的值在2到36间之间，那么转换按该基数进行；如果radix为0，则基数为八进制、十进制、十六进制，以0为前导的是八进制，以0x或0X为前导的是十六进制。无论在哪种情况下，串中的字母是表示10到radix-1之间数字的字母。如果radix是16，可以加上前导0x或0X。
如果结果上溢，则依据结果的符号返回LONG_MAX或LONG_MIN，置errno为ERANGE。
 
5.6 strtoul
unsigned long int strtoul(const char *start, char **end, int radix);
与strtol()类似，只是结果为unsigned long类型，溢出时值为ULONG_MAX。
 
5.7 rand
int rand(void);
产生一个0到RAND_MAX之间的伪随机整数。RAND_MAX值至少为32767。
 
5.8 srand
void srand(unsigned int seed);
设置新的伪随机数序列的种子为seed。种子的初值为1。
 
5.9 calloc
void *calloc(size_t num, size_t size);
为num个大小为size的对象组成的数组分配足够的内存，并返回指向所分配区域的第一个字节的指针；如果内存不足以满足要求，则返回NULL。
分配的内存区域中的所有位被初始化为0。
 
5.10 malloc
void *malloc(size_t size);
为大小为size的对象分配足够的内存，并返回指向所分配区域的第一个字节的指针；如果内存不足以满足要求，则返回NULL。
不对分配的内存区域进行初始化。
 
5.11 realloc
void *realloc(void *ptr, size_t size);
将ptr指向的内存区域的大小改为size个字节。如果新分配的内存比原内存大，那么原内存的内容保持不变，增加的空间不进行初始化。如果新分配的内存比原内存小，那么新内存保持原内存区中前size字节的内容。函数返回指向新分配空间的指针。如果不能满足要求，则返回NULL，原ptr指向的内存区域保持不变。
如果ptr为NULL，则行为等价于malloc(size)。
如果size为0，则行为等价于free(ptr)。
 
5.12 free
void free(void *ptr);
释放ptr指向的内存空间，若ptr为NULL，则什么也不做。ptr必须指向先前用动态分配函数malloc、realloc或calloc分配的空间。
 
5.13 abort
void abort(void);
使程序非正常终止。其功能类似于raise(SIGABRT)。
 
5.14 exit
void exit(int status);
使程序正常终止。atexit函数以与注册相反的顺序被调用，所有打开的文件被刷新，所有打开的流被关闭。status的值如何被返回依具体的实现而定，但用0表示正常终止，也可用值EXIT_SUCCESS和EXIT_FAILURE。
 
5.15 atexit
int atexit(void (*func)(void));
注册在程序正常终止时所要调用的函数func。如果成功注册，则函数返回0值，否则返回非0值。
 
5.16 system
int system(const char *str);
把字符串str传送给执行环境。如果str为NULL，那么在存在命令处理程序时，返回0值。如果str的值非NULL，则返回值与具体的实现有关。
 
5.17 getenv
char *getenv(const char *name);
返回与name相关的环境字符串。如果该字符串不存在，则返回NULL。其细节与具体的实现有关。
 
5.18 bsearch
void *bsearch(const void *key, const void *base, size_t n, size_t size,\
int (*compare)(const void *, const void *));
在base[0]...base[n-1]之间查找与*key匹配的项。size指出每个元素占有的字节数。函数返回一个指向匹配项的指针，若不存在匹配则返回NULL。
函数指针compare指向的函数把关键字key和数组元素比较，比较函数的形式为：
int func_name(const void *arg1, const void *arg2);
arg1是key指针，arg2是数组元素指针。
返回值必须如下：
arg1 < arg2时，返回值<0；
arg1 == arg2时，返回值==0；
arg1 > arg2时，返回值>0。
数组base必须按升序排列(与compare函数定义的大小次序一致)。
 
5.19 qsort
void qsort(void *base, size_t n, size_t size, \
int (*compare)(const void *, const void *));
对由n个大小为size的对象构成的数组base进行升序排序。
比较函数compare的形式如下：
int func_name(const void *arg1, const voie *arg2);
其返回值必须如下所示：
arg1 < arg2，返回值<0；
arg1 == arg2，返回值==0；
arg1 > arg2，返回值>0。
 
5.20 abs
int abs(int num);
返回int变元num的绝对值。
 
5.21 labs
long labs(long int num);
返回long类型变元num的绝对值。
 
5.22 div
div_t div(int numerator, int denominator);
返回numerator/denominator的商和余数，结果分别保存在结构类型div_t的两个int成员quot和rem中。
 
5.23 ldiv
ldiv_t div(long int numerator, long int denominator);
返回numerator/denominator的商和余数，结果分别保存在结构类型ldiv_t的两个long成员quot和rem中。
 
 
6.iomanip库
dec 置基数为10 相当于"%d"
hex 置基数为16 相当于"%X"
oct 置基数为8 相当于"%o"
setfill( 'c' ) 设填充字符为c
setprecision( n ) 设显示小数精度为n位
setw( n ) 设域宽为n个字符
这个控制符的意思是保证输出宽度为n。如：
cout << setw( 3 ) << 1 << setw( 3 ) << 10 << setw( 3 ) << 100 << endl; 输出结果为
1 10100 （默认是右对齐）当输出长度大于3时(<<1000)，setw(3)不起作用。
▲setw(n)用法： 通俗地讲就是预设宽度
如 cout<<setw(5)<<255<<endl;
结果是:
(空格)(空格)255
▲setfill(char c) 用法 : 就是在预设宽度中如果已存在没用完的宽度大小，则用设置的字符c填充
如 cout<<setfill(‘@‘)<<setw(5)<<255<<endl;
结果是:
@@255
▲setbase(int n) : 将数字转换为 n 进制.
如 cout<<setbase(8)<<setw(5)<<255<<endl;
cout<<setbase(10)<<setw(5)<<255<<endl;
cout<<setbase(16)<<255<<endl;
结果是:
(空格)（空格)377
(空格)(空格) 255
(空格)(空格) f f
▲ setprecision用法
使用setprecision(n)可控制输出流显示浮点数的数字个数。C++默认的流输出数值有效位是6。
如果setprecision(n)与setiosflags(ios::fixed)合用，可以控制小数点右边的数字个数。setiosflags(ios::fixed)是用定点方式表示实数。
如果与setiosnags(ios::scientific)合用，可以控制指数表示法的小数位数。setiosflags(ios::scientific)是用指数方式表示实数。
setiosflags(ios::fixed) 固定的浮点显示
setiosflags(ios::scientific) 指数表示
setiosflags(ios::left) 左对齐
setiosflags(ios::right) 右对齐
setiosflags(ios::skipws) 忽略前导空白
setiosflags(ios::uppercase) 16进制数大写输出
setiosflags(ios::lowercase) 16进制小写输出
setiosflags(ios::showpoint) 强制显示小数点
setiosflags(ios::showpos) 强制显示符号
7.numeric库
accumulate（first ，last，n）求和，n为初始值；

adjacent_difference（first，last，result）求相邻元素的差，后减前，result为差的序列在原序列开始的位置

checked_ adjacent_difference(first,last,result)

inner_product(first1,first2,last1,last2)将对应元素相乘并求出累计和

partial_sum（first，last，result）求到任意位置的累计和，result为和的序列在原序列开始的位置

 

////////////////////////////////////////////////////////////////////////////////////////
 C++ STL algorithm部分用法(1) 收藏
(1) copy函数：MSDN中的定义是这样子的，参数_First是源数组(或集合)对象的起始指针(或迭代器)，参数_Last是源数组(或集合)对象的末尾指针(或迭代器)，参数_DestBeg是目标数组(或集合)对象的起始指针(或迭代器)。

template<class InputIterator, class OutputIterator>
   OutputIterator copy(
      InputIterator _First,
      InputIterator _Last,
      OutputIterator _DestBeg
   );
示例代码如下：

// alg_copy.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
   vector <int> v1, v2;
   vector <int>::iterator Iter1, Iter2;

   int i;
   for ( i = 0 ; i <= 5 ; i++ )
      v1.push_back( 10 * i );

   int ii;
   for ( ii = 0 ; ii <= 10 ; ii++ )
      v2.push_back( 3 * ii );

   cout << "v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   cout << "v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // To copy the first 3 elements of v1 into the middle of v2
   copy( v1.begin( ), v1.begin( ) + 3, v2.begin( ) + 4 );

   cout << "v2 with v1 insert = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // To shift the elements inserted into v2 two positions
   // to the left
   copy( v2.begin( )+4, v2.begin( ) + 7, v2.begin( ) + 2 );

   cout << "v2 with shifted insert = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;
}
(2)find函数：MSDN中的定义是这样子的，参数_First是数组(或集合)对象的起始指针(或迭代器)，参数_Last是数组(或集合)对象的末尾指针(或迭代器)，参数_Val是数组(或集合)对象要查找的值。

template<class InputIterator, class Type>
   InputIterator find(
      InputIterator _First,
      InputIterator _Last,
      const Type& _Val
   );
示例代码如下：

// alg_find.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>
using namespace std;
int main(){
  
   list <int> L;
   list <int>::iterator Iter;
   list <int>::iterator result;
  
   L.push_back( 40 );
   L.push_back( 20 );
   L.push_back( 10 );
   L.push_back( 30 );
   L.push_back( 10 );

   cout << "L = ( " ;
   for ( Iter = L.begin( ) ; Iter != L.end( ) ; Iter++ )
      cout << *Iter << " ";
   cout << ")" << endl;
  
   result = find( L.begin( ), L.end( ), 10 );
   if  ( result == L.end( ) )
      cout << "There is no 10 in list L.";
   else  {
      cout << "There is a 10 in list L";
      if ( ++result != L.end() )
         cout << " and it is followed by a " << *result << ".";
   }
   cout << endl;
}
(3)replace函数：MSDN中的定义是这样子的，参数_First是数组(或集合)对象的起始指针(或迭代器)，参数_Last是数组(或集合)对象的末尾指针(或迭代器)，参数_OldVal是数组(或集合)要被替代的原值，参数_NewVal是数组(或集合)替代的新值。

template<class ForwardIterator, class Type>
   void replace(
      ForwardIterator _First,
      ForwardIterator _Last,
      const Type& _OldVal,
      const Type& _NewVal
   );
示例代码如下：

// alg_replace.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main( ) {
  
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   for ( i = 0 ; i <= 9 ; i++ )
      v1.push_back( i );

   int ii;
   for ( ii = 0 ; ii <= 3 ; ii++ )
      v1.push_back( 7 );
  
   random_shuffle (v1.begin( ), v1.end( ) );
   cout << "The original vector v1 is:  ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Replace elements with a value of 7 with a value of 700
   replace (v1.begin( ), v1.end( ), 7 , 700);

   cout << "The vector v1 with a value 700 replacing that of 7 is:  ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;
}
(4)sort函数：MSDN中的定义是这样子的，参数_First是数组(或集合)对象的起始指针(或迭代器)，参数_Last是数组(或集合)对象的末尾指针(或迭代器)，指定了在一个范围内的值进行排序。

template<class RandomAccessIterator>
   void sort(
      RandomAccessIterator _First,
      RandomAccessIterator _Last
   );
示例代码如下：
// alg_sort.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // greater<int>( )函数所在的头文件
#include <iostream>
using namespace std;
// Return whether first element is greater than the second
bool UDgreater ( int elem1, int elem2 )
{
   return elem1 > elem2;
}

int main( )
{
  
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   for ( i = 0 ; i <= 5 ; i++ )
   {
      v1.push_back( 2 * i );
   }

   int ii;
   for ( ii = 0 ; ii <= 5 ; ii++ )
   {
      v1.push_back( 2 * ii + 1 );
   }

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   sort( v1.begin( ), v1.end( ) );
   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in descending order. specify binary predicate
   sort( v1.begin( ), v1.end( ), greater<int>( ) );
   cout << "Resorted (greater) vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // A user-defined (UD) binary predicate can also be used
   sort( v1.begin( ), v1.end( ), UDgreater );
   cout << "Resorted (UDgreater) vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}
(5)random_shuffle函数：MSDN中的定义是这样子的，参数_First是数组(或集合)对象的起始指针(或迭代器)，参数_Last是数组(或集合)对象的末尾指针(或迭代器)，指定了在一个范围内随机打乱数据排列顺序。

template<class RandomAccessIterator>
   void random_shuffle(
      RandomAccessIterator _First,
      RandomAccessIterator _Last
      );
示例代码如下：

// alg_random_shuffle.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

int main( ) ...{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1, Iter2;

   int i;
   for ( i = 1 ; i <= 9 ; i++ )
      v1.push_back( i );

   random_shuffle( v1.begin( ), v1.end( ) );
   cout << "The original version of vector v1 is: ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Shuffled once
   random_shuffle( v1.begin( ), v1.end( ));
   push_heap( v1.begin( ), v1.end( ) );
   cout << "Vector v1 after one shuffle is:       ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Shuffled again
   random_shuffle( v1.begin( ), v1.end( ));
   push_heap( v1.begin( ), v1.end( ) );
   cout << "Vector v1 after another shuffle is:   ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;
}
 

//////////////////////////////////////////////////////////////////////////

   VC++里的system("cls")是对系统的调用，效率太低了，而且clrscr()又不能用——一个高效的清屏方法，或者输出覆盖。 clrscr().这个是turbo C 中的库函数，包含在<conio.h>中

不过如果你是C++，那这个函数就用不了了，得自己写一个。

      许多人都问这个问题，因为在tc下是有conio.h里的clrscr()清屏函数的。但是在VC下，conio.h里没有clrscr()，只能用system("cls");  
  或者console功能调用，查MSDN就知道了。  
  可以写一个这样的函数：  
  inline   void   clrscr(void)  
  {  
  HANDLE   hStdOut=GetStdHandle(STD_OUTPUT_HANDLE);  
  MyCls(hStdOut);  
  return;  
  }  
  void   MyCls(HANDLE   hConsole)  
  {  
  COORD   coordScreen={0,0};//设置清屏后光标返回的屏幕左上角坐标  
  BOOL   bSuccess;  
  DWORD   cCharsWritten;  
  CONSOLE_SCREEN_BUFFER_INFO   csbi;//保存缓冲区信息  
   
  DWORD   dwConSize;//当前缓冲区可容纳的字符数  
   
  bSuccess=GetConsoleScreenBufferInfo(hConsole,&csbi);//获得缓冲区信息  
  PERR(bSuccess,"GetConsoleScreenBufferInfo");  
  dwConSize=csbi.dwSize.X   *   csbi.dwSize.Y;//缓冲区容纳字符数目  
   
  //用空格填充缓冲区  
  bSuccess=FillConsoleOutputCharacter(hConsole,(TCHAR)'   ',dwConSize,coordScreen,&cCharsWritten);  
  PERR(bSuccess,"FillConsoleOutputCharacter");  
   
  bSuccess=GetConsoleScreenBufferInfo(hConsole,&csbi);//获得缓冲区信息  
  PERR(bSuccess,"ConsoleScreenBufferInfo");  
   
  //填充缓冲区属性  
  bSuccess=FillConsoleOutputAttribute(hConsole,csbi.wAttributes,dwConSize,coordScreen,&cCharsWritten);  
  PERR(bSuccess,"FillConsoleOutputAttribute");  
   
  //光标返回屏幕左上角坐标  
  bSuccess=SetConsoleCursorPosition(hConsole,coordScreen);  
  PERR(bSuccess,"SetConsoleCursorPosition");  
  return;  
  }  

//////////////////////////////////////////////////////////////////////////////////////

 

STL sort常用用法归纳

1 STL提供的Sort 算法
//#include<algorithm>//快速排序sort()    (平均O(NlogN)
//稳定排序stable_sort() (最好O(NlogN)，最坏O(N(logN)^2) 用法与sort()相同//堆排序s
ort_heap()    (O(NlogN))
用法同sort()，要先make_heap()或push_heap()/************目录************
1.1
   所有sort算法介绍所有的sort算法的参数都需要输入一个范围，[begin,
end)。这里使用的迭代器(iterator)都需是随机迭代器(RadomAccessIterator),
也就是说可以随机访问的迭代器，如：it+n什么的。（partition 和stable_partition 除外）
如果你需要自己定义比较函数，你可以把你定义好的仿函数(functor)作为参数传入。每种算法都支持传入比较函数。以下是所有STL
sort算法函数的名字列表:
函数名 功能描述 sort 对给定区间所有元素进行排序 stable_sort 对给定区间所有元素进行稳定排序 partial_sort 对给定区间所有元素部分排序 partial_sort_copy 对给定区间复制并排序 nth_element 找出给定区间的某个位置对应的元素 is_sorted 判断一个区间是否已经排好序 partition 使得符合某个条件的元素放在前面 stable_partition 相对稳定的使得符合某个条件的元素放在前面 其中nth_element
是最不易理解的，实际上，这个函数是用来找出第几个。例如：找出包含7个元素的数组中排在中间那个数的值，此时，我可能不关心前面，也不关心后面，我只关心排在第四位的元素值是多少。
1.2
   sort 中的比较函数当你需要按照某种特定方式进行排序时，你需要给sort指定比较函数，否则程序会自动提供给你一个比较函数。

vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此时相当于调用
sort(vect.begin(), vect.end(), less<int>() );
上述例子中系统自己为sort提供了less仿函数。在STL中还提供了其他仿函数，以下是仿函数列表:

名称  功能描述
  equal_to 相等
 not_equal_to 不相等
 less 小于
 greater 大于
 less_equal 小于等于
 greater_equal 大于等于
 需要注意的是，这些函数不是都能适用于你的sort算法，如何选择，决定于你的应用。另外，不能直接写入仿函数的名字，而是要写其重载的()函数： less<int>()     greater<int>()
当你的容器中元素时一些标准类型（int float char)或者string时，你可以直接使用这些函数模板。但如果你时自己定义的类型或者你需要按照其他方式排序，你可以有两种方法来达到效果：一种是自己写比较函数。另一种是重载类型的'<'操作赋
#include<iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

class myclass {
        public:
              myclass(int a, int b):first(a), second(b){}
        bool operator < (const myclass &m)const {
                return first < m.first;
              }
        int first;
        int second;
};

bool less_second(const myclass & m1, const myclass & m2) {
        return m1.second < m2.second;
}

int main() {
             
              vector< myclass > vect;
        for(int i = 0 ; i < 10 ; i ++){
                      myclass my(10-i, i*3);
                      vect.push_back(my);
              }
        for(int i = 0 ; i < vect.size(); i ++)
              cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
              sort(vect.begin(), vect.end());
              cout<<"after sorted by first:"<<endl;
        for(int i = 0 ; i < vect.size(); i ++)
              cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
              cout<<"after sorted by second:"<<endl;
              sort(vect.begin(), vect.end(), less_second);
        for(int i = 0 ; i < vect.size(); i ++)
              cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
             
        return 0 ;
}
具体操作如下：
    用法一：内置类型的由小到大排序：使用默认比较函数(less<T>())sort(a,a+len); //a:数组名，len:数组长度=sizeof(arrray)/sizeof(*array)
    用法二:内置类型的由大到小排序：使用内置比较函数(greater<T>())sort(a,a+len,greater<int>()); //greater<Type>()包含在#include<functional>
    用法三:自定义类型对象数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)            bool myGreater(Type& a, Type& b){ return a>b;}sort(a,a+len,myGreater); //自定义类型对象数组的由大到小排序堆排序版本：bool myGreater(Type& a, Type& b){ return a>b;} make_heap(a,a+len,myGreater);sort_heap(a,a+len,myGreater); //参数必须完全一样!用法四:指针数组的由大到小排序：使用游离比较函数(myGreater(Type*, Type*)bool myGreater(int* a, int* b){ return *a>*b;}sort(p,p+len,myGreater); //指针数组的由大到小排序，适用于索引排序
 /**///***********例子************#include<iostream>#include<algorithm>#include<functional>using namespace std;//用法一：内置类型的由小到大排序：使用默认比较函数(less<T>())/*void main(){int a[]={3, 1,4,2,5};int len=sizeof(a)/sizeof(int);sort(a,a+len); //默认：内置类型的由小到大排序for (int i=0; i<len; i++)     cout<<a[i]<<'\t';cout<<endl;}/**///用法二:内置类型的由大到小排序：使用内置比较函数(greater<T>()) /*void main(){int a[]={3, 1,4,2,5};int len=sizeof(a)/sizeof(int);sort(a,a+len,greater<int>()); //内置类型的由大到小排序for (int i=0; i<len; i++)     cout<<a[i]<<'\t';cout<<endl; }/**///用法三:自定义类型对象数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)/*bool myGreater(int& a, int& b){ return a>b;}void main(){int a[]={3, 1,4,2,5};int len=sizeof(a)/sizeof(int); sort(a,a+len,myGreater); //自定义类型的由大到小排序for (int i=0; i<len; i++)     cout<<a[i]<<'\t';cout<<endl;}/**///sort_heap版本：bool myGreater(int& a, int& b){ return a>b;} void main(){int a[]={3, 1,4,2,5};int len=sizeof(a)/sizeof(int);make_heap(a,a+len,myGreater);sort_heap(a,a+len,myGreater); //自定义类型的由大到小排序for (int i=0; i<len; i++)     cout<<a[i]<<'\t'; cout<<endl;}/**///用法四:自定义类型指针数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)
  bool myGreater(int* a, int* b)
{ return *a>*b;}
void main()
{
int a[]={3, 1,4,2,5};
int* p[5];
for(int i=0;i<5;i++)
p[i]=&a[i];
 int len=sizeof(a)/sizeof(int);
sort(p,p+len,myGreater); //自定义类型的由大到小排序
for (i=0; i<len; i++)    
cout<<a[i]<<'\t';cout<<endl;for (i=0; i<len; i++)
     cout<<*p[i]<<'\t'; cout<<endl;
}

///////////////////////////////////////////////
/**********************************************************************
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
class student
{
public:
 string Name;
 double Score;
 student(string name,double score):Name(name),Score(score){}

};
void out(student stu)
{
 cout<<"Name:"<<stu.Name<<"\tScore:"<<stu.Score<<endl;
}
bool compare(const student&stu1,const student&stu2)
{
 return stu1.Score<stu2.Score;
}
bool find(student stu)
{
 return stu.Score==90;
}
int main()
{
 student s[]={student("赵",67),student("钱",23),student("孙",45),student("李",90),student("王",88)};
 vector<student>stu;
 for(int i=0;i<5;i++)
  stu.push_back(s[i]);
 vector<student>::iterator ptr;
 ptr=find_if(stu.begin(),stu.end(),find); 
 cout<<ptr->Name<<endl;
 for_each(stu.begin(),stu.end(),out);

 sort(stu.begin(),stu.end(),compare);

 for_each(stu.begin(),stu.end(),out);
 return 0;
}
****************************************************/
/****************************************************
#include<iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

class myclass {
public:
 myclass(int a, int b):first(a), second(b){}
 int first;
 int second;
 bool operator < (const myclass &m)const {
  return first < m.first;
 }
};

bool less_second(const myclass & m1, const myclass & m2) {
 return m1.second < m2.second;
}

int main() {

 vector< myclass > vect;
 for(int i = 0 ; i < 10 ; i ++){
  myclass my(10-i, i*3);
  vect.push_back(my);
 }
 for(int i = 0 ; i < vect.size(); i ++)
  cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
 sort(vect.begin(), vect.end());
 cout<<"after sorted by first:"<<endl;
 for(int i = 0 ; i < vect.size(); i ++)
  cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
 cout<<"after sorted by second:"<<endl;
 sort(vect.begin(), vect.end(), less_second);
 for(int i = 0 ; i < vect.size(); i ++)
  cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";

 return 0 ;
}
************************************************************/