C++语言篇 第六章 字符数组及函数（不能用在string字符串中）

字符数组

 

数组中的每个元素都是一个字符的数组称为“字符数组”。有时，把一维字符数组又称为“字符串”。定义字符数组的方法与定义其他类型数组的方法类似。

对于字符数组的定义“char s[10] = {'H'，'e'，'l'，'l'，'o'}；”其在计算机内部的存储方式如下：

 

 

也就是说，字符串的末尾都会有一个空字符'\0'。

 

 

字符数组赋值方法

用字符常量逐个初始化：char letter［5］={'a'，'e'，'i'，'o'，'u'}；

用赋值语句逐个元素赋值：letter［0］='a'；…

用 scanf 读入整个数组：scanf （"%s"，letter）；

用 scanf 逐个元素读入：scanf （"%c"，&letter［0］）；…

用 cin 输入整个数组：cin >> letter；

用 cin 逐个元素输入：cin >> letter［0］；…

用 gets 读入整个数组：gets（letter）；

用 getchar 逐个读入：letter［0］=getchar（）；…

 

 

字符数组输出方法

 

用 cout 输出整个数组：cout >> letter；

用 cout 逐个元素输出：cout >> letter［0］；…

用 printf 输出整个数组：printf （"%s"，letter）；

用 printf 逐个元素输出：printf （"%c"，letter［0］）；…

用 puts 输出整个数组：puts（letter）；

用 putchar 逐个元素输出：putchar（letter［0］）；…

 

例1、阅读以下程序，体会各种字符串输入输出方式的区别。

#include <bits/stdc++.h>
using namespace std;
int main()
{   char s1[20],s2[20];
    scanf( " %s " ,s1);
    scanf( " %s "  ,s2);
    printf( " %s " ,s1);
    printf( " %s\n " ,s2);
    return 0;
}

【问题分析】

scanf 函数读取一个字符串时，是把 回车符、空格符、Tab 符作为字符串的结束符号 。所以，输入“Hello world!”，第一个 scanf 语句只会读取“Hello”，而第二个 scanf 语句会接着读入“world!”。另外cin也是把 回车符、空格符、Tab 符作为字符串的结束符号 。

 

输入“Hello world!”。

输出为：

Hello

world!

 

 

     如果程序改为用 gets 输入、puts 输出：

#include <bits/stdc++.h>
using namespace std;
int main()
{   char s1[20],s2[20];
    gets(s1);
    gets(s2);
    puts(s1);
    puts(s2);
    return 0;
}

输入：

Hello world!

Test2

则输出为：

Hello world!

Test2

 

注意：gets()接受空格，不接受回车。所以Hello   World!可以整体输入给s1。

 

如果程序改为用 getchar 输入、putchar 输出：

 

#include <bits/stdc++.h>
using namespace std;
int main()
{   char s1[20],s2[20],i;
    i = 0;
    while((s1[i] = getchar()) != '\n' ) i++;
    s1[i] ='\0 ';
    i = 0;
    while(s1[i++] !=' \0 ' )  putchar(s1[i]);
    putchar( ' \n ' );
    i = 0;
    while((s2[i] = getchar()) != ' \n ' ) i++;
    s2[i] = '\0 ';
    i = 0;
    while(s2[i++] != ' \0 ' )
          putchar(s2[i]); 
    putchar( '\n ' );
    return 0;
}

 

 

字符数组函数

一、字符及字符串的大小写转换
1. tolower（将单个大写字母转换成单个小写字母） 
2. toupper()（将单个小写字母转换成单个大写字母）  
3.strlwr（将字符串中的大写字符转化为小写的函数）
4.strupr（将字符串中的小写字符转化为大写的函数）

二、字符串转换为数字
1. atof（） （将字符串转换成浮点型数）  
2. atoi（）（将字符串转换成整型数）
3. atol()（将字符串转换成长整型数）
4. strtod()（将字符串转换成浮点数） 
5. strtol()（将字符串转换成长整型数） 
6. strtoul()（将字符串转换成无符号长整型数）

三、数字转换为字符串
1. gcvt()（将浮点型数转换为字符串，取四舍五入） 
2. sprintf()（其它数据类型转换为字符串） 
3. toascii()（将整型数转换成合法的ASCII 码字符）

四.字符串的比较与查找
1. memcmp( )(比较内存内容）
2. strcmp()与strncmp()（比较字符串）
3. strcasecmp()（忽略大小写比较字符串）
4. strchr()（查找字符串中第一个出现的指定字符）
6. strrchr()（查找字符串中最后出现的指定字符）
7. strspn()（返回字符串中连续不含指定字符串内容的字符数）
8 strstr()（在一字符串中查找指定的字符串）
9. strtok()（分割字符串）
10. strlen()（返回字符串长度）

五、字符串的拷贝
1 .memcpy()（拷贝内存内容）
2.strcpy（拷贝字符串）
3.strncpy（拷贝字符串）
4. memset（将一段内存空间填入某值）
5.strcat（连接两字符串）
6.strncat（连接两字符串）

一、字符及字符串的大小写转换

1. tolower（将单个大写字母转换成单个小写字母）  

相关函数   isalpha，toupper

表头文件   #include<stdlib.h>

定义函数   int tolower(int c);

函数说明   若参数c为大写字母则将该对应的小写字母返回。

返回值   返回转换后的小写字母，若不须转换则将参数c值返回。

附加说明  

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{  char s[]="aBcDeFgH12345;!#$";
   int i;
   printf("before tolower() : %s\n",s);
   for(i=0;i<sizeof(s);i++)
   s[i]=tolower(s[i]);
   printf("after tolower()  : %s\n",s);
}

运行结果：

before tolower() : aBcDeFgH12345;!#$

after tolower() 　: abcdefgh12345;!#$

 

2. toupper()（将单个小写字母转换成单个大写字母）  

相关函数   isalpha，tolower

表头文件   #include<ctype.h>

定义函数   int toupper(int c);

函数说明   若参数c为小写字母则将该对映的大写字母返回。

返回值   返回转换后的大写字母，若不须转换则将参数c值返回。

附加说明  

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{ char s[]="aBcDeFgH12345;!#$";
  int i;
  printf("before toupper() : %s\n",s);
  for(i=0;i<sizeof(s);i++)
  　　s[i]=toupper(s[i]);
  printf("after toupper() : %s\n",s);
}

运行结果：

before toupper() : aBcDeFgH12345;!#$

after toupper() : ABCDEFGH12345;!#$

 

3.strlwr（将字符串中的大写字符转化为小写的函数）

一般形式：strlwr（字符串）

作用：将字符串中的大写字母转化为小写。

#include<bits/stdc++.h>
using namespace std;
int main()
{  char s[]="aBcDeFgH12345;!#$";
   int i;
   printf("before tolower() : %s\n",s);
   strlwr(s);
   printf("after tolower()  : %s\n",s);
}

运行结果：

before tolower() : aBcDeFgH12345;!#$

after tolower() 　: abcdefgh12345;!#$

 

4.strupr（将字符串中的小写字符转化为大写的函数）

一般形式：strupr（字符串）

作用：将字符串中的小写字母转化为大写字母。

#include<bits/stdc++.h>
using namespace std;
int main()
{  char s[]="aBcDeFgH12345;!#$";
   int i;
   printf("before tolower() : %s\n",s);
   strupr(s);
   printf("after tolower()  : %s\n",s);
}

运行结果：

before toupper() : aBcDeFgH12345;!#$

after toupper() : ABCDEFGH12345;!#$

 

二、字符串转换为数字

1. atof（） （将字符串转换成浮点数）  

相关函数   atoi，atol，strtod，strtol，strtoul

表头文件   #include <stdlib.h>

定义函数   double atof(const char *nptr);

函数说明   atof()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。参数nptr字符串可包含正负号、小数点或E(e)来表示指数部分，如123.456或123e-2。

返回值   返回转换后的浮点型数。

附加说明   atof()与使用strtod(nptr,(char**)NULL)结果相同。

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{  char a[]="  -100.23  43";
   char b[]="200e-2";
   float c1,c2,c3;
   c1=atof(a);
   printf("c1=%.2f\n",c1);
   c2=atof(b);
   printf("c2=%.2f\n",c2);
   c3=atof(a)+atof(b);      
   printf("c3=%.2f\n",c3);
}

运行结果：

c1= -100.23

c2= 2.00

c3=-98.23

 

2. atoi（）（将字符串转换成整型数）  

相关函数   atof，atol，atrtod，strtol，strtoul

表头文件   #include<stdlib.h>

定义函数   int atoi(const char *nptr);

函数说明   atoi()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。

返回值   返回转换后的整型数。

附加说明   atoi()与使用strtol(nptr，(char**)NULL，10)；结果相同。

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{  char a[]="  -100.23  43";
   char b[]="200e-2";
   int c1,c2,c3;
   c1=atoi(a);
   printf("c1=%d\n",c1);
   c2=atoi(b);
   printf("c2=%d\n",c2);
   c3=atoi(a)+atof(b);      
   printf("c3=%d\n",c3);
}

运行结果：

c1= -100

c2= 200

c3=-98

 

3. atol()（将字符串转换成长整型数）  

相关函数   atof，atoi，strtod，strtol，strtoul

表头文件   #include<stdlib.h>

定义函数   long atol(const char *nptr);

函数说明   atol()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。

返回值   返回转换后的长整型数。

附加说明   atol()与使用strtol(nptr,(char**)NULL,10)；结果相同。

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{ char a[]="1000000000";
  char b[]="234567890";
  long c;
  c=atol(a)+atol(b);
  printf("c=%d\n",c);
}

运行结果：

c=1234567890

4. strtod()（将字符串转换成浮点数）  

相关函数   atoi，atol，strtod，strtol，strtoul

表头文件   #include<stdlib.h>

定义函数   double strtod(const char *nptr,char **endptr);

函数说明   strtod()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，到出现非数字或字符串结束时('\0')才结束转换，并将结果返回。若endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr传回。参数nptr字符串可包含正负号、小数点或E(e)来表示指数部分。如123.456或123e-2。

返回值   返回转换后的浮点型数。

附加说明   参考atof()。

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{   char *endptr;
    char a[] = "12345.6789";
    char b[] = "1234.567qwer";
    char c[] = "-232.23e4";
    printf( "a=%lf\n", strtod(a,NULL) );
    printf( "b=%lf\n", strtod(b,&endptr) );
    printf( "endptr=%s\n", endptr );
    printf( "c=%lf\n", strtod(c,NULL) );
}

运行结果：

a=12345.678900
b=1234.567000
endptr=qwer
c=-2322300.000000

5. strtol()（将字符串转换成长整型数）  

相关函数   atof，atoi，atol，strtod，strtoul

表头文件   #include<stdlib.h>

定义函数   long int strtol(const char *nptr,char **endptr,int base);

函数说明   strtol()会将参数nptr字符串根据参数base来转换成长整型数。参数base范围从2至36，或0。参数base代表采用的进制方式，如base值为10则采用10进制，若base值为16则采用16进制等。当base值为0时则是采用10进制做转换，但遇到如'0x'前置字符则会使用16进制做转换。一开始strtol()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('\0')结束转换，并将结果返回。若参数endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr返回。

返回值   返回转换后的长整型数，否则返回ERANGE并将错误代码存入errno中。

附加说明   ERANGE指定的转换字符串超出合法范围。

范例  

#include<bits/stdc++.h>
using namespace std;
int main()
{ char a[]="100";
  char b[]="100";
  char c[]="ffff";
  printf("a=%d\n",strtol(a,NULL,10));
  printf("b=%d\n",strtol(b,NULL,2));
  printf("c=%d\n",strtol(c,NULL,16));
}

运行结果：

a=100

b=４

c=65535

6. strtoul()（将字符串转换成无符号长整型数）  

相关函数   atof，atoi，atol，strtod，strtol

表头文件   #include<stdlib.h>

定义函数   unsigned long int strtoul(const char *nptr,char **endptr,int base);

函数说明   strtoul()会将参数nptr字符串根据参数base来转换成无符号的长整型数。参数base范围从2至36，或0。参数base代表采用的进制方式，如base值为10则采用10进制，若base值为16则采用16进制数等。当base值为0时则是采用10进制做转换，但遇到如'0x'前置字符则会使用16进制做转换。一开始strtoul()会扫描参数nptr字符串，跳过前面的空格字符串，直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('\0')结束转换，并将结果返回。若参数endptr不为NULL，则会将遇到不合条件而终止的nptr中的字符指针由endptr返回。

返回值   返回转换后的长整型数，否则返回ERANGE并将错误代码存入errno中。

附加说明   ERANGE指定的转换字符串超出合法范围。

范例   

#include <bits/stdc++.h>
using namespace std;
int main ()
{   char buffer [256];
    unsigned long ul;
    printf ("Enter an unsigned number: ");
    fgets (buffer, 256, stdin);
    ul = strtoul (buffer, NULL, 0);
    printf ("Value entered: %lu.\n", ul);
    return 0;
}

运行结果：
Enter an unsigned number: 017cyuyan
Value entered: 15.

017是八进制数，转为十进制为15；

三、数字转换为字符串

1. gcvt()（将浮点型数转换为字符串，取四舍五入）  

相关函数   ecvt，fcvt，sprintf

表头文件   #include<stdlib.h>

定义函数   char *gcvt(double number，size_t ndigits，char *buf);

函数说明   gcvt()用来将参数number转换成ASCII码字符串，参数ndigits表示显示的位数。gcvt()与ecvt()和fcvt()不同的地方在于，gcvt()所转换后的字符串包含小数点或正负符号。若转换成功，转换后的字符串会放在参数buf指针所指的空间。

返回值   返回一字符串指针，此地址即为buf指针。

附加说明  

范例   

#include <bits/stdc++.h>
using namespace std;
int main ()
{  double a=123.45678;
   double b=-1234.5678;
   char ptr[10000];//用　char *.prt;会出问题
   int decpt,sign;
   gcvt(a,5,ptr);
   printf("a value=%s\n",ptr);
   gcvt(b,6,ptr);
   printf("b value=%s\n",ptr);
}

运行结果：

a value=123.46

b value=-1234.56

2. sprintf()（其它数据类型转换为字符串） 

功能：　函数sprintf()用来作格式化的输出。 

用法：　此函数调用方式为int sprintf(char *string,char *format,arg_list); 

说 明：　函数sprintf()的用法和printf()函数一样，只是sprintf()函数把arg传给第一个参数string(一般为字符数组），然后再将串里的字符显示在屏幕上。arg_list为参数表，可有不定个数。通常在绘图方式下输出数字时可调用sprintf()函 数将所要输出的格式送到第一个参数，然后显示输出。

程序范例: 

#include <bits/stdc++.h>
using namespace std;
int main ()
{   char buf[10];
    sprintf(buf, "The length of the string is more than 10");
    printf("%s", buf);
}

编译并运行，屏幕上输出”The length of the string is more than 10“，同时系统提示程序已经停止。原因就是要写入的字符串的长度超过了buf的长度，造成缓冲区溢出。

使用snprintf()来代替sprintf()将能够很好的解决这个问题。

#include <bits/stdc++.h>
using namespace std;
int main ()
{   char a = 'a';
    char buf[80];
    sprintf(buf, "The ASCII code of a is %d.", a);
    printf("%s", buf);
}

运行结果：
The ASCII code of a is 97.

sprintf的作用是将一个格式化的字符串输出到一个目的字符串中，而printf是将一个格式化的字符串输出到屏幕。sprintf的第一个参数是目的字符串，如果不指定这个参数，执行过程中出现"该程序产生非法操作,即将被关闭...."的提示。 因为C语言在进行字符串操作时不检查字符串的空间是否够大，所以可能会出现数组越界而导致程序崩溃的问题。即使碰巧，程序没有出错，也不要这么用，因为早晚会出错。所以一定要在调用sprintf之前分配足够大的空间给buf。  

sprintf()最常见的应用之一莫过于把整数打印到字符串中

#include <bits/stdc++.h>
using namespace std;
int main()  
{   char buffer[100];  
    char a[] = "1234";  
    char b[] = "5678";  
    sprintf(buffer, "%s %s", a, b);  
    printf("%s\n", buffer);  
    return 0;  
}  

运行结果：1234  5678

#include <bits/stdc++.h>
using namespace std;
int main ()
{   char a = 'a';
    char buf[80];
    sprintf(buf, "The ASCII code of a is %d.", a);
    printf("%s\n", buf);
    sprintf(buf,"%d",123);  cout<<buf<<endl;
    sprintf(buf, "%4x", 17);   cout<<buf<<endl;
    char who[] = "I";
    char whom[] = "CSDN";
    sprintf(buf, "%s love %s.", who, whom); 
    cout<<buf<<endl;
    sprintf(buf, "%10.3f", 3.1415626); 
    cout<<buf<<endl;
}

运行结果：

The ASCII code of a is 97.

123

    11  

I   love  CSDN

        3.142

 

3. toascii()（将整型数转换成合法的ASCII 码字符）  

相关函数   isascii，toupper，tolower

表头文件   #include<ctype.h>

定义函数   int toascii(int c)

函数说明   toascii()会将参数c转换成7位的unsigned char值，第八位则会被清除，此字符即会被转成ASCII码字符。

返回值   将转换成功的ASCII码字符值返回。

范例   

#include <bits/stdc++.h>
using namespace std;
int main ()
{ int a=65;
  char b;
  printf("before toascii () : a value =%d(%c)\n",a,a);
  b=toascii(a);
  printf("after toascii() : b value =%d(%c)\n",b,b);
}

运行结果：

before toascii() : a value =65(A)

after toascii() : b value =65(A)

#include <bits/stdc++.h>
using namespace std;
int main ()
{ int a=217;
  char b;
  printf("before toascii () : a value =%d(%c)\n",a,a);
  b=toascii(a);
  printf("after toascii() : b value =%d(%c)\n",b,b);
}

运行结果：

before toascii() : a value =217()

after toascii() : b value =89(Ｙ)

 

四.字符串的比较与查找

1. memcmp( )(比较内存内容）

相关函数  bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp 

表头文件  #include <string.h> 

定义函数  int memcmp (const void *s1,const void *s2,size_t n);

函数说明  memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定，次顺序亦为字符的值。memcmp()首先将s1第一个字符值减去s2第一个字符的值，若差为0则再继续比较下个字符，若差值不为0则将差值返回。例如，字符串"Ac"和"ba"比较则会返回字符'A'(65)和'b'(98)的差值(－33)。 

返回值    若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。 

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{  char a[]="aBcDeF";
   char b[]="AbCdEf";
   char c[]="aacdef";
   char d[]="aBcDeF";
   printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*)b,6));
   printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*)c,6));
   printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*)d,6));
}

运行结果：

memcmp(a,b):1

memcmp(a,c):-1

memcmp(a,d):0

 

2. strcmp()与strncmp()（比较字符串）

相关函数  bcmp，memcmp，strcasecmp，strncasecmp，strcoll

表头文件  #include<string.h>

定义函数  int strcmp(const char *s1,const char *s2);

函数说明  strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII码表上的顺序来决定，此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值，若差值为0则再继续比较下个字

符，若差值不为0则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(－33)。

返回值    若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char a[]="aBcDeF";
  char b[]="AbCdEf";
  char c[]="aacdef";
  char d[]="aBcDeF";
  printf("strcmp(a,b) : %d\n",strcmp(a,b));
  printf("strcmp(a,c) : %d\n",strcmp(a,c));
  printf("strcmp(a,d) : %d\n",strcmp(a,d));
}

运行结果：

strcmp(a,b) : 1

strcmp(a,c) :-1

strcmp(a,d) : 0

strncmp()
strncmp函数是指定比较size个字符。也就是说，如果字符串s1与s2的前size个字符相同，函数返回值为0。此函数功能即比较字符串str1和str2的前maxlen个字符。如果前maxlen字节完全相等，返回值就=0；在前maxlen字节比较过程中，如果出现str1[n]与str2[n]不等，则依次比较str1和str2的前n位，设i(i< n)为两字符串首次的不同位，则返回（str1[i]-str2[i]）。

如； 
str1=”ABCDHG”,str2=”ABCDEF” 
strncmp(str1,str2,4)的返回值是 0； 
strncmp(str1,str2,5)的返回值是 1；
 

strcmp()与memcmp()功能比较：

     二者都可以用于字符串的比较，但是二者是有比较大的差异的，因为strcmp是按照字节（byte-wise）比较的，并且比较的过程中会检查是否出现了"/0"结束符，一旦任意一个字符串指针前进过程中遇到结束符，将终止比较。而memcmp函数是用于比较两个内存块的内容是否相等，在用于字符串比较时通常用于测试字符串是否相等，不常进行byte-wise的字符串比较。如果要比较的对象中包含一些由于边界对齐需求而填入结构对象中的空格、联合 (union)结束的额外空格、字符串所分配的空间未使用完的部分引起的“holes”的话，最好使用memcmp来完成。这些“holes”的内容是不确定的，在执行byte-wise比较时结果也是不明确的。

效率差异： 
     strcmp比较的字符串，而memcmp比较的是内存块，strcmp需要时刻检查是否遇到了字符串结束的 /0 字符，而memcmp则完全不用担心这个问题，所以memcmp的效率要高于strcmp

 

3. strcasecmp()（忽略大小写比较字符串）

相关函数   bcmp，memcmp，strcmp，strcoll，strncmp

表头文件   #include<string.h>

定义函数   int strcasecmp (const char *s1, const char *s2);

函数说明   strcasecmp()用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异。

返回值     若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0的值，s1 长度若小于s2 长度则返回小于0的值。

范例      

#include <bits/stdc++.h>
using namespace std;
int main()
{ char a[]="aBcDeF";
  char b[]="AbCdEf";
  if(!strcasecmp(a,b))
  printf("%s=%s\n",a,b);
}

运行结果：aBcDeF=AbCdEf

 

4. strchr()（查找字符串中第一个出现的指定字符）

相关函数  index，memchr，rinex，strbrk，strsep，strspn，strstr，strtok

表头文件  #include<string.h>

定义函数  char * strchr (const char *s,int c);

函数说明  strchr()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。

返回值    如果找到指定的字符则返回该字符所在地址，否则返回0。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{  char s[]="0123456789012345678901234567890";
   char *p;
   p=strchr(s,'5');
   printf("%s\n",p);
}

运行结果：56789012345678901234567890

 

６. strrchr()（查找字符串中最后出现的指定字符）

相关函数  index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok

表头文件  #include<string.h>

定义函数  char * strrchr(const char *s, int c);

函数说明  strrchr()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。

返回值    如果找到指定的字符则返回该字符所在地址，否则返回0。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char s[]="0123456789012345678901234567890";
  char *p;
  p=strrchr(s,'5');
  printf("%s\n",p);
}

运行结果：567890

 

７. strspn()（返回字符串中连续不含指定字符串内容的字符数）

相关函数  strcspn，strchr，strpbrk，strsep，strstr

表头文件  #include<string.h>

定义函数  size_t strspn (const char *s,const char * accept);

函数说明  strspn()从参数s 字符串的开头计算连续的字符，而这些字符都完全是accept 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符都是属于字符串accept

内的字符。

返回值    返回字符串s开头连续包含字符串accept内的字符数目。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char *str="Linux was first developed for 386/486-based PCs.";
  char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  printf("%d\n",strspn(str,t1));
}

运行结果：5

 

8 strstr()（在一字符串中查找指定的字符串）

相关函数   index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok

表头文件   #include<string.h>

定义函数   char *strstr(const char *haystack,const char *needle);

函数说明   strstr()会从字符串haystack 中搜寻字符串needle，并将第一次出现的地址返回。

返回值     返回指定字符串第一次出现的地址，否则返回0。

定义：strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

比如： 
char str2 = “cdef”； 
char str1 = “abcdefgh”； 
则通过函数，将返回 
strstr(str1,str2) = cdefgh；

如果str1不包含有str2。 
char str2 = “cxef”； 
char str1 = “abcdefgh”； 
则通过函数，将返回 
strstr(str1,str2) = NULL；

 

#include <bits/stdc++.h>
using namespace std;
int main()
{  char h[] = "RUNOOBTT";
   char n[] = "NOOB";
   char *ret;
   ret = strstr(h, n);
   printf("子字符串是： %s\n", ret);
   return(0);
}

运行结果：子字符串是：NOOBTT

#include <bits/stdc++.h>
using namespace std;
int main()
{  char h[] = "RUNOBTT";
   char n[] = "NOOB";
   char *ret;
   ret = strstr(h, n);
   printf("子字符串是： %s\n", ret);
   return(0);
}

运行结果：子字符串是：<NULL>

 

9. strtok()（分割字符串）

相关函数  index，memchr，rindex，strpbrk，strsep，strspn，strstr

表头文件  #include<string.h>

定义函数  char * strtok(char *s,const char *delim);

函数说明  strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串，当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。

返回值    返回下一个分割后的字符串指针，如果已无从分割则返回NULL。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
  char delim[]="-: ";
  char *p;
  printf("%s\n",strtok(s,delim));
  while((p=strtok(NULL,delim)))printf("%s ",p);
    printf("\n");
}

运行结果：

ab

cd ef;gh i jkl;mnop;qrs tu vwx y;z

 

10. strlen()（返回字符串长度）

相关函数

表头文件  #include<string.h>

定义函数  size_t strlen (const char *s);

函数说明  strlen()用来计算指定的字符串s的长度，不包括结束字符"\0"。

返回值    返回字符串s的字符数。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char str[] = "12345678";
  printf("str length = %d\n", strlen(str));
}

执行str length = 8

 

五、字符串的拷贝

1 .memcpy()（拷贝内存内容）

相关函数bcopy，memccpy，memcpy，memmove，strcpy，strncpy

表头文件#include<string.h>

定义函数void * memcpy (void * dest ,const void *src, size_t n);

函数说明memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是，memcpy()会完整的复制n个字节，不会因为遇到字符串结束'\0'而结束。n表示要复制的字符数。

返回值返回指向dest的指针。

附加说明指针src和dest所指的内存区域不可重叠。

范例

#include <bits/stdc++.h>
using namespace std;
int main ()
{  char src[50] = "www.runoob.com";
   char dest[50]= "abc";
   memcpy(dest, src, strlen(src)+1);
   printf("dest = %s\n", dest);
   return(0);
}

运行结果：dest = www.runoob.com

 

２.strcpy（拷贝字符串）

相关函数bcopy，memcpy，memccpy，memmove

表头文件#include<string.h>

定义函数char *strcpy(char *dest,const char *src);

函数说明strcpy()会将参数src字符串拷贝至参数dest所指的地址。

返回值返回参数dest的字符串起始地址。

附加说明如果参数dest所指的内存空间不够大，可能会造成缓冲溢出(bufferOverflow)的错误情况，在编写程序时请特别留意，或者用strncpy()来取代。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char a[]="string1";
  char b[]="string2";
  printf("a before strcpy() :%s\n",a);
  printf("a after strcpy() :%s\n",strcpy(a,b));
}

运行结果：

a before strcpy() : string1

a after strcpy() : string2

 

3.strncpy（拷贝字符串）

相关函数bcopy，memccpy，memcpy，memmove

表头文件#include<string.h>

定义函数char * strncpy(char *dest,const char *src,size_t n);

函数说明strncpy()会将参数src字符串拷贝前n个字符至参数dest所指的地址。

返回值返回参数dest的字符串起始地址。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char a[]="string1";
  char b[]="stng2";
  printf("before strncpy() : %s\n",a);
  printf("after strncpy() : %s\n",strncpy(a,b,6));
}

运行结果：

before strncpy() : string1

after strncpy() : stng2

 

#include<bits/stdc++.h>
using namespace std;
int main()
{	char s1[100]="Hello World";
	char s2[100];
	strcpy(s2,s1);
	printf("%s\n",s2);
	memset(s2,'\0',sizeof(s2)); // 重置s2
	strncpy(s2,s1,5);
	printf("%s\n",s2);
	return 0;
}

运行结果：

Hello  World

Hello 

 

4. memset（将一段内存空间填入某值）

相关函数bzero，swab

表头文件#include<string.h>

定义函数void * memset (void *s ,int c, size_t n);

函数说明memset()会将参数s所指的内存区域前n个字节以参数c填入，然后返回指向s的指针。在编写程序时，若需要将某一数组作初始化，memset()会相当方便。

返回值返回指向s的指针。

附加说明参数c虽声明为int， 但必须是unsigned char ，所以范围在0到255之间。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{ char s[30];
  int  r[10],t[10],i;
  memset (r,0,sizeof(r));
  memset (s,1,sizeof(t));
  memset (s,'A',sizeof(s));
  s[30]='\0';
  for(i=0;i<10;i++) printf("%d ",r[i]);  cout<<endl;
  for(i=0;i<10;i++) printf("%d ",t[i]);  cout<<endl;
  printf("%s\n",s);
}

运行结果：

0 0 0 0 0 0 0 0 0 0

4  2293384  4200007 4199946 1 -1 0  4  2952936   0

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

给数组“整体”赋值

（1）memset 函数

     memset 函数是给数组“按字节”进行赋值，一般用在 char 型数组中，如果是 int 类型的数组，一般赋值为 0 和 -1。使用前需要包含头文件：#include <cstring>。

（2）fill 函数

          fill 函数是给数组“按元素”进行赋值，可以是整个数组，也可以是部分连续元素，可以赋任何值。使用前需要包含头文件：#include <algorithm>。

#include <bits/stdc++.h>
using namespace std;
int main()
{   int a[7],b[7],c[7],d[7],i;
    memset(a,0,sizeof(a));   // 将a数组所有元素均赋值为0
    for(i = 0; i < 7; i++) cout << a[i] <<"  " ;
    cout << a[7] << endl; 
    memset(b,1,sizeof(b));  // 将 b 数组所有元素均赋值为二进制数 2^0+2^8+2^16+2^24=16843009
    for(i = 0; i < 7; i++) cout << b[i] <<"  " ;
    cout << b[7] << endl;
    memset(c,0,5);       //将 c 数组前 5个字节都赋值为 0，所以只能确定 c[0]等于0，其他元素值不确定
    for(i = 0; i < 7; i++) cout << c[i] <<"  " ;
    cout << c[7] << endl;
    fill(d,d+5,8);        //将 d 数组前 5 个元素都赋值为 8，其他元素值不确定
    for(i = 0; i < 7; i++) cout << d[i] <<"  " ;
    cout << d[7] << endl;
    return 0;
}

输出：

0 0 0 0 0 0 0  2293640

16843009 16843009  16843009  16843009  16843009   16843009  16843009  0

0  1971967056   4247373    4249184    4   2293384    4200271   16843009

8  8  8  8  8  1972014293    1019092974  0

注意 ：

      1、  memset(a,1,5) 是给前五个字节，每个字节赋值为1，  不是按每个数赋值， 其它的字节不确定。

      2、  fill(d,d+5,8);        //将 d 数组前 5 个元素都赋值为 8，其他元素值不确定

              fill 函数是给数组“按元素”进行赋值，可以是整个数组，也可以是部分连续元素，可以赋任何值。

 

５.strcat（连接两字符串）

相关函数bcopy，memccpy，memcpy，strcpy，strncpy

表头文件#include <string.h>

定义函数char *strcat (char *dest,const char *src);

函数说明strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。

返回值返回参数dest的字符串起始地址范例

#include <bits/stdc++.h>
using namespace std;
int main()
{  char a[30]="string1";
   char b[]="string2";
   printf("before strcat() : %s\n",a);
   printf("after strcat() : %s\n",strcat(a,b));
}

运行结果：

before strcat () : string１

after strcat () : string1string2

#include <bits/stdc++.h>
using namespace std;
int main()
{	char s1[100]="Hello";
	char s2[100]="World";
	strcat(s1,s2);
	printf("%s\n%s\n",s1,s2);
	return 0;
}

运行结果：

Hello  World

Hello 

 

6.strncat（连接两字符串）

相关函数bcopy，memccpy，memecpy，strcpy，strncpy

表头文件#inclue <string.h>

定义函数char * strncat(char *dest,const char *src,size_t n);

函数说明strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。

返回值返回参数dest的字符串起始地址。

范例

#include <bits/stdc++.h>
using namespace std;
int main()
{  char a[]="string1";
   char b[]="string2";
   printf("before strncat() :%s\n", a);
   printf("after strncat() :%s\n", strncat(a,b,5));
}

运行结果：

before strnact() : string1

after strncat() : string1strin