转载地址：http://blog.csdn.net/kz_ang/article/details/7767335

<string>头文件

string构造函数

string s　　生成一个空字符串s
string s(str)　　拷贝构造函数,生成str对象的复制品
string s(str,stridx)　　将字符串str对象内"始于位置stridx"的部分当作字符串的初值
string s(str,stridx,strlen)　　将字符串str对象始于stridx且最长为strlen部分作为字符串的初值
string s(cstr)　　将C字符串作为s的初值
string s(chars,chars_len)　　将C字符串前chars_len个字符作为字符串s的初值
string s(num,c)　　生成一个字符串,包含num个c字符
string s(beg,end)　　以区间(迭代器iterator )beg到end(不包含end)内的字符作为字符串s的初值

string析构函数

s.~string()　　销毁所有字符，释放内存

赋值操作

重载=操作符

basic_string& operator=(const basic_string& rhs)
basic_string& operator=(const E *s)
basic_string& operator=(E c)

string对象= string对象 / 字符串("gaint") / 字符( ' j '）

assign()函数

s.assign(str)　　把str对象赋给s对象
s.assign(str,pos,n)　　把string 对象中从(下标)pos的后n个元素赋值给s
s.assign(str,pos,string::npos)　　把字符串str从索引值p开始到结尾赋给s
s.assign(char_string)　　把字符串赋值给s对象
s.assign(char_string,num)　　把字符串前num个字符'赋给s对象
s.assign(first,last)　　把(迭代器iterator )first和last之间的部分赋给字符串
s.assign(num,char_x)　　把num个字符赋给s对象

交字符对象内容

void swap(basic_string& str)　　把s与str对象的内容交换

尾部添加字符

重载+= 操作符

basic_string& operator+=(const basic_string& rhs)
basic_string& operator+=(const E *s)
basic_string& operator+=(E c)

string对象+= string对象 / 字符串("gaint") / 字符( ' j ')

append()函数

s.append(str)　　把str对象t添加到s对象末尾
s.append(str,pos,num)　　把string对象中从(下标)pos的后num个元素添加到s对象末尾
s.append(char_string)　　把字符串添加到s对象末尾
s.append(char_string.num)　　把字符串的前num个字符添加到s对象末尾
s.append(first,last)　　把(迭代器iterator )first到last中的元素添加到s末尾
s.append(num,char_x)　　把num个字符添加到s对象末尾

push_back()函数

s.push_back(char_x)　　把单个字符添加到s的尾部,这个函数只能增加单个字符

插入字符

insert()函数

basic_string& insert(size_type p0,const basic_string& str)
basic_string& insert(size_type p0,const basic_string& str, size_type pos, size_type n)
basic_string& insert(size_type p0,const E *s, size_type n)
basic_string& insert(size_type p0, const E *s)
basic_string& insert(size_type p0, size_type n, E c)
iterator insert(iterator it, E c)
void insert(iterator it, size_type n, E c)
void insert(iterator it,const_iterator first, const_iterator last)

删除字符 erase() 函数

basic_string& erase(size_type p0 = 0, size_type n = npos)
iterator erase(iterator it)
iterator erase(iterator first, iterator last)

转换为字符串数组

const E *c_str() const　　将内容以C_string返回,一个以'\0'结尾的字符数组

替换字符

s.replace(pos ,num , str )　　用str代替s中从pos开始的num个字符
s.replace(pos ,num , chars)　　用字符串代替s中从pos开始的num个字符
s.replace(pos1,num1,str,pos2, num2)　　用str中从pos2开始的num2个字符,代替s中从pos1开始的 num1个字符
s.replace(pos1,num1,chars, num2 )　　用字符串中num2个字符,代替s中从pos1开始的num1个字符
s. replace(pos,num,count,char)　　用count个字符,代替s中从 pos开始的num个字符
s.replace(First,Last,str )　　用 string 代替s中从(迭代器iterator)First到Last的字符
s.replace(First,Last,chars)　　用字符串代替s中从(迭代器iterator)First到Last的字符
s.replace(First0,Last0,chars, num )　　用字符串的num个字符，代替s中从(迭代器iterator )First到Last的字符
s.replace(First0,Last0,First,Last )　　用(迭代器iterator)First开始到Last的字符,代替s中从(迭代器iterator )First0到Last0的字符
s.replace(First,Last,count,char)　　用count个字符,代替s中从(迭代器iterator )First到Last的字符

比较字符串

==
!=
<
<=
>
>=

支持string与c_string的比较(如 str<"hello"),字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时，string ("aaaa") <string(aaaaa),compare()他支持多参数处理，支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果,返回值意义如下：0表相等 大于0表大于 小于0表小于

int compare(const basic_string& str) const;
int compare(size_type p0, size_type n0,const basic_string& str
int compare(size_type p0, size_type n0,const basic_string& str, size_type pos, size_type n)
int compare(size_type p0, size_type n0,const E *s) const
int compare(const E *s) const
int compare(size_type p0, size_type n0,const E *s, size_type pos) const

字符串长度

size_type size() const
size_type length() const

返回字符数量,他们等效

字符串最大个数

size_type max_size() const　　返回字符串的可能最大个数,C++字符串最多能包含的字符数,很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系

字符串是否为空

booempty() const　　判断字符串是否为空

重新指定字符数组长度

void resize(size_type n, E t = E())　　重新指定字符数组长度的长度为n,元素值为t

新分配之前字符容量

size_type capacity() const　　返回重新分配之前的字符容量

保留一定量内存以容纳一定数量的字符

void reserve(size_type n = 0)　　保留一定量内存以容纳一定数量的字符,这个函数为string重新分配内存,重新分配的大小由其参数决定,默认参数为0,这时候会对string进行非强制性缩减

存取单一字符

const_reference at(size_type pos) const
reference at(size_type pos)
const_reference operator[](size_type pos) const
reference operator[](size_type pos)

从stream读取某值

>>
getline()

从stream读取某值

将谋值写入stream

<<　　将谋值写入stream

复制string

size_type copy(E *s,size_type n, size_type pos = 0) const　　将某值赋值为一个C_string,把字符串的内容复制或写入既有的c_string或字符数组内

返回字符数组形式

const E *data() const　　将内容以字符数组形式返回,但并不添加’\0’

返回某个子字符串

basic_string substr(size_type pos = 0, size_type n = npos) const

搜索与查找

这些函数返回符合搜索条件的字符区间内的第一个字符的索引,没找到目标就返回npos.所有的函数的参数说明如下:第一个参数是被搜寻的对象.第二个参数（可有可无）指出string内的搜寻起点索引,第三个参数（可有可无）指出搜寻的字符个数

size_type find(const basic_string& str,size_type pos = 0) const
size_type find(const E *s, size_type pos, size_type n) const
size_type find(const E *s, size_type pos = 0) const
size_type find(E c, size_type pos = 0) const
size_type find(E c, size_type pos = 0) const
size_type rfind(const basic_string& str,size_type pos = npos) const
size_type rfind(const E *s, size_type pos,size_type n = npos) const
size_type rfind(const E *s, size_type pos = npos) const
size_type rfind(E c, size_type pos = npos) const
size_type find_first_of(const basic_string& str,size_type pos = 0) const
size_type find_first_of(const E *s, size_type pos,size_type n) const
size_type find_first_of(const E *s, size_type pos = 0) const
size_type find_first_of(E c, size_type pos = 0) const
size_type find_last_of(const basic_string& str,size_type pos = npos) const
size_type find_last_of(const E *s, size_type pos,size_type n = npos) const
size_type find_last_of(const E *s, size_type pos = npos) const
size_type find_last_of(E c, size_type pos = npos) const
size_type find_first_not_of(const basic_string& str,size_type pos = 0) const
size_type find_first_not_of(const E *s, size_type pos,size_type n) const
size_type find_first_not_of(const E *s, size_type pos = 0) const
size_type find_first_not_of(E c, size_type pos = 0) const
size_type find_last_not_of(const basic_string& str,size_type pos = npos) const
size_type find_last_not_of(const E *s, size_type pos,size_type n) const
size_type find_last_not_of(E c, size_type pos = npos) const
size_type find_last_not_of(const E *s,size_type pos = npos) const

迭代器

正向迭代器

• • iterator begin()
  • const_iterator begin() const
  • iterator end()
  • const_iterator end() const

返回配置器

• • A get_allocator() const

逆向迭代器

• • reverse_iterator rbegin()
  • const_reverse_iterator rbegin() const
  • reverse_iterator rend()
  • const_reverse_iterator rend() const

npos

string::npos　　string::npos的类型是string::size_type,所以，一旦需要把一个索引与npos相比，这个索引值必须是string::size_type类型的.是类的静态成员,更多的情况下，我们可以直接把函数和npos进行比较（如：if(s.find("jia")== string::npos)）

注意

• C++字符串并不以’\0’结尾。我的建议是在程序中能使用C++字符串就使用，除非万不得已不选用c_string
• 还有必要再重复一下C++字符串和C字符串转换的问题，许多人会遇到这样的问题，自己做的程序要调用别人的函数、类什么的（比如数据库连接函数Connect(char*,char*)），但别人的函数参 数用的是char*形式的，而我们知道，c_str()、data()返回的字符数组由该字符串拥有，所以是一种const char*,要想作为上面提及的函数的参数，还必须拷贝到一个char*,而我们的原则是能不使用C字符串就不使用。那么，这时候我们的处理方式是：如果 此函数对参数(也就是char*)的内容不修改的话，我们可以这样Connect((char*)UserID.c_str(), (char*)PassWD.c_str()),但是这时候是存在危险的，因为这样转换后的字符串其实是可以修改的（有兴趣地可以自己试一试），所以我强调除非函数调用的时候不对参数进行修改，否则必须拷贝到一个char*上去。当然，更稳妥的办法是无论什么情况都拷贝到一个char*上去。同时我们也祈 祷现在仍然使用C字符串进行编程的高手们写的函数都比较规范，那样 我们就不必进行强制转换了
• 我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。而at()会检查，如果使用 at()的时候索引无效，会抛出out_of_range异常

<cstdlib>头文件

字符串转整形

• 形式: char *_itoa( int value, char *string, int radix );
• 参数:
  • value 表示需要被转换的整形值
  • string 表示转换后字符串被存放的地址
  • radix 表示被转换成几进制

字符串转成 double 型

• 形式: double atof( const char *string );
• 参数: string 表示需要被转换的字符串

字符串转成 int 型

• 形式: int atoi( const char *string );
• 参数: string 表示需要被转换的字符串

字符串转成 long 型

• 形式: long atol( const char *string );
• 参数: string 表示需要被转换的字符串

malloc函数

• 形式: void *malloc( size_t size );
• 参数: size 为新开辟时候需要的内存区大小
• 注意:
  • malloc 返回值是 void 所以必须有强制转换类型 (typename*)malloc
  • LEN 为开辟空间的长度,如果为单个变量可用sizeof(typename) 函数返回一个 typename 类型变量内存空间需要的长度.如果是数组的话其中元素个数为 N 其内存空间需要的长度为 N*sizeof(typename)
    [cpp] view plaincopy

    print?

    1. int *p=(int*)malloc(sizeof(int));//p为新开辟的整形变量的指针  
  • 由于 point_name 为地址，malloc 动态生成的结构体无名称，不能用 *point_name. 成员名 来访问成员，但由于 () 优先级高，所以可以用 (*point_name).成员名 来访问
  • malloc 不会初始化开辟空间里面的内容,所以用 malloc 开辟空间的元素在没有初始化前使用结果是未知的
• 作用: 为变量开辟存储空间

free函数

• 形式: void free( void *memblock );
• 参数: memblock 用 malloc 或者 realloc 开辟空间的指针
• 注意:
  • 用 malloc 生成的变量/结构体/数组用 free 函数来释放内存
  • free 释放的都是malloc指针指向的内存,而不会删掉指针本身
  • 对空指针应用 free 是安全的
  • 不能用 sizeof 操作符来确定动态分配数组包含的字节数
• 作用: 释放由 malloc,realloc 或者 calloc 开辟的变量空间

realloc函数

• 形式: void *realloc( void *memblock, size_t size );
• 参数:
  • memblock 为原来有 malloc 开辟空间的指针
  • size 为新开辟时候需要的新的内存区大小,要比 malloc 的大才行
• 注意:
  • realloc 返回值是 void 所以必须有强制转换类型 (*typename)realloc
  • LEN 为开辟空间的长度,如果为单个变量可用 sizeof(typename) 函数返回一个 typename 类型变量内存空间需要的长度.如果是数组的话其中元素个数为N其内存空间需要的长度为 N*sizeof(typename)

#include<iostream>  
#include <cstdlib>  
using namespace std;  
void main()  
{  int *p=(int*)malloc(sizeof(int));  *p = 5;  cout<<"用 malloc 开辟变量空间 :"<<endl;  cout<<"指针 p 指向的地址"<<p<<endl;  cout<<"指针 p 指向的地址里面的变量值"<<*p<<endl;  p =(int*) realloc((void*)p,2*sizeof(int));  *(p+1) = 6;  cout<<"用 realloc 重新开辟变量空间 :"<<endl;  cout<<"指针 p 指向的地址"<<p<<endl;  cout<<"指针 p 指向的地址里面的变量值"<<*p<<endl;  cout<<"指针 p+1 指向的地址"<<(p+1)<<endl;  cout<<"指针 p+1 指向的地址里面的变量值"<<*(p+1)<<endl;  system("pause");  
}  

用 malloc 开辟变量空间 :
指针 p 指向的地址003B5410
指针 p 指向的地址里面的变量值5
用 realloc 重新开辟变量空间 :
指针 p 指向的地址003B5410
指针 p 指向的地址里面的变量值5
指针 p+1 指向的地址003B5414
指针 p+1 指向的地址里面的变量值6
请按任意键继续. . .

宏与类型定义

_INTSIZEOF宏

宏定义:

_ADDRESSOF

宏定义:

va_start宏

宏定义:

作用: 使 va_list 指向起始的参数
参数:

• ap 为 va_list 类型的变量
• v 函数的第一个固定参数

va_arg宏

宏定义: 

作用: 检索参数,每次提取一次可变参数,arg 就向上移动一次.无论它现在指向的是不是参数它都会读取arg参数里存放地址里的内容
参数:

• ap 为 va_list 类型的变量
• t 为回传的型态

va_end宏

宏定义:

作用: 释放 va_list
参数: ap 为 va_list 类型的变量

va_list类型

定义:

对于函数

形式:

• type va_arg( va_list arg_ptr, type );
• void va_end( va_list arg_ptr );
• void va_start( va_list arg_ptr ); (UNIX version)
• void va_start( va_list arg_ptr, prev_param ); (ANSI version)

参数解释:

• type: Type of argument to be retrieved
• arg_ptr: Pointer to list of arguments
• prev_param: Parameter

使用可变参数

使用可变参数的下步骤

• 首先在函数里定义一个 va_list 型的变量,这里是 arg_ptr,这个变量是指向参数的指针.
• 然后用 va_start 宏初始化变量 arg_ptr,这个宏的第二个参数是第一个可变参数的前一个参数,是一个固定的参数.
• 然后用 va_arg 返回可变的参数,并赋值给整数 j. va_arg的第二个 参数是你要返回的参数 的类型,这里是 int 型.
• 最后用 va_end 宏结束可变参数的获取.然后你就可以在函数里使用第二个参数了.如果函数有多个可变参数的,依次调用 va_arg 获取各个参数

C 语言的函数是从右向左压入堆栈的,下图是函数的参数在堆栈中的分布位置:

例子

输出所有int型态的参数，直到-1结束:

输出结果:

5 2 14 84 97 15 24 48
84 51
 
1
请按任意键继续. . .

用可变参数第一参数为参数的长度说明:

 输出结果:

name :王一,age=12
name :李二,age=5
name :赵三,age=58
请按任意键继续. . .

若把上例子中的函数调用由 output(3,"王一",12,"李二",5,"赵三",58); 改为output(3,"王一",12,"李二",5); 时候输出结果变成了这样(在参数后面还有跟着一些函数的相关信息):

name :王一,age=12
name :李二,age=5
name :兡 ?0@,age=1
请按任意键继续. . .

若把上例子中的函数调用由 output(3,"王一",12,"李二",5,"赵三",58); 改为output(3,"王一",12,"李二"); 时候输出结果变成了这样(错误说明:读取的地址无效,.va_arg 提取地址发生错误):

<ctime>头文件

“时间”和“日期”的概念 

Coordinated Universal Time(UTC):

协调世界时,又称为世界标准时间,也就是大家所熟知的格林威治标准时间（Greenwich Mean Time,GMT）.比如,中国内地的时间与UTC的时差为+8,也就是UTC+8.美国是UTC-5

Calendar Time:

日历时间:是用“从一个标准时间点到此时的时间经过的秒数”来表示的时间.这个标准时间点对不同的编译器来说会有所不同,但对一个编译系统来说,这个标准时间点是不变的,该编译系统中的时间对应的日历时间都通过该标准时间点来衡量,所以可以说日历时间是“相对时间”,但是无论你在哪一个
时区,在同一时刻对同一个标准时间点来说,日历时间都是一样的.epoch：时间点时间点在标准C/C++中是一个整数,它用此时的时间和标准时间点相差的秒
数（即日历时间）来表示

clock tick:

时钟计时单元（而不把它叫做时钟滴答次数),一个时钟计时单元的时间长短是由 CPU 控制的.一个 clock tick 不是C PU 的一个时钟周期,而是C/C++的一个基本计时单位.

重要的宏

CLOCKS_PER_SEC

说明:每秒钟的滴答数
定义:

#define CLOCKS_PER_SEC ((clock_t) 000) 

用途:它用来表示一秒钟会有多少个时钟计时单元

clock_t

说明:滴答计数类型
定义:

注意:其中clock_t是用来保存时间的数据类型

time_t

说明:日历时间的秒计数

定义:

注意:对time_t数据类型的值来说,它所表示的时间不能晚于2038年 月 8日 9时 4分07秒. 

重要数据类型

struct tm

说明:年月日等得细分时间数据结构

函数

clock 函数

• 原型:clock_t clock( void );
• 作用:返回本程序自启动来,流逝的时钟计时单元.

difftime 函数

• 原型:double difftime( time_t timer ,time_t timer0 );
• 作用:返回两个日历时间之差timer -timer0;

time 函数

• 原型:time_t time( time_t *timer );
• 作用:获取机子的时间
• 注意:如果,timer不为空,则同时将返回值赋给timer指向的变量.

mktime 函数

• 原型:time_t mktime(struct tm *timeptr );
• 作用:将由年月日时分秒等构成的细分时间转换为流逝秒数构成的日历时间.

localtime 函数

• 原型:struct tm *localtime(const time_t *timer);
• 作用:将日历时间转换为本地细分时间

gmtime函数

• 原型:struct tm *gmtime( const time_t *timer);
• 作用:将日历时间转换为UTC（世界协调时间）的细分时间
• 注意:localtime与gmtime,前者比后者多8个小时

asctime函数

• 原型:char *asctime( const struct tm *timeptr );
• 作用:将细分时间转换为简写字符串

ctime函数

• 原型:char *ctime( const time_t *timer );
• 作用:将日历时间转换为简写字符串

strftime函数

• 原型:size_t strftime(char *strDest, size_t maxsize, const char *format, const struct tm *timeptr );
• 作用:将细分时间按format的格式要求格式化到strDest指向的缓冲区

函数strftime()的操作有些类似于sprintf()：识别以百分号(%)开始的格式命令集合,格式化输出结果放在一个字符串中.格式化命令说明串strDest中各种日期和时间信息的确切表示方法.格式串中的其他字符原样放进串中.格式命令列在下面,它们是区分大小写的.

• %a 星期几的简写
• %A 星期几的全称
• %b 月分的简写
• %B 月份的全称
• %c 标准的日期的时间串
• %C 年份的后两位数字
• %d 十进制表示的每月的第几天
• %D 月/天/年
• %e 在两字符域中,十进制表示的每月的第几天
• %F 年-月-日
• %g 年份的后两位数字,使用基于周的年
• %G 年分,使用基于周的年
• %h 简写的月份名
• %H 24小时制的小时
• %I 2小时制的小时
• %j 十进制表示的每年的第几天
• %m 十进制表示的月份
• %M 十时制表示的分钟数
• %n 新行符
• %p 本地的AM或PM的等价显示
• %r 2小时的时间
• %R 显示小时和分钟：hh:mm %S 十进制的秒数
• %t 水平制表符 %T 显示时分秒：hh:mm:ss
• %u 每周的第几天,星期一为第一天 （值从0到6,星期一为0）
• %U 第年的第几周,把星期日做为第一天（值从0到53）
• %V 每年的第几周,使用基于周的年
• %w 十进制表示的星期几（值从0到6,星期天为0）
• %W 每年的第几周,把星期一做为第一天（值从0到53）
• %x 标准的日期串
• %X 标准的时间串
• %y 不带世纪的十进制年份（值从0到99）
• %Y 带世纪部分的十制年份
• %z,%Z 时区名称,如果不能得到时区名称则返回空字符.%% 百分号

<ctype>头文件

函数 isalpha

• 原型: int isalpha(int ch);
• 返回值: 检查 ch 是否是字母.
• 返回值: 是字母返回非 0 ,否则返回 0　

函数 iscntrl

• 原型: int iscntrl(int ch);
• 返回值: 检查 ch 是否控制字符(其 ASCII 码在 0x00 到 0x1F 之间).
• 返回值: 是返回非 0,否则返回 0.

函数 isdigit

• 原型: int isdigit(int ch);
• 返回值: 检查 ch 是否是数字( 0-9 )
• 返回值: 是返回非 0,否则返回 0

函数 isgraph

• 原型: int isgraph(int ch);
• 返回值: 检查 ch 是否可显示字符(其 ASCII 码在 0x21 到 0x7E 之间),不包括空格
• 返回值: 是返回非 0,否则返回 0

函数 islower

• 原型: int islower(int ch);
• 返回值: 检查 ch 是否小写字母(a-z)
• 返回值: 是返回非 0,否则返回 0　　

函数 tolower

• 原型: int tolower(int ch);
• 返回值: 将 ch 字符转换为小写字母
• 返回值: 返回 ch 所代表的字符的小写字母　　

函数 toupper

• 原型: int toupper(int ch);
• 返回值: 将 ch 字符转换成大写字母
• 返回值: 与 ch 相应的大写字母　　　

函数 isalnum

• 原型: int isalnum(int ch);
• 返回值: 检查 ch 是否是字母或数字
• 返回值: 是字母或数字返回 1,否则返回 0　

函数 isprint

• 原型: int isprint(int ch);
• 返回值: 检查 ch 是否可打印字符(包括空格),其 ASCII 码在 0x20 到 0x7E 之间
• 返回值: 是返回非 0,否则返回 0　　

函数 ispunct

• 原型: int ispunct(int ch);
• 返回值: 检查 ch 是否是标点字符(不包括空格),即除字母,数字和空格以外的所有可打印字符
• 返回值: 是返回非 0,否则返回 0　　

函数 isspace

• 原型: int isspace(int ch);
• 返回值: 检查ch是否是空格符和跳格符(控制字符)或换行符
• 返回值: 是返回非 0,否则返回 0　

函数 isupper

• 原型: int isupper(int ch);
• 返回值: 检查ch是否是大写字母(A-Z)
• 返回值: 是返回非 0,否则返回 0

函数 isxdigit

• 原型: int isxdigit(int ch);
• 返回值: 检查 ch 是否是一个 16 进制数学字符(即 0-9,或 A-F,或 a-f)
• 返回值: 是返回非 0,否则返回 0

函数 isascii

• 原型: int isascii(int ch);
• 返回值: 测试参数是否是 ASCII 码 0-127
• 返回值: 是返回非 0,否则返回 0

函数 strcpy

• 原型: char* strcpy (char *s1, const char *s2);
• 作用: 将字符串 2 复制到字符数组 1 当中去
• 说明:
  • 字符数组 1 的长度应不小于字符串2的长度
  • "字符数组 1" 必须写成数组名形式,"字符串 2" 可以为字符数组名,也可以是一个字符串常量
  • 在未对字符数组 1 赋初值时,复制时将 "字符串 2" 中的字符串和其后的 "/0" 一起复制到字符数组 1 中,取代其前 n+1 个字符,而后面的字符是 "字符数组 1" 原字符

函数 strncpy

• 原型: char* strncpy (char *s1, const char *s2, size_t len);
• 作用: 将 s2 的前 len 个字符复制到 s1 中指定的地址, 不加 '\0'

函数 memcpy 

• 原型: void* memcpy (void *s1, const void *s2, size_t len);
• 作用: 将 s2 的前 len 个字节复制到 s1 中指定的地址, 不加 '\0'
• 说明: 源和目的不能是同一块内存区域

函数 memmove 

• 原型: void* memmove (void *s1, const void *s2, size_t len);
• 作用: 当源单元和目的单元缓冲区交迭时使用
• 说明: 源和目的可以是同一块内存区域(例如数组某个元素在数组存储器内部移动数据)

函数 strxfrm

• 原型: size_t strxfrm (char *s1, const char *s1, size_t len);
• 作用: 根据程序当前的区域选项,将 s2 的前 len 个字符(字节)复制到 s1 中指定的地址, 不加 '\0'

函数 strcat 

• 原型: char* strcat (char *s1, const char *s2);
• 作用: 把字符串 2 接到字符串 1 后面（字符串 1 要足够大）
• 说明: 连接前两个字符串都有 "/0" ,连接时将字符串1后 "/0" 丢弃,只在新字符串后保留 '/0'

函数 strncat 

• 原型:char* strncat (char *s1, const char *s2, size_t len);
• 作用: 将字符串 s2 的前 len 个字符连接到 s1 尾部, 不加 '\0'

函数 strcmp 

• 原型: int strcmp (const char *s1, const char *s2); ①作用：比较字符串1与字符串2
• 规律: 两个字符串自左至右逐个字符相比(按 ASCII 码值大小比较)直到出现不同的字符或者遇到 "/0" 为止,如果全部字符相同,则认为相等,若出现不同字符,则以第一个不相同的字符为准
• 准则:
  • 如果字符串 1=字符串 2，函数返回值为 0
  • 如果字符串 1>字符串 2，函数返回值为正数
  • 如果字符串1<字符串 2，函数返回值为负数

函数 strncmp

• 原型: int strncmp (const char *s1, const char *s2, size_t len);
• 作用: 对 s1 和 s2 的前len个字符作比较

函数 memcmp

• 原型: int memcmp (const void *s1, const void *s2, size_t len);
• 作用: 对 s1 和 s2 的前 len 个字节作比较

函数 strcoll

• 原型: int strcoll (const char *s1, const char *s2);
• 作用: 根据程序当前的区域选项中的 LC_COLLATE, 比较字符串 s1 和 s2

函数 strchr

• 原型: char* strchr (const char *s, int ch);
• 作用: 在 s 中查找给定字符 ch 第一次出现的位置

函数 memchr

• 原型: void* memchr (const void *s, int ch, size_t len);
• 作用: 查找在字符串中最后一次出现字符 ’ch’ 的位置。如果 s 中存在字符 ch，返回出现 ch 的位置的指针；否则返回NULL。

函数 strrchr

• 原型: char* strrchr (const char *s, int ch);
• 作用: 在串 s 中查找给定字符 ch 最后一次出现的位置, r表示从串尾开始

函数 strstr

• 原型: char* strstr (const char *s1, const char *s2);
• 作用: 在串 s1 中查找指定字符串 s2 第一次出现的位置

函数 strspn

• 原型: size_t strspn (const char *s1, const char *s2);
• 作用: 返回一个长度，这个长度是在 s1 中没有出现 s2 任意字符的从 s1 头计算的字符串的长度。

函数 strcspn

• 原型: size_t strcspn (const char *s1, const char *s2);
• 作用: 返回一个长度，这个长度是在 s1 中没有出现 s2 任意字符的从 s1 头计算的字符串的长度。

函数 strpbrk

• 原型: char* strpbrk (const char *s1, const char *s2);
• 作用: 与 strcspn 类似, 区别是返回指针而不是索引

函数 strtok

• 原型: char* strtok (char *s1, const char *s2);
• 函数执行步骤:
  • 从串s1中分离出由串 s2 中指定的分界符分隔开的记号(token)
  • 第一次调用时 s1 为需分割的字串, 此后每次调用都将 s1 置为 NULL,
  • 每次调用 strtok 返回一个记号, 直到返回 NULL 为止
• 作用: 分解字符串为一组字符串。s 为要分解的字符串，delim 为分隔符字符串。实质上的处理是，strtok 在 s 中查找包含在 delim 中的字符并用 NULL(’\0′) 来替换,直到找遍整个字符串。
• 返回值: 从 s 开头开始的一个个被分割的串。当没有被分割的串时则返回 NULL。所有 delim 中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

函数 strlen

• 原型: size_t strlen (const char *s);
• 作用: 它是测试字符串长度的函数，函数的值为字符串中的实际长度(不包括 "/0")

函数 memset

• 原型: void* memset (void *s, int val, size_t len);
• 作用: 将从 s 开始的 len 个字节置为 val

函数 strerror

• 原型: char* strerror (int errno);
• 作用: 返回指向错误信息字符串的指针

函数 _strlwr

• 原型: char *_strlwr( char *string );
• 作用: 把字符串中的大写字母换成小写字母

函数 _strupr

• 原型: char *_strupr( char *string );
• 作用: 把字符串中的小写字母换成大写字母