字符串操作常用函数_字符串函数有哪些

字符串常用函数有如下

puts()      //输出字符串
gets()      //获取字符串
strlen()    //计算字符串长度
memset()     //初始化
strcpy()  strncpy() //字符串的拷贝
strcat()     //字符串的拼接
strcmp()     //字符串的比较
strchr()  strstr()   //字符串的查找
strtok() //字符串分割
strlwr()  strupr()  //字符串转为小写和字符串转为大写

1
2
3
4
5
6
7
8
9
10
11

1、puts()和geits()

puts()函数用来向输出设备（屏幕）输出字符串并自带换行，将’\0’转换为回车换行，其调用方式为，puts(s)；其中s为字符串字符（字符串数组名或字符串指针），puts和printf("%s",s)的功能差不多，不同之处在于puts自带换行。

gets()函数用来从输入设备（键盘）读取字符串直到换行符结束，但换行符会被丢弃，然后在末尾添加’\0’，其调用格式为：gets(s);其中s为字符串变量（字符串数组名或字符串指针），gets()函数读取到\n（我们输入的回车）于是停止读取，但是它不会把\n包含到字符串里面去，然后，和puts函数配合使用，在输出字符串的时候自动换行。
示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    char str[128] = {'\0'};//如果是char *str的话要注意野指针
    printf("请输入字符串\n");
    gets(str);
    puts(str);
    system("pause");
    return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这里如果用指针的话要注意野指针

2、strlen（）

对于strlen（）函数可以参考strlen

3、memset()

memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组, c 是赋给buffer的值, count 是buffer的长度，简单的说就是将buffer中初始化为c,大小为count，memset函数作用是在一段内存块中填充某个给定的值，它是对数组进行清零操作最快的一种最快方法。

示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    //char str[128] = {'\0'};
    char *pstr;
    pstr = (char*)malloc(128); //注意野指针
    memset(pstr,'\0',128);   //初始化为‘\0’

    printf("请输入字符串\n");
    gets(pstr);
    puts(pstr);
    system("pause");
    return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这里的memset是给指针pstr初始化，用三条代码代替了用数组定义的一条代码，虽然条数多了，但是指针比数组更加灵活，更加方便。

4、strcpy() 和 strncpy()

在C语言函数中strcpy函数原型为：char * strcpy(char * Dest,const char * Src);
功能是把从src地址开始的字符串复制到以dest开始的地址空间
注意：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串，返回指向dest的指针。

strncpy函数用于将指定长度的字符串复制到字符数组中，是 C语言的库函数之一，语法形式为：char *strncpy(char *dest, const char *src, int n)，表示把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回被复制后的dest 。

strcpy和strncpy的区别：
strcpy只是复制字符串，但不限制复制的数量，很容易造成溢出，strncpy要安全一些。
strncpy能够选择一段字符输出，strcpy则不能。

示例代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    char pstr1[128] = "helloworld";
    char *pstr2 = "china";
    strcpy(pstr1,pstr2);
    printf("strcpy = %s\n",pstr1);
   // strncpy(pstr1,pstr2,3);  //将pstr2的前三个字符拷贝到pstr1前三个位置
  // printf("strncpy = %s\n",pstr1);
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这里运行时strcpy和strncpy要分开运行。

当拷贝目标为指针时

    char *pstr;
    pstr = (char*)malloc(128);
    if(pstr == NULL){
		printf("开辟空间失败\n");
		exit(-1);
	}
    memset(pstr,'\0',10);
    char pstr1[128] = "hello";
    //strcpy(pstr,pstr1); 
    //printf("strcpy = %s\n",pstr);
    strncpy(pstr,pstr1,2);
    printf("strncpy = %s\n",pstr);
    
1
2
3
4
5
6
7
8
9
10
11
12
13

5、strcat()

strcat()为字符串的拼接函数，函数原型为extern char strcat(char dest, const char src);把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除dest原来末尾的“\0”）但是要保证dest足够长，以容纳被复制进来的src，*src中原有的字符不变，返回指向dest的指针。
示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    char pstr[128] = "hello";
    char *pstr1 = "world";
    strcat(pstr,pstr1);
    printf("strcat = %s\n",pstr);
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

6、strcmp()

strcmp() 函数原型为 extern int strcmp(const char *s1,const char *s2);函数的返回类型为整型，用于比较两个字符串并根据比较结果返回整数、基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止

示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    char pstr[128] = "hello";
    char *pstr1 = "world";
    int cnt = strcmp(pstr,pstr1);
    printf("strcmp返回值 = %d\n",cnt);
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

7、strchr() 和 strstr()

strchr（）为字符的查找函数，函数原型为：char *strchr(const char *str, char c)，即在字符串 str 所指向的内存中搜索第一次出现字符 c（一个无符号字符）的位置，在参数str所指向的字符串中搜索第一次出现字符 c 的位置，返回一个指向 str 中第一次出现的字符的指针，如果字符串中不包含该字符则返回NULL空指针。

示例代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    char pstr[128] = "hello";
    char c = 'o';
    char* p = NULL;
    p = strchr(pstr,c);
    if(p == NULL){
        printf("没有找到字母 o \n");
    }else{
        
        printf("找到字母 o \n");
        puts(p);
    }
    
    system("pause");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

strstr()是字符串的查找函数，strstr函数原型char *strstr(const char *haystack, const char *needle) 用于判断字符串needle是否是haystack的子串，和strchr()函数的不同之处在于strchr函数是查找一个字符，而strstr是查找一个字符串， 在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’ ，该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。

示例代码

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
int main()
{
    char pstr[128] = "helloworld";
    char *pstr1 = "wor";
    //char *pstr1 = "world";
    char *ret = NULL;
    ret = strstr(pstr, pstr1);
    if(ret == NULL){

        printf("没有找到\n");
    }else{
        printf("找到了\n");
        printf("找到的子字符串为 %s \n",ret);
    }

    system("pause");
    return(0);
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8、strtok()

strtok()为分割字符串为一组字符串，函数原型为char *strtok(char s[ ], const char *delim)，s为要分解的字符串，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符，s指向要分解的字符串，之后再次调用要把s设成NULL。

s开头一个个被分割的串，当s中的字符查找到末尾时，返回NULL，如果查找不到delim中的字符时，返回当前strtok的字符串的指针，所有delim中包含的字符都会被滤掉。

示例代码

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
int main()
{
    char *p = NULL;
    char pstr[128] = "hello1,world1,hello2,world2";
    char *ps = ",";

    p = strtok(pstr,ps);
    if(p != NULL){

        printf("获取到第一个字符串p = %s\n",p);
    }
    //从第二次开始目标字符串要改为NULL
    p = strtok(NULL,ps);   
    if(p != NULL){

        printf("获取到第二个字符串p = %s\n",p);
    }

    p = strtok(NULL,ps);  
    if(p != NULL){

        printf("获取到第三个字符串p = %s\n",p);
    }

    p = strtok(NULL,ps);   
    if(p != NULL){

        printf("获取到第四个字符串p = %s\n",p);
    }

    system("pause");
    return(0);
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

可以看到上面这一种字符串的分割方法有点啰嗦，可以用循环对代码进行优化

如下

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
int main()
{
    char *p = NULL;
    char pstr[128] = "hello1,world1,hello2,world2";
    char *ps = ",";
    int i = 1;
    char* pstrarray[10];  //pstrarray[10]用来存放分割的字符串
    p = strtok(pstr,ps);
    if(p != NULL){

        printf("获取到第%d个字符串p = %s\n",i,p);
        pstrarray[i-1] = p;
    }

    while(1){
        i++;
        p = strtok(NULL,ps);
        if(p != NULL){
            
            pstrarray[i-1] = p;
            printf("获取到第%d个字符串p = %s\n",i,p);
        }
        else{

            printf("没有子串了\n");
            break;
        }

    }

    int j;                    //i最后 = 5,pstrarry最后只是到了pstrarry[3]（需要访问4次）
    for(j = 0;j < i-1;j++){  //如果是j < i会访问5次，会出现乱码，所以是i-1
                                                                                                
        puts(pstrarray[j]);
    }
    system("pause");
    return(0);
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

9、strlwr() 和 strupr()

C语言中，strlwr函数和strupr函数的用法都是直接传入字符串调用，strlwr函数的作用是将字符串参数转换为小写形式。strupr函数的作用是将字符串参数转换为大写形式。

strlwr函数原型为extern char *strlwr(char *s);函数功能是将字符串s转换为小写形式，（只转换s参数中出现的大写字母，不改变其它字符），返回指向s参数的指针。

strupr函数原型是extern char *strupr(char *s);函数功能是将字符串s转换为大写形式，（只转换s参数中出现的小写字母，不改变其它字符），返回指向s参数的指针。

示例代码

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
int main()
{

    char pstr[12] = "HELLO";
    char pstr1[12] = "hello";
    char *p = NULL;
    char *p1 = NULL; 
    p = strlwr(pstr);
    p1 = strupr(pstr1);
    printf("大写转换为小写为%s\n",p);
    printf("小写转换为大写为%s\n",p1);
    system("pause");
    return(0);
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19