C语言之字符串处理函数

文章目录

• [1 字符串处理函数](#1 字符串处理函数)
• • [1.1 输入输出](#1.1 输入输出)
  • • [1.1.1 输出函数puts](#1.1.1 输出函数puts)
    • [1.1.2 输入函数gets](#1.1.2 输入函数gets)
  • [1.2 连接函数](#1.2 连接函数)
  • • [1.2.1 stract](#1.2.1 stract)
    • [1.2.2 strncat](#1.2.2 strncat)
  • [1.3 复制](#1.3 复制)
  • • [1.3.1 复制strcpy](#1.3.1 复制strcpy)
    • [1.3.2 复制strncpy](#1.3.2 复制strncpy)
    • [1.3.3 复制memcpy](#1.3.3 复制memcpy)
    • [1.3.4 指定复制memmove](#1.3.4 指定复制memmove)
    • [1.3.5 指定复制memset](#1.3.5 指定复制memset)
    • [1.3.6 新建复制strdup](#1.3.6 新建复制strdup)
    • [1.3.7 字符串设定strset](#1.3.7 字符串设定strset)
  • [1.4 比较](#1.4 比较)
  • • [1.4.1 比较strcmp](#1.4.1 比较strcmp)
    • [1.4.2 比较strncmp](#1.4.2 比较strncmp)
    • [1.4.3 比较memcmp](#1.4.3 比较memcmp)
  • [1.5 搜索](#1.5 搜索)
  • • [1.5.1 搜索memchr](#1.5.1 搜索memchr)
    • [1.5.2 搜索首次位置strchr](#1.5.2 搜索首次位置strchr)
    • [1.5.3 逆匹配搜索strcspn](#1.5.3 逆匹配搜索strcspn)
    • [1.5.4 查找第一个不属于字符集的下标strspn](#1.5.4 查找第一个不属于字符集的下标strspn)
    • [1.5.5 查找错误strerror](#1.5.5 查找错误strerror)
    • [1.5.6 查找第一个属于字符集位置strpbrk](#1.5.6 查找第一个属于字符集位置strpbrk)
    • [1.5.7 查找给定字符的最后一次匹配strrchr](#1.5.7 查找给定字符的最后一次匹配strrchr)
    • [1.5.8 查找字符串首次出现位置strstr](#1.5.8 查找字符串首次出现位置strstr)
    • [1.5.9 分隔符查找strtok](#1.5.9 分隔符查找strtok)
  • [1.6 排序&长度](#1.6 排序&长度)
  • • [1.6.1 倒排strrev](#1.6.1 倒排strrev)
    • [1.6.2 长度函数strlen](#1.6.2 长度函数strlen)
  • [1.7 转换大小写](#1.7 转换大小写)
  • • [1.7.1 转小写strlwr](#1.7.1 转小写strlwr)
    • [1.7.2 转大写strupr](#1.7.2 转大写strupr)
  • [1.8 转换其他数据类型](#1.8 转换其他数据类型)
  • • [1.8.1 转换浮点型atof](#1.8.1 转换浮点型atof)
    • [1.8.2 转换整型atoi](#1.8.2 转换整型atoi)
    • [1.8.3 转换长整型](#1.8.3 转换长整型)
    • • [1.8.3.1 atol](#1.8.3.1 atol)
      • [1.8.3.2 strtol](#1.8.3.2 strtol)
      • [1.8.3.3 无符号长整型strtoul](#1.8.3.3 无符号长整型strtoul)
    • [1.8.4 转换双精度strtod](#1.8.4 转换双精度strtod)

1 字符串处理函数

1.1 输入输出

1.1.1 输出函数puts

函数puts将字符串的内容输出到终端，并将字符串中的 \0 转换成换行符 \n 。即输出字符串内容，并换行。例如：

char str[]="1234";
puts(str);
将输出：1234

1.1.2 输入函数gets

参数 str是字符串，它的功能是从终端输入---行字符到str中。其中输入时的回车符被转换成\0。str不能是字符串常量。该函数调用将返回一个函数值，其值是str的起始地址。

1.2 连接函数

1.2.1 stract

函数原型：char strcat (char dest,char *src);

函数功能：将两个字符串连接合并成一个字符串，也就是把字符串src连接到字符串dest后面，连接后的结果放在字符串dest中

返回值：指向字符串dest的指针

参数 str1、str2 是字符串，它的功能是将str2连接在str1的后面。str1不能是字符串常量。函数调用返回一个函数值，函数值为str1的开始地址。正确使用该函数，要求str1必须足够大，以便能容纳str2的内容。注意，连接前，strl和str2都各有自\0。 连接后，strl中的\0在连接时被覆盖掉，而在新的字符串有效字符之后保留一个 \0 。例如：

char str1[100]="Beijing",str2[]="China";
strcat(str1,str2);
puts(str1);
将输出BeijingChina。

#include <string.h>
#include <stdio.h>
int main( )
{
     char dest[20]={" "};
    char *hello = "hello ", *space = " ", *world = "world";
     strcat(dest, hello);
       strcat(dest, space);
    strcat(dest, world);
       printf("%s\n", destination);
    getch();
       return 0;
}
运行结果是：

hello world

注意：开始对字符数组dest初始化为空是必要的，对声明的变量进行初始化是一个很好的习惯，如果不对字符数组dest进行初始化程序会产生运行时的错误，有兴趣的读者可以试试未初始化程序的输出结果。

1.2.2 strncat

函数原型：char strncat (char dest, char *src, int n);

函数功能：将一个字符串的子串连接到另一个字符串末端，也就是把字符串src的前n个字符连接到字符串dest后面，连接后的结果放在字符串dest中

返回值：指向字符串dest的指针

#include <string.h>
#include <string.h>
#include <stdio.h>
int main(void)
{
    char dest[30]={""};
    char *favorite = "I love", *tabs = "\t\n", *language = "C++";
    strcnat(dest, favorite,6);
    strncat(dest, tabs,1);
    strncat(dest, language,1);
    printf("%s\n", dest);
    getch();
    return 0;
}
运行结果是：

I love    C

注意：本例程中，字符串tabs中的内容比较新奇，它并不是我们一般的字符，而是两个转义说明符构成的特殊字符，C语言内部在处理过程中遇到转义说明符时会作特殊处理，本例中会将\t看做制表符，将\n看做换行符。

1.3 复制

1.3.1 复制strcpy

函数原型： char strcpy (char dest,char * src);

函数功能：实现字符串的拷贝工作，也就是把字符串src中的内容拷贝到字符串dest中，使两个字符串的内容相同。

返回值：指向字符串dest的指针

#include <stdio.h> 
#include <string.h> 
int main(void) { 
	char dest[20] ={""}; 
	char *src = "Hello World"; 
	int result; strcpy(dest,src); 
	printf("%s\n", dest); 
	result=strcmp(dest,src); 
	if(!result) 
		printf("dest is equal to src"); 
	else 
		printf("dest is not equal to src");
	getch(); 
	return 0; 

} 
运行结果是：

Hello World dest is equal to src 

注意：本例程中，向字符数组中赋值时要保证字符数组中有足够的空间，虽然有时候即便空间不够也会打印出正确的结果，但随着程序的运行，不能保证超出下标范围的部分还能以正确的型式存在。

1.3.2 复制strncpy

在某些应用中，需要将一个字符串的前面一部分拷贝，其余部分不拷贝。调用函数strncpy可实现这个要求。
strncpy(str1,str2,n)的作用是将str2中的前n个字符拷贝到str1(附加\0)。其中n是整型表达式，指明欲拷贝的字符个数。如果str2中的字符个数不多于n，则该函数调用等价于strcpy(strl，str2)

函数原型： char strncpy (char dest,char * src, int n);

函数功能：实现字符串子串的拷贝工作，也就是把字符串src中的前n个字符拷贝到字符串dest中。

返回值：指向字符串dest的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char dest[20]={""};
    char *src1="Hello World",*src2 ="Aloha";
    strncpy(dest,src1,5);
    strncpy(dest,src2,5);
    if(!strcmp(dest,src1))
        printf("dest is equal to src1");
    else if(!strcmp(dest,src2))
        printf("dest is equal to src2");
    else
        printf("dest is %s",dest);
    printf("%s\n", dest);
    getch();
    return 0;
}
运行结果是：

Aloha
dest is equal to src2

1.3.3 复制memcpy

函数原型：void memcpy(void destin, void *source, unsigned n)

函数功能：从source所指的对象中复制n个字符到destin所指的对象中。但是，如果这种复制发生在重叠对象之间，其行为是不可预知的。

#include <stdio.h>
#include <string.h>
int main(void)
{
   char *s = "";
   char *d = "This is a test for memcpy function";
   char *ptr;
   printf("destination before memcpy: %s\n", d);
   ptr = memcpy(d, s, strlen(s));
   if (ptr)
      printf("destination after memcpy: %s\n", d);
   else
      printf("memcpy failed\n");
   return 0;
}
运行结果为：
destination before memcpy: This is a test for memcpy function
destination after memcpy:  test for memcpy function

注意： memcpy与strcpy的不同在于应用memcpy进行字符串的拷贝可以指定拷贝串的长度。另外memcpy的参数为void指针类型，因此它还可以对非字符型对象进行操作，而strcpy只适用于字符串的拷贝。

如果复制过程中发生在重叠对象之间，其行为是不可预知的。例如下面这个例子：

#include <string.h>
#include <stdio.h>
int main(void)
{
  char *d = "1234567890";
  char *p;
  p=d+3;
  printf(" %s\n", d);
  memcpy(p, d, 6);
  printf(" %s\n", d);
  return 0;
}

运行结果为：
1234567890
1231231230

由于字符串p是字符串d的一个子串，在调用memcpy时，复制的字符串在d和p之间又重叠，因此该复制行为是不可预知的，结果也自然难以保证。

显然这不是期望得到的结果。

1.3.4 指定复制memmove

函数原型：void memmove(void destin, void *source, unsigned n)

函数功能：从source所指的对象中复制n个字符到destin所指的对象中。与memcpy不同的是，当对象重叠时，该函数仍能正确执行。

#include <stdio.h>
#include <string.h>
int main(void)
{
   char *s = "";
   char *d = "This is a test for memcpy function";
   char *ptr;
   printf("destination before memmove: %s\n", d);
   ptr = memmove(d, s, strlen(s));
   if (ptr)
      printf("destination after memmove:  %s\n", d);
   else
      printf("memcpy failed\n");
   return 0;
}
运行结果为：
destination before memmove: This is a test for memcpy function
destination after memmove:  test for memcpy function

注意： 与函数memcpy不同的是，当对象重叠时，该函数仍能正确执行。例如下面这个例子：

#include <string.h>
#include <stdio.h>
int main(void)
{
  char *d = "1234567890";
  char *p;
  p=d+3;
  printf(" %s\n", d);
  memmove(p, d, 6);
  printf(" %s\n", d);
  return 0;
}
运行结果为：

1234567890
1231234560

显然这是期望得到的结果。 这是因为函数memmove的复制行为类似于先从source对象中复制n个字符到一个与source和destin都不重合的含n个字符的临时数组中作为缓冲，然后从临时数组中再复制n个字符destin所指的对象中。 就本段程序而言，memmove先将字符串"123456"复制到一个临时数组中，再将它复制到以p为首地址的字符串中。

1.3.5 指定复制memset

函数原型：void memset(void s, int c, unsigned n)

函数功能：把c复制到s所指向的对象的前n个字符的每一个字符中。

返回值：s的值

#include <string.h>
#include <stdio.h>
int main(void)
{
   char *str="AAAAAAAAAAAAAAAAAA";
   printf("The original string is:    %s\n",str);
   memset(str,'B',9);
   printf("The string after memset is:%s\n",str);
}
运行结果为：

The original string is:    AAAAAAAAAAAAAAAAAA
The string after memset is:BBBBBBBBBAAAAAAAAA

1.3.6 新建复制strdup

函数原型：char strdup(char str);

函数功能：将字符串拷贝到新分配的空间位置，也就是将str拷贝到一块新分配的存储空间，其内部使用动态分配内存技术实现的，分配给字符串的空间来自于当前所用内存模式制定的堆。

返回值：返回指向含有该串拷贝的存储区

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *src="This is the buffer text";
    char *dest;
    dest=strdup(src);
    if(!strcmp(src,dest))
        printf("Copy success\n%s\n",dest);
    else
        printf("Copy failure");
    free(dest);
    getch();
    return 0;
}
运行结果是：

Copy success
This is the buffer text

注意：本例程中，初学者往往会忽视释放动态分配存储区的操作，虽然表面看起来似乎对程序没有什么影响，但实际上不对存储区进行回收会造成内存泄漏，在一些大程序会造成致命的后果。

1.3.7 字符串设定strset

函数原型：char strset(char str, char c);

函数功能：将字符串原有字符全部设定为指定字符，也就是将字符串str中的所有字符全部用字符c进行替换.

返回值：返回指向被替换字符串的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
   char str[11]="0123456789";
   char symbol='a';
   printf("Before: %s\n",str);
   strset(str,symbol);
   printf("After: %s\n",str);
   getch();
   return 0;
}
运行结果是：

0123456789
aaaaaaaaaa

1.4 比较

1.4.1 比较strcmp

函数原型：int strcmp (char str1,char str2);

函数功能：比较两个字符串的大小，也就是把字符串str1和字符串str2从首字符开始逐字符的进行比较，直到某个字符不相同或比较到最后一个字符为止，字符的比较为ASIC码的比较

返回值：若字符串str1大于字符串str2返回结果大于零，若字符串str1小于字符串str2返回结果小于零，若字符串str1等于字符串str2返回结果等于零

参数 str1、str2 是字符串，它的功能是比较两个字符串大小。对两个字符串自左至右逐个字符相比较(按字符的ASCII代码值的大小)，直至出现不同的字符或遇到\0为止。如全部字符都相同，则认为相等，函数返回0值；若出现不相同的字符，则以这第一个不相同的字符比较结果为准。若str1的那个不相同字符小于str2的相应字符，函数返回一个负整数；反之，返回一个正整数。 注意，对字符串不允许施加相等==和不相等!=运算，必须用字符串比较函数对字符串作比较。

例如：
if(str1==str2) printf("Yes\n");是非法的，而只能用if(strcmp(str1,str2)==0) printf("Yes\n");

#include <string.h>
#include <stdio.h>
int main(void)
{
    char *str1 = "Canada", *str2 = "China", *str3 = "china";
    int result;
    result = strcmp(str1, str2);
    if (result < 0)
        printf("%s is less than %s", str1,str2);
    else
        printf("%s is not less than %s", str1,str2);
    printf("\n");
    result = strcmp(str2, str3);
    if (result < 0)
        printf("%s is less than %s", str2,str3);
    else
        printf("%s is not less than %s", str2,str3);
    getch();
    return 0;
}

运行结果是：
Canada is less than China
China is less than china

注意：本例程中，字符串的比较结果为首个两个不等字符之间ASIC码的差值，如果我们将第一次比较的结果result输出，应该是' a'的ASIC与码与' h'的ASIC码的差值

1.4.2 比较strncmp

函数原型： int strncmp (char str1,char str2, int n);

函数功能：比较两个字符串子串的大小，也就是把字符串str1的前n个字符组成的子串和字符串str2的前n个字符组成的子串进行比较，从首字符开始逐字符的进行比较，直到某个字符不相同或比较到第n个字符为止。

返回值：若字符串str1前n个字符组成的子串大于字符串str2前n个字符组成的子串返回结果大于零，若字符串str1前n个字符组成的子串小于字符串str2前n个字符组成的子串返回结果小于零，若字符串str1前n个字符组成的子串等于字符串str2前n个字符组成的子串返回结果等于零

#include <string.h>
#include <string.h>
int main(void)
{
    char *str1="Hello World";
    char *str2="Hello C Programme";
    int result;
    result=strncmp(str1,str2,5);
    if(!result)
        printf("%s is identical to %s in the first 5 words",str1,str2);
    else if(result<0)
        printf("%s is less than %s in the first 5 words",str1,str2);
    else
        printf("%s is great than %s in the first 5 words",str1,str2);
    printf("\n");
    result=strncmp(str1,str2,10);
     if(!result)
        printf("%s is identical to %s in the first 10 words",str1,str2);
    else if(result<0)
        printf("%s is less than %s in the first 10 words",str1,str2);
    else
        printf("%s is great than %s in the first 10 words",str1,str2);
    getch();
    return 0;
}
运行结果是：

Hello World is identical to Hello C Programme in the first 5 words
Hello World is great than Hello C Programme in the first 10 words

注意：本例程中，要注意子串比较的过程中子串的大小应不小于零且不超过字符串的长度，虽然子串的长短参数不会产生编译时的错误和最终结果的输出，但在比较前检查比较范围是一个很好的习惯。

1.4.3 比较memcmp

函数原型：void memcmp(char s1, char *s2, unsigned n)

函数功能：比较s1所指向的字符串与s2所指向的字符串的前n个字符。

返回值：根据s1所指向的对象的大于、等于、小于s2所指向的对象，函数

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str1="ABCDEF";
    char *str2="ABCDEf";
    int s1,s2;
    s1=memcmp(str1,str2,6);
    s2=memcmp(str1,str2,5);
    printf("The comparison of 6 character\n");
    if(s1>0)printf("%s>%s\n",str1,str2);
    else
        if(s1<0)printf("%s<%s\n",str1,str2);
    else
         printf("%s=%s\n",str1,str2);
    printf("The comparison of 5 character\n");
    if(s2>0)printf("%s>%s\n",str1,str2);
    else
        if(s2<0)printf("%s<%s\n",str1,str2);
    else
         printf("%s=%s\n",str1,str2);
}

运行结果为：
The comparison of 6 character
ABCDEF<ABCDEf
The comparison of 5 character
ABCDEF=ABCDEf

注意： 由于字符串比较的方法是从左至右按照字符的ASCII码进行比较的，因此在比较6个字符时，字符串"ABCDEF"<"ABCDEf"（f的ASCII值大于F的ASCII值）；而只比较5个字符时，字符串"ABCDEF"="ABCDEf"。

1.5 搜索

1.5.1 搜索memchr

函数原型：void memchr(void s, char ch, unsigned n)

函数功能：在数组的前 n 个字节中搜索字符 ch。

返回值：返回一个指针，它指向ch在s 中第一次出现的位置。如果在s的前n个字符中找不到匹配，返回NULL。

#include <string.h>
#include <stdio.h>
int main(void)
{
   char *str="I love China\n";
   char *p;
   p=memchr(str,'C',strlen(str));
   if(p)
         printf("%s",p);
   else
        printf("The character was not found\n") ;
}
本例程的运行结果为：
China

1.5.2 搜索首次位置strchr

函数原型：char strchr(char str, char c);

函数功能：在字符串中查找给定字符的第一次匹配，也就是在字符串str中查找字符c第一次出现的位置

返回值：第一次匹配位置的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char str[15] ={""};
    char *ptr, c = 'r';
    strcpy(str, "Hello World");
    ptr = strchr(str, c);
    if (ptr)
       printf("The character %c is at position: %d\n", c, ptr-str);
    else
       printf("The character was not found\n");
    strcpy(str, "Aloha");
    if (ptr)
       printf("The character %c is at position: %d\n", c, ptr-str);
    else
       printf("The character was not found\n");
    getch();
    return 0;
}
运行结果是：
The character r is at position 8
The character r is at position 8

注意：本例程中，对字符串中字符匹配的返回值是指向匹配位置的指针，我们获取到该指针后，与数组的头指针做减法，也就是与数组变量名做减法，就可以获得我们得到的指针在数组中对应的下标。

1.5.3 逆匹配搜索strcspn

函数原型：int strcspn(char str1, char str2);

函数功能：在字符串中查找第一个属于字符集的下标，即从开始有多少个字符不属于字符集，也就是在字符串str1中查找第一个属于字符集str2中任何一个字符的下标，即字符串str1中从开始一直有多少个字符不属于字符集str2中的字符。

返回值：所找到的字符串中段的长度

#include <string.h>
#include <stdio.h>
int main(void)
{
    char *str1="tomato",*str2="carrot";
    char *str= "abc";
    int  result;
    result = strcspn(str1,str);
    if(result)
        printf("The first %d is congruent\n",result);
    else
        printf("No character is congruent\n");
    result = strcspn(str2,str);
    if(result)
        printf("The first %d is congruent\n",result);
    else
        printf("No character is congruent\n");
    getch();
    return 0;
}

运行结果是：
The first 3 is congruent
No character is congruent

注意：本例程中，字符集逆匹配与字符集匹配两者的匹配方式截然相反，字符串匹配是当字符串中字符等于字符集中任意字符是匹配成功，字符串逆匹配是当字符串中字符不等于字符集中任意字符是匹配成功。

1.5.4 查找第一个不属于字符集的下标strspn

函数原型：int strspn(char str1, char str2);

函数功能：在字符串中查找第一个不属于字符集的下标，即从开始有多少个字符属于字符集，也就是在字符串str1中查找第一个不属于字符集str2中任何一个字符的下标，即字符串str1中从开始一直有多少个字符属于字符集str2中的字符。

返回值：所找到的字符串中段的长度

#include <string.h>
#include <stdio.h>
int main(void)
{
    char *str1="cabbage",*str2="potato";
    char *str= "abc";
    int  result;
    result = strspn(str1,str);
    if(result)
        printf("The first %d is congruent\n",result);
    else
        printf("No character is congruent");
    result = strspn(str2,str);
    if(result)
        printf("The first %d is congruent\n",result);
    else
        printf("No character is congruent");
    getch();
    return 0;
}
运行结果是：

The first 5 is congruent
No character is congruent

1.5.5 查找错误strerror

函数原型：char *strerror(int errnum);

函数功能：获取程序出现错误的字符串信息，也就是根据错误代码errnum查找到具体的错误信息。

如下示例，循环只取了前十二种错误信息，实际的错误种类还有更多

#include <stdio.h>
#include <errno.h>
int main(void)
{
    char *error;
    int i;
    for(i=0;i<12;i++)
    {
        error=strerror(i);
        printf("%s",error);
    }
    getch();
    return 0;
}

运行结果是：

Error 0
Invalid function number
No such file or directory
Path not found
Too many open files
Permission denied
Bad file number
Memory arena trashed
Not enough memory
Invalid memory block address
Invalid environment
Invalid format

1.5.6 查找第一个属于字符集位置strpbrk

函数原型：char strpbrk(char str1, char *str2);

函数功能：在字符串中查找第一个属于字符集的字符位置，也就是在字符串str1中查找第一个属于字符集str2中任意字符的位置。

返回值：返回第一个匹配字符的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str1="There are 5 pigs in the hogpen";
    char *str2="0123456789";
    char *result;
    result = strpbrk(str1,str2);
    if(result)
        printf("%s\n",result++);
    else
        printf("There are no numbers any more");
    result = strpbrk(result,str2);
    if(result)
        printf("%s\n",result++);
    else
        printf("There are no numbers any more");
    getch();
    return 0;
}
运行结果是：

5 pigs in the hogpen
There are no numbers any more

注意：本例程中，值得注意的是匹配成功时结果的输出。由于获得了匹配成功的字符的指针，因此我们可以利用该指针输出字符串的字串，利用自增操作符我们移动一个位置又可以对尚未匹配的子串继续进行下一次匹配。

1.5.7 查找给定字符的最后一次匹配strrchr

函数原型：char strrchr(char str, char c);

函数功能：在字符串中查找给定字符的最后一次匹配，也就是在字符串str中查找字符c最后一次出现的位置

返回值：最后一次匹配位置的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char str[15]={""};
    char *ptr, c = 'o';
    strcpy(str, "Hello World");
    ptr = strchr(str, c);
    if (ptr)
       printf("The first character %c is at position: %d\n", c, ptr-str);
    else
       printf("The character was not found\n");
    ptr = strrchr(str, c);
    if (ptr)
       printf("The last character %c is at position: %d\n", c, ptr-str);
    else
       printf("The character was not found\n");
    getch();
    return 0;
}
运行结果是：

The first character r is at position 4
The last character r is at position 7

注意：本例程中，如果字符串中只有一个'o'字符，那么无论调用哪种字符串中字符匹配函数都会返回相同的结果。

1.5.8 查找字符串首次出现位置strstr

函数原型：char strstr(char str1, char *str2);

函数功能：在字符串中查找另一个字符串首次出现的位置，也就是在字符串str1中查找第一次出现字符串str2的位置。

返回值：返回第一次匹配字符串的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str1 = "Borland International",*str2 = "nation";
    char *result;
    result=strstr(str1, str2);
    if(result)
        printf("The substring is: %s\n", ptr);
    else
        printf("Not found the substring");
    getch();
    return 0;
}
运行结果是：
The substring is national

注意：本例程中，匹配成功时的返回结果并不是进行匹配的字符串，而是第一次匹配成功的字符串首字符的指针。

1.5.9 分隔符查找strtok

函数原型：char strtok(char str1, char *str2);

函数功能：在字符串中查找单词，这个单词始有第二个字符串中定义的分隔符分开，也就是在字符串str1中查找由字符串str2定义的分隔符，以分隔符为界，分隔出来的分隔符前面的所有字符组成一个单词，分离出第一个单词后将第一个参数置为空，可以继续分隔第二个单词。

返回值：返回分隔出的单词的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str1="I am very\thappy,to,stduy\nC\nprogramme";
    char *str2=" ,\t\n";
    char *token;
    printf("%s\n\nTokens:\n",str1);
    token = strtok(str1,str2);
    while( token != NULL )
    {
        printf("%s\n",token);
        token = strtok(NULL,str2);
    }
    getch();
    return 0;
}

运行结果是：

I am very        happy,to,study
C
Programme
Token:
I
am
very
happy
to
study
C
Programme

注意：本例程中，一定要记住如果在第一次分隔出单词后想继续进行分隔操作，务必要将函数的第一个参数置为空。

1.6 排序&长度

1.6.1 倒排strrev

函数原型：char strrev(char str);

函数功能：将字符串进行倒转，也就是将字符串str中的第一个字符与最后一个字符交换，第二个字符与倒数第二个字符交换，以此类推。

返回值：返回倒转后字符串的指针

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str = "Able was I ere I saw Elba";
    printf("Before: %s\n",str);
    strrev(str);
    printf("After: %s\n",str);
    getch();
    return 0;
}
运行结果是：

Able was I ere I saw Elba
ablE was I ere I saw elbA

注意：本例程中，字符数组中的初值并不是严格意义上的回文，将它倒转后会发现与原字符串并不是完全一样。

1.6.2 长度函数strlen

函数原型： int strlen (char *str);

函数功能：求字符串的长度，也就是求字符串str中有多少个字符

返回值：字符串str字符的个数

#include <stdio.h>
#include <string.h>
int main(void)
{
    char src1[3]={""},src2[10]={"Hello"};
    char *src3="Hello";
    printf("%d\n",strlen(src1));
    printf("%d\n",strlen(src2));
    printf("%d\n",strlen(src3));
    getch();
    return 0;
}
运行结果是：

0
5
5

1.7 转换大小写

1.7.1 转小写strlwr

函数原型：char strlwr(char str,);

函数功能：将字符串原有大写字符全部转换为小写字符，也就是将字符串str中的所有字符变成小写。

返回值：返回指向被转换字符串的指针

函数strlwr(str)将字符串str中的大写字母转换成小写字母，其中str不能是字符串常量。 例0.24：任意输入一个英文书名，将书名中的小写字母全部转换成大写字母，其余字符不变，输出转换后的书名。程序代码如下：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[100];
    int i;
    printf("Input the book name: ");
    gets(str);
    for(i=0; i<=strlen(str);i++){
	    if(str[i]>='a'&&str[i]<='z')
	    str[i]-=32;
	 }
   puts(str);
   return 0; 
}

在上面的程序中，首先定义了一个字符数组str，用来存储英文书名，然后用gets函数得到输入的英文书名。在for循环中，用strlen函数得到输入的英文书名字符串的长度，然后把英文书名的小写字母转换成大写字母。最后用puts函数输出转换后的英文书名。

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *s="You'll Never Walk Alone";
    printf("%s",strlwr(s));
    getch();
    return 0;
}

1.7.2 转大写strupr

函数原型：char strupr(char str);

函数功能：将字符串原有小写字符全部转换为大写字符，也就是将字符串str中的所有字符变成大写。

返回值：返回指向被转换字符串的指针

strupr(str)则将字符串str中的小写字母转换成大写字母，其中str不能是字符串常量。

#include <stdio.h>
#include <string.h>
int main(void)
{
    char *s=" You'll Never Walk Alone ";
    printf("%s",strlwr(s));
    getch();
    return 0;
}

运行结果是：

YOU'LL NEVER WALK ALONE

1.8 转换其他数据类型

1.8.1 转换浮点型atof

函数原型：float atof(const char *str);

函数功能：将字符串转换成浮点值，也就是将字符串str转换成浮点值然后获取转换后的结果。

返回值：返回转换后的浮点值

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
   char *str="12345.67";
   float result;
   result=atof(str);
   printf("string=%s\nfloat =%f\n",str,result);
   getch();
   return 0;
}
运行结果：
string =12345.67
float=12345.669922

注意：本例程中，转换成浮点数的结果有些奇怪，它并不等于我们字符串中变量的值，而是存在一定的误差，虽然误差很小，但是可以看出误差是从原字符串中的最后一位开始的，这是由于在转换过程中函数内部在实现时采用的转换方式造成的，如果想避免这种误差，可以使用strtoX系列函数。

1.8.2 转换整型atoi

函数原型：int atoi(const char *str);

函数功能：将字符串转换成整数值，也就是将字符串str转换成整型值然后获取转换后的结果。

返回值：返回转换后的整型值

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
   char *str="12345.67";
   int result;
   result=atoi(str);
   printf("string=%s\ninteger=%d\n",str,result);
   getch();
   return 0;
}

运行结果是：
string =12345.67
integer=12345

1.8.3 转换长整型

1.8.3.1 atol

函数原型：long atol(const char *str);

函数功能：将字符串转换成长整数值，也就是将字符串str转换成长整型值然后获取转换后的结果。

返回值：返回转换后的长整型值

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
   char *str="12345.67";
   long result;
   result=atol(str);
   printf("string=%s\nlong =%ld\n",str,result);
   getch();
   return 0;
}

运行结果是：
string =12345.67
long=12345

1.8.3.2 strtol

函数原型：long strtol(char str, char *endptr, int base);

函数功能：将字符串转换为长整型值，也就是将字符串str转换为长整型值，其中进行转换字符串必须是长整型的字符表示格式，如果字符串中有非法的非数字字符，则第二个参数将负责获取该非法字符，即字符串指针endptr用于进行错误检测，转换在此非法字符处停止进行。

返回值：返回转换后的长整型结果

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
    char str[20], *endptr;
    long result;
    while(1)
    {
        printf("Input a long:");
        gets(str);
        result=strtod(str,&endptr);
        if(result!=-1)
            printf("The number is %ld\n",result);
        else
            break;
    }
    getch();
    return 0;
}
运行结果是：

Input a long: -15
The number is -15
Input a long: 1234.5678
The number is 1234
Input a long: 333333333333
The number is 2147483647
Input a long: -34abc
The number is -34
Input a long: abc
The number is 0
Input a float: -1

注意：将字符串中的小数转换为长整型时，程序会将小数点看作非法字符，从而停止转换继续进行，因此无论小数点后面的数是多少都会截断，而不是我们习惯上的四舍五入或者五舍六入。

1.8.3.3 无符号长整型strtoul

函数原型：unsigned long strtoul(char str, char *endptr, int base);

函数功能：将字符串转换为无符号长整型值，也就是将字符串str转换为无符号长整型值，其中进行转换字符串必须是无符号长整型的字符表示格式，如果字符串中有非法的非数字字符，则第二个参数将负责获取该非法字符，即字符串指针endptr用于进行错误检测，转换在此非法字符处停止进行。

返回值：返回转换后的无符号长整型结果

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
    char str[20], *endptr;
    unsigned long result;
    while(1)
    {
        printf("Input an unsigned long:");
        gets(str);
        result=strtoud(str,&endptr);
        if(result!=-1)
            printf("The number is %lu\n",result);
        else
            break;
    }
    getch();
    return 0;
}

运行结果是：

Input a long: 100
The number is 100
Input a long: -36
The number is 0
Input a float: 1

注意：本例程中，输入负数的时候程序会将负号看作非法字符，从而停止转换继续进行，没有发生任何实际的转换。

1.8.4 转换双精度strtod

函数原型：double strtod(char str, char *endptr);

函数功能：将字符串转换非双精度值，也就是将字符串str转换为双精度值，其中进行转换字符串必须是双精度数的字符表示格式，如果字符串中有非法的非数字字符，则第二个参数将负责获取该非法字符，即字符串指针endptr用于进行错误检测，转换在此非法字符处停止进行。

返回值：返回转换后的双精度结果

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
    char str[20], *endptr;
    double result;
    while(1)
    {
        printf("Input a float:");
        gets(str);
        result=strtod(str,&endptr);
        if(result==-1)
            printf("The number is %lf\n",str,result);
        else
            break;
    }
    getch();
    return 0;
}

运行结果是：

Input a float: 4.2
The number is 4.20000
Input a float: 79
The number is 79.00000
Input a float: 1.1111111111
The number is 1.111111
Input a float: 34.45abc
The number is 34.450000
Input a float:abc
The number is 0.000000
Input a float: -1

注意：本例程中，即便转换出现非法字符循环也不会停止，而只是通过第二个参数捕捉到了非法字符，可以编写程序对非法字符进行处理，本例中并没有这样做，循环只是以输入循环结束标志循环结束依据。