Linux C编程--string.h函数解析

合集下载

string.h头文件函数说明

string.h头文件函数说明

头文件:<string.h>1、strcat原型:extern char *strcat(char *dest,char *src);功能:把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')。

说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

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

2、strncat原型:char * strncat(char *dest, const char *src, size_t n);//dest指向目标字符串,src为指向源字符串。

功能:把src所指字符串的前n个字符添加到dest所指字符串的结尾处,并覆盖dest所指字符串结尾的'\0',从而实现字符串的连接。

说明:src和dest所指内存区域不可以重叠,并且dest必须有足够的空间来容纳src的字符串。

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

3、4、memcmp原型:intmemcmp(const void *buf1, const void *buf2, unsigned int count);功能:比较内存区域buf1和buf2的前count个字节。

说明:该函数是按字节比较的。

返回:当buf1<buf2时,返回值-1;当buf1==buf2时,返回值=0;当buf1>buf2时,返回值1。

5、memcpy原型:void *memcpy(void *dest, const void *src, size_t n);功能:从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中说明:1.source和destin所指的内存区域可能重叠,但是如果source和destin所指的内存区域重叠,那么这个函数并不能够确保source所在重叠区域在拷贝之前不被覆盖。

而使用memmove可以用来处理重叠区域。

c语言string函数详解

c语言string函数详解

c语言string函数详解linux kernel code : kernel/lib/string.cstrsep,strtok,strchr ,strstr ......PS:本文包含了大部分strings函数的说明,并附带举例说明。

本来想自己整理一下的,发现已经有前辈整理过了,就转了过来。

@函数原型: char *strdup(const char *s)函数功能: 字符串拷贝,目的空间由该函数分配函数返回: 指向拷贝后的字符串指针参数说明: src-待拷贝的源字符串所属文件: <string.h>[cpp] view plain copy1.#include <stdio.h>2.#include <string.h>3.#include <alloc.h>4.int main()5.{6.char *dup_str, *string="abcde";7.dup_str=strdup(string);8.printf("%s", dup_str);9.free(dup_str);10.return 0;11.}@函数名称: strcpy函数原型: char* strcpy(char* str1,char* str2);函数功能: 把str2指向的字符串拷贝到str1中去函数返回: 返回str1,即指向str1的指针参数说明:所属文件: <string.h>[cpp] view plain copy1.#include <stdio.h>2.#include <string.h>3.int main()4.{5.char string[10];6.char *str1="abcdefghi";7.strcpy(string,str1);8.printf("the string is:%s\n",string);9.return 0;10.}@函数名称: strncpy函数原型: char *strncpy(char *dest, const char *src,intcount)函数功能: 将字符串src中的count个字符拷贝到字符串dest中去函数返回: 指向dest的指针参数说明: dest-目的字符串,src-源字符串,count-拷贝的字符个数所属文件: <string.h>[cpp] view plain copy1.#include<stdio.h>2.#include<string.h>3.int main()4.{5.char*src = "bbbbbbbbbbbbbbbbbbbb";//20 'b's6.char dest[50] ="aaaaaaaaaaaaaaaaaaaa";//20 'a's7.8.puts(dest);9.strncpy(dest, src, 10);10.11.puts(dest);12.return0;13.}输出:[cpp] view plain copy1./*******************************************2.aaaaaaaaaaaaaaaaaaaa3.bbbbbbbbbbaaaaaaaaaa4.*******************************************/注意:strncpy只复制指定长度的字符,不会自动在末尾加'\0'。

c语言string函数

c语言string函数

c语言string函数
标准 C 语言的string.h头文件中定义了一组有用的函数,被称为字符串处理函数。

字符串就是由字母,数字和符号组成的一行字符序列,通常以字符串结尾显示。

它是一种数据抽象,是用来存储,分析,表示和处理应用程序中的文本数据的一种常见方式。

1.strlen()函数:该函数用来计算字符串的长度,不包括字符串结尾的null字符
'\0'。

该函数所返回的字符数不包括null字符,而只代表字符串中实际的字符数。

2.strcat()函数:该函数的作用是将字符串s2拼接到字符串s1的末尾。

这意味着s1的末尾会出现字符串s2的第一个字符,直到结束符'\0'。

4.strcmp()函数:该函数用于比较两个字符串s1和s2,如果s1>s2,函数会返回正值;如果s1=s2,函数会返回0;如果s1
5.strchr()函数:该函数用于在字符串s1中查找给定字符c。

如果成功,函数会返回指向找到字符的指针;否则,函数会返回NULL。

7.strtok()函数:该函数用于将字符串分割成一系列子字符串,每个子字符串以一个或多个指定的分隔符分隔。

以上就是标准C语言的string.h头文件中的一些常用的字符串处理函数,这些函数主要用于对字符串的操作,如切割,拼接,比较等。

由于 C 语言的数据结构比较简单,因此这个头文件函数的功能也是非常强大的,可以满足各种字符串处理的需求。

C标准库源码解剖(4):字符串处理函数string.h和wchar.h

C标准库源码解剖(4):字符串处理函数string.h和wchar.h

C标准库源码解剖(4):字符串处理函数string.h和wchar.h简要介绍资料的主要内容,以获得更多的关注C标准库源码解剖(4):字符串处理函数string.h和wchar.h分类:C 20XX年-10-08 12:39 648人阅读评论(1) 收藏举报string.h中包含了所有的字符串处理函数,也包含了内存处理函数,因为这些内存处理函数(如比如、复制、搜索)的功能与字符串处理函数功能类似。

我们是用通用指针来指向内存块的,通用指针可以用char*类型(传统C语言),也可以用void*类型(标准C语言)。

每个函数都有对应的宽字符版本,在wchar.h中。

string.h中包含的标准库函数:strcat,strncat,strcmp,strncmp,strcpy,strncpy,strlen,strchr,strrchr,strspn,strcsp n,strpbrk, strstr,strok,strcoll,strxfrm,strerror;memcpy,memmove,memcmp,memchr,memeset。

GNU还提供了很多非标准的扩展,如memccpy,rawmemchr,memrchr, strdup,strndup等。

view plaincopy to clipboardprint? 1. /* ISO C99 Standard: 7.21 字符串处理string.h */2. #ifndef _STRING_H3. #define _STRING_H 14. #include features.h /* 非标准头文件,定义了一些编译选项*/5. __BEGIN_DECLS6. /* 从stddef.h中获得size_t和NULL */7. #define __need_size_t8. #define __need_NULL9. #include stddef.h10. __BEGIN_*****CE_STD11. /* 从SRC中复制N个字节的内容到DEST中*/12. extern void *memcpy (void *__restrict __dest,13. __const void *__restrict __src, size_t __n)14. __THROW __nonnull ((1, 2));15. /* 从SRC中复制N个字节的内容到DEST中,保证对重叠字符串(即SRC与DEST共用存储空间)有正确的行为*/16. extern void *memmove (void *__dest, __const void *__src, size_t __n)17. __THROW __nonnull ((1, 2));18. __END_*****CE_STD19. /* 从SRC中复制不超过N个字节的内容到DEST中,当遇到字符C返回DEST中C的拷贝后面的字符指针。

c语言中string.h库函数

c语言中string.h库函数

C语言中的`string.h`库函数是一组用于处理字符串的函数,包括字符串的复制、连接、比较、查找等操作。

以下是一些常用的`string.h`库函数:1. `strcpy(char *dest, const char *src)`:将字符串src复制到dest中,返回dest。

2. `strncpy(char *dest, const char *src, size_t n)`:将字符串src的前n个字符复制到dest中,返回dest。

3. `strcat(char *dest, const char *src)`:将字符串src连接到dest的末尾,返回dest。

4. `strncat(char *dest, const char *src, size_t n)`:将字符串src的前n个字符连接到dest的末尾,返回dest。

5. `strcmp(const char *a, const char *b)`:比较两个字符串a和b,返回0表示相等,返回大于0表示a大于b,返回小于0表示a小于b。

6. `strncmp(const char *a, const char *b, size_t n)`:比较两个字符串a和b的前n个字符,返回0表示相等,返回大于0表示a大于b,返回小于0表示a小于b。

7. `strstr(const char *haystack, const char *needle)`:在字符串haystack中查找字符串needle首次出现的索引,如果未找到则返回NULL。

8. `strtok(const char *token, const char *delim)`:将字符串按照指定的分隔符进行分割,返回分割后的子字符串。

9. `strspn(const char *s, const char *re)`:返回字符串s中匹配子串re的个数。

10. `strpbrk(const char *s, const char *delim)`:返回字符串s中首次出现匹配子串delim的索引,如果未找到则返回NULL。

string.h 函数

string.h 函数

string.h是C 语言标准库中的一个头文件,它包含了处理字符串的函数。

以下是一些在string.h中常见的函数:1.strcpy(): 复制一个字符串到另一个字符串。

c复制代码char *strcpy(char *dest, const char *src);2.strcat(): 将一个字符串附加到另一个字符串的末尾。

c复制代码char *strcat(char *dest, const char *src);3.strlen(): 返回一个字符串的长度(不包括终止字符)。

c复制代码size_t strlen(const char *s);4.strcmp(): 比较两个字符串。

c复制代码int strcmp(const char *s1, const char *s2);5.strchr(): 在字符串中查找第一个出现的指定字符。

c复制代码char *strchr(const char *s, int c);6.strstr(): 在字符串中查找子字符串的首次出现。

c复制代码char *strstr(const char *haystack, const char *needle);7.memcpy(): 从源地址复制指定数量的字节到目标地址。

c复制代码void *memcpy(void *dest, const void *src, size_t n);8.memset(): 将内存区域设置为给定的值。

c复制代码void *memset(void *s, int c, size_t n);9.memmove(): 从源地址复制字节到目标地址,可以处理重叠的内存区域。

c复制代码void *memmove(void *dest, const void *src, size_t n);10.bzero(): 将内存区域设置为零。

这是一个非标准的函数,但在一些旧的代码中可能会看到。

在新的代码中,建议使用memset。

Linux下常用C语言字符串操作函数

Linux下常用C语言字符串操作函数

Linux下常用C语言字符串操作函数stroul,strdupsnprintf()atioC中常用字符串操作函数#include <string.h>size_t strlen(const char *s) 测量字符串长度s的实际长度。

例如s[20]="abc",那么strlen(s)的结果是3,而不是20.这就是实际长度char *strcat(const char *s1, const *s2) 将字符串s2连接到s1的尾部。

从s1的\0开始。

int strcmp(const *s1,const *s2) 比较s1和s2。

s1 = s2的时候返回值=0s1 < s2的时候返回至<0s1 > s2的时候返回值>0char *strchr(const char *s, char c); 返回s中首次出现C的位置的指针。

如果s中不存在c则返回NULLchar *strrchr(const char *s, char c );返回s中最后一次出现c的位置的指针。

如果没有,则返回0char *strstr(const char *haystack, const char *needle);返回haystack中needle字符串首次出现的位置的指针(不比较结束符NULL)。

若果没找到则返回NULL限定长度的比较,拷贝和追加函数int strncmp(char *s1, const char *s2, size_t n);(这些都是针对字符串的前n个字符来操作的)char *strncpy(char *dest, const char *src, size_t n);char *strncat(char *dest, const char *src, size_t n);char *strdup(char *s)返回指向被复制的字符串的指针,所需空间由malloc()分配而且需要free释放空间int atoi(const char *nptr);将字符串转换成整型数atoi()会扫描参数nptr字符串,跳过前面的空格,直到遇上数字或者正负号才开始装换,而再遇到非数字或者非字符串结束时('\0')其实ato是一族将字符转换为数的函数,atof,atol:他们分别是将字符串转换成浮点型,长整型数。

linux c 字符查找函数

linux c 字符查找函数

linux c 字符查找函数“Linux C字符查找函数”是指在Linux操作系统的C编程环境中,专门用于查找特定字符的函数集合。

这些函数通常用于字符串处理、文本分析和模式匹配等应用场景。

本文将从基本定义、常用函数、示例代码以及注意事项等方面一步步回答关于“Linux C字符查找函数”的问题。

首先,我们来理解一下“字符查找函数”的基本定义。

在Linux C 编程环境中,字符查找函数是指用于在字符串中查找指定字符的函数。

它们可以帮助我们快速定位并处理字符串中的特定字符,以满足不同的需求。

这些函数通常属于C标准库的一部分,可以在开发中直接引用,无需额外的安装或配置。

在Linux C编程环境中,有许多常用的字符查找函数可供选择。

下面我们将逐一介绍一些常见的函数及其用法。

1. strchr函数:在字符串中查找第一个指定字符的位置。

该函数的原型为:cchar *strchr(const char *str, int c);其中,str是待查找的字符串,c是要查找的字符。

函数返回第一个匹配字符的指针,若找不到则返回NULL。

2. strrchr函数:在字符串中查找最后一个指定字符的位置。

该函数的原型为:cchar *strrchr(const char *str, int c);与strchr函数类似,只是它从字符串的末尾开始查找,并返回最后一个匹配字符的指针。

3. strstr函数:在字符串中查找第一次出现指定串的位置。

该函数的原型为:cchar *strstr(const char *haystack, const char *needle);haystack是待查找的字符串,needle是要查找的子串。

函数返回第一次匹配子串的指针,若找不到则返回NULL。

4. strpbrk函数:在字符串中查找任意字符集中的字符的位置。

该函数的原型为:cchar *strpbrk(const char *str, const char *charset);str是待查找的字符串,charset是要查找的字符集。

string.h截取字符串用法

string.h截取字符串用法

string.h截取字符串用法
在C语言中,可以使用string.h头文件中的函数来截取字符串。

具体来说,可以使用strncpy()函数来实现字符串的截取。

strncpy()函数的原型如下:
c.
char strncpy(char dest, const char src, size_t n);
这个函数将源字符串src的前n个字符复制到目标字符串dest 中。

如果源字符串的长度小于n,那么目标字符串将用空字符进行
填充以保证总共复制了n个字符。

如果源字符串的长度大于或等于n,那么目标字符串将不会以空字符结尾。

需要注意的是,strncpy()并不会在目标字符串的末尾添加空字符,因此需要手动添加以保证
目标字符串的完整性。

另外,还可以使用strcpy()函数和strcat()函数来实现字符串
的截取。

strcpy()函数用于将一个字符串复制到另一个字符串中,
而strcat()函数用于将一个字符串追加到另一个字符串的末尾。

除了上述函数之外,还可以使用指针来实现字符串的截取。


过移动指针并逐个复制字符,可以实现对字符串的截取操作。

总的来说,通过使用string.h头文件中的函数,结合指针操作,可以灵活地实现字符串的截取操作。

在实际使用中,需要根据具体
的需求选择合适的方法来进行字符串的截取。

C语言string.h中的字符串函数

C语言string.h中的字符串函数

C语⾔string.h中的字符串函数C语⾔标准库头⽂件 <string.h> 定义了⼀个变量类型、⼀个宏和两组字符串函数,⼀组函数的名字以str开头,还有⼀组函数的名字以mem开头。

1、⼀个变量类型size_t:⽆符号整型(unsigned int),是sizeof操作符返回的结果类型,在64位系统中为 long unsigned int。

代码⽰例运⾏结果其中,%zu ⽤来输出 size_t 类型。

2、⼀个宏NULL:空指针常量的值3、以str开头的函数size_t strlen(const char *str)计算字符串 str 的长度,直到空结束字符'',不包括空结束字符。

char *strcpy(char *dest, const char *src)把 src 所指向的字符串复制到 dest。

char *strncpy(char *dest, const char *src, size_t n)同上,把 src 所指向的字符串的前n个字符复制到 dest。

char *strcat(char *dest, const char *src)把 src 所指向的字符串追加到 dest 所指向的字符串的结尾,实现字符串的连接。

char *strncat(char *dest, const char *src, size_t n)同上,把src所指字符串的前n个字符添加到dest所指字符串的结尾处,并覆盖dest所指字符串结尾的'',实现字符串的连接。

char *strchr(const char *str, int c)在参数 str 所指向的字符串中搜索第⼀次出现字符 c(⽆符号字符)的位置,如果str中没有c,则返回NULL。

char *strrchr(const char *str, int c)在参数 str 所指向的字符串中搜索最后⼀次出现字符 c(⽆符号字符)的位置,如果str中没有c,则返回NULL。

C语言中常用的string.h的字符函数

C语言中常用的string.h的字符函数

C语⾔中常⽤的string.h的字符函数strcmp字符串⽐较函数原型:int strcmp(char *str1, char *str2);例⼦:if(strcmp(buf1,buf2)>0) printf("buffer 1 is greater than buffer 2.\n");str1>str2,返回值 > 0(⼀般返回1),两串相等,返回0strlen字符串长度函数原型:int strlen(const char *s);例⼦:char *buf1="haha"; len=strlen(buf1); //len=4strstr查找字符串str2在str1第⼀次出现的位置原型:char *strstr(char *str1, char *str2);例⼦:char *str1 = "She is prrety", *str2 = "he", *ptr;ptr = strstr(str1, str2);printf("The substring is: %s\n", ptr);printf("The position is:%d\n",ptr-str1);//输出://The substring is: he is prrety//The position is:1strcpy拷贝字符串原型:char *strcpy(char *destin, char *source);例⼦:char string[10];char *str1 = "abcdefghi";strcpy(string, str1);printf("%s\n", string);//输出://abcdefghistrncpystrncpy(string, str1,3);//string=str1的前三个字符strcat字符串拼接函数原型:char *strcat(char *destin, char *source);例⼦:char str[25];char *str1 ="I am", *str2 = " Lucy.";strcpy(str,str1); //先复制str1的内容strcat(str,str2); //再接上str2的内容printf("%s\n", str);//输出//I am Lucy.要注意的是,strcat的第⼀个参数只能是str这样定义的数组,不能是指针str1 strchr查找字符在字符串的位置原型:char *strchr(char *str, char c);例⼦:char string[15]="BUPT";char *ptr, c = 'U';ptr = strchr(string, c);if (ptr)printf("The character %c is at position: %d\n", c, ptr-string);elseprintf("The character was not found\n");//输出://The character %c is at position: 1。

linux中返回值为字符串的函数

linux中返回值为字符串的函数

linux中返回值为字符串的函数在Linux 中,一个返回字符串的函数通常会返回一个字符串指针或使用引用参数来返回字符串。

以下是两种常见的方法:1. 返回字符串指针:```c#include <stdio.h>#include <stdlib.h>#include <string.h>// 返回动态分配的字符串指针char* getString() {char* str = (char*)malloc(20 * sizeof(char)); // 为字符串分配内存strcpy(str, "Hello, World!"); // 将字符串拷贝到分配的内存中return str;}int main() {char* result = getString();printf("String: %s\n", result);free(result); // 释放动态分配的内存return 0;}```上述例子中,`getString` 函数返回一个动态分配的字符串指针,需要在使用后手动释放内存。

2. 使用引用参数:```c#include <stdio.h>// 通过引用参数返回字符串void getString(char str) {*str = "Hello, World!";}int main() {char* result;getString(&result);printf("String: %s\n", result);return 0;}```在这个例子中,`getString` 函数通过引用参数将字符串赋给了指针`result`。

请注意,在使用这些方法时,要确保在使用完字符串后适当地释放内存,以免造成内存泄漏。

在真实的应用中,你可能需要根据具体情况来选择使用哪种方法。

string.h下相关函数介绍

string.h下相关函数介绍

strcat语法:功能:函数将字符串str2连接到str1的末端,并返回指针str1. 例如:printf( "Enter your name: " );scanf( "%s", name );title = strcat( name, " the Great" );printf( "Hello, %s\n", title );相关主题:strchr(), strcmp(), and strcpy().strchr语法:功能:函数返回一个指向str中ch首次出现的位置,当没有在str中找ch到返回NULL。

相关主题:strpbrk(), strspn(), strstr(), and strtok().strcmp语法:功能:比较字符串str1 and str2, 返回值如下:例如:printf( "Enter your name: " );scanf( "%s", name );if( strcmp( name, "Mary" ) == 0 )printf( "Hello, Dr. Mary!\n" );相关主题:memcmp(), strchr(), strcpy(), and strncmp().strcoll语法:功能:比较字符串str1和str2, 很象strcmp. 但是, strcoll() 使用在目前环境中由setlocale()设定的次序进行比较。

strcpy语法:功能:复制字符串from中的字符到字符串to,包括空值结束符。

返回值为指针to。

相关主题:memcpy(), strchr(), strcmp(), strncmp(), and strncpy().strcspn语法:功能:函数返回str1开头连续n个字符都不含字符串str2内字符的字符数。

string.h函数

string.h函数

`string.h` 是C 语言标准库中的一个头文件,它包含了一系列用于处理字符串的函数。

下面是一些常用的`string.h` 函数:1. `strlen(s)`: 返回字符串 `s` 的长度,不包括终止字符 `\0`。

2. `strcpy(dest, src)`: 将字符串 `src` 复制到字符串 `dest`。

3. `strcat(dest, src)`: 将字符串 `src` 追加到字符串 `dest` 的末尾。

4. `strcmp(s1, s2)`: 比较字符串 `s1` 和 `s2`。

如果它们相等,则返回 0;如果 `s1` 在字典中位于 `s2` 之前,则返回一个负值;如果 `s1` 在字典中位于 `s2` 之后,则返回一个正值。

5. `strchr(s, c)`: 在字符串 `s` 中查找字符 `c` 的第一次出现。

6. `strstr(s1, s2)`: 在字符串`s1` 中查找子字符串 `s2` 的第一次出现。

7. `strcspn(s, accept)`: 在字符串 `s` 中查找第一个不属于集合`accept` 的字符的位置。

8. `strpbrk(s, accept)`: 在字符串`s` 中查找第一个属于集合`accept` 的字符的位置。

9. `strtok(s, delimiters)`: 将字符串 `s` 分割成子字符串,使用指定的分隔符字符集 `delimiters`。

10. `strtol(s, endptr, base)`: 将字符串`s` 转换为长整型数,其中 `endptr` 指向转换后的字符串中的第一个非数字字符,`base` 指定转换的基数(2-36)。

11. `strtoul(s, endptr, base)`: 将字符串 `s` 转换为无符号长整型数。

这些函数提供了基本的字符串操作功能,包括复制、比较、查找、分割和转换等。

请注意,在使用这些函数时,应确保目标字符串有足够的空间来存储结果,以避免缓冲区溢出等安全问题。

LinuxC函数之字符串处理函数

LinuxC函数之字符串处理函数

LinuxC函数之字符串处理函数字符串处理函数(13, 19)这些函数的头文件都是string.h非str前缀的字符串操作bcmp: 比较内存中的内容, 建议用memcmp()取代函数定义: int bcmp(const void *s1, const void *s2, int n);说明: 用来比较s1和s2所指的内存区前n个字节, 若参数n为0, 则返回0. 若参数s1和s2所指的内存完全相同返回0值, 否则返回非0值.bcopy: 拷贝内存内容, 建议用memcpy()取代函数定义: void bcopy(const void *src, void *dest, int n);说明: bcopy()和memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址, 不过, 参数scr和dest在传给函数时位置是相反的.bzero: 将一段内存内容全清为0, 建议用bzero()取代函数定义: void bzero(void *s, int n);说明: bzero()会将参数s所指的内存区域前n个字节, 全部设为0. 相当于调用memset(void *s, 0, size_t n);ffs: 在一个整型数(2进制表示)中查找第一个值为1的位函数定义: int ffs(int i);说明: ffs()会由低位至高位, 判断参数i的2进制中每一位, 将最先出现位的值为1的位置返回. 若i为0, 返回0.应用举例:#include <stdio.h>#include <string.h>int main(void){int num[7] = {0, 1, 2, 3, 4, 5, 8};int i;for(i = 0; i < 7; i++){printf("%d: %d\n", num[i], ffs(num[i]));}return 0;}运行结果:0: 0 1: 1 2: 2 3: 1 4: 3 5: 1 8: 4index: 查找字符串中第一个出现的指定字符函数定义: char *index(const char *s, int c);说明: index()用来找出参数s字符串中第一个出现的参数c的地址, 然后将该字符出现的地址返回, 结束符也视为字符串的一部分. 返回值, 如果找到指定的字符则返回该字符所在地址, 否则返回0.rindex: 查找字符串中最后一个出现的指定字符函数定义: char *rindex(const char *s, int c);说明: rindex()用来找出参数s字符串中最后一个出现的参数c的地址, 然后将该字符出现的地址返回, 结束符也视为字符串的一部分. 返回值, 如果找到指定的字符则返回该字符所在地址, 否则返回0.应用举例:#include <stdio.h>#include <string.h>int main(void){const char *s = "1234556554321";char *p;printf("%s\n", s);printf("%s\n", index(s, '5'));printf("%s\n", rindex(s, '5'));p = memchr(s, '5', 3);if(p == NULL)printf("NULL\n");elseprintf("%s\n", p);printf("%s\n", memchr(s, '5', 8));return 0;}运行结果:123455655432155655432154321NULL556554321memchr: 在某一内存范围中找一特定字符函数定义: void *memchr(const void *s, int c, size_t n);说明: memchr()从头开始搜寻s所指内存的前n个字节, 直到发现第一个值为c的字符, 则返回指向该字符的指针. 如果找不到就返回0.应用举例: 见index和rinedxmemcmp: 比较内存内容函数定义: int memcmp(const void *s1, const void *s2, size_t n);说明: memcmp()用来比较s1和s2所指的内存区间前n个字符. 字符串大小的比较是以ASCII表上的顺序来决定, 此顺序亦为字符的值. memcmp()首先将s1第一个字符值减去s2第一个字符值, 若差值为0则再继续比较下个字符, 若不为0则将等差值返回. 返回值, 若s1和s2相等则返回0, 若s1大于s2则返回大于0的值, 若s1小于s2则返回小于0的值.应用举例:#include <stdio.h>#include <string.h>int main(void){const char *s1 = "123asd";const char *s2 = "123edf";int nR;nR = memcmp(s1, s2, sizeof(s1));if(nR == 0)printf("0\n");else if(nR > 1)printf("1\n");elseprintf("-1\n");return 0;}运行结果:-1memset: 将一段内存空间填入某值函数定义: void *memset(void *s, int c, size_t n);说明: memset()会将参数s所指向的内存区域前n个字节以参数c填入, 然后返回指向s的指针. 在编写程序时, 若需要将某一数组初始化, 使用memset(). 返回指向s的指针. 注意, 参数c虽然声明为int, 但必须是unsigned char, 所以范围在0到255之间.应用举例:#include <stdio.h>#include <string.h>int main(void){char s[5];memset(s, 'a', sizeof(s));s[4] = '\0';printf("%s\n", s);return 0;}运行结果:aaaamemfrob: 对内存区域编码, Linux特有函数定义: void *memforb(void *s, size_t n);说明: memfrob()用来将参数s所指的内存空间前n个字符与42作XOR运算, 用途是可以隐藏一特定字符串内容, 只要再用相同的参数调用memfrob()即可将内容还原.应用举例:#include <stdio.h>#include <string.h>int main(void){char s[] = "Funtion memfrob tests.";printf("%s\n", s);memfrob(s, strlen(s));printf("%s\n", s);memfrob(s, strlen(s));printf("%s\n", s);return 0;}运行结果:Funtion memfrob tests.l_D^CEDGOGLXEH^OY^YFuntion memfrob tests.memcpy: 拷贝内存内容函数定义: void *memcpy(void *dest, void *scr, size_t n);说明: memcpy()用来拷贝src所指的内存前n个字节到dest所指的地址上. 于strcpy()不同, memcpy()会完整的复制n个字节, 不会因遇到结束符'\0'而结束. 返回指向dest的指针. 注意, 指针src和dest所指的内存区域不可重叠.memccpy: 拷贝内存内容函数定义: void *memccpy(void *dest, const void *src, int c, size_t n);说明: memccpy()用来拷贝src所指的内存前n个字节到dest所指的地址上. 与memcpy()不同的是, memccpy()会在复制时检查参数c是否出现, 若是出现则返回dest中的值为c的下一个字节地址. 返回0表示在scr中前n个字节中没有c.memmove: 拷贝内存内容函数定义: void *memmove(void *dest, const void *src, size_t n);说明: memmove()和memcpy()一样用来拷贝src所指的内存前n个字节到dest所指的地址上. 不同的是memmove()的scr和dest 所指的内存区域可以重叠. 返回值指向dest的指针.应用举例:#include <stdio.h>#include <string.h>int main(void){char src[] = "abcdefghi\0";char dest1[10];char dest2[10];char dest3[10];printf("%s\n", src);memcpy(dest1, src, 10);memccpy(dest2, src, 'c', 10);//没用明白memmove(dest3, src, 10);printf("%s\n", dest1);printf("%s\n", dest2);printf("%s\n", dest3);return 0;}运行结果:abcdefghiabcdefghiabcx<abcdefghiabcdefghistr前缀的字符串操作1. 字符串比较strcmp: 比较字符串函数定义: int strcmp(const char *s1, const char *s2);说明: strcmp()用来比较参数s1和s2字符串. 字符串大小的比较是以ASCII码表上的顺序来决定, 此顺序亦为字符的值. strcmp()首先将s1第一个字符值减去s2第一个字符值,若差值为0则再继续比较下个字符, 若差值不为0则将差值返回. 若参数s1和s2字符串相同则返回0, s1若大于s2则返回大于0的值, s1若小于s2则返回小于0的值.strncmp: 比较字符串(指定数目)函数定义: int strncmp(const char *s1, const char *s2, size_t n);说明: strncmp()用来比较参数s1和s2字符串前n个字符. 若参数s1和s2字符串相同则返回0, s1若大于s2则返回大于0的值, s1若小于s2则返回小于0的值.strcasecmp: 忽略大小写比较字符串函数定义: int strcasecmp(const char *s1, const char *s2);说明: strcasecmp()用来比较参数s1和s2字符串, 比较时会自动忽略大小写的差异. 若参数s1和s2字符串相同则返回0, s1若大于s2则返回大于0的值, s1若小于s2则返回小于0的值.strncasecmp: 忽略大小写比较字符串(指定数目)函数定义: int strncasecmp(const char *s1, const char *s2, size_t n);说明: strncasecmp()用来比较参数s1和s2字符串前n个字符, 比较时会自动忽略大小写的差异. 若参数s1和s2字符串相同则返回0, s1若大于s2则返回大于0的值, s1若小于s2则返回小于0的值.strcoll: 采用目前区域的字符排列次序来比较字符串函数定义: int strcoll(const char *s1, const char *s2);说明: strcoll()会依环境变量LC_COLLATE所指定的文字排列次序来比较s1和s2字符串. 若参数s1和s2字符串相同则返回0, s1若大于s2则返回大于0的值, s1若小于s2则返回小于0的值.附加说明: 若LC_COLLATE为“POSIX”或“C”, 则strcoll()与strcmp()作用完全相同.应用举例:#include <stdio.h>#include <string.h>int main(void){char *src = "abcdefefdsa";char *cmp = "abcdEFe";printf("%d ", strcmp(src, cmp));printf("%d ", strncmp(src, cmp, 6));printf("%d ", strcasecmp(src, cmp));printf("%d ", strncasecmp(src, cmp, 6));printf("\n");return 0;}运行结果:1 32 102 02. 字符串连接strcat: 连接两个字符串函数定义: char *strcat(char *dest, const char *src);说明: strcat()会将参数src字符串拷贝到参数dest所指的字符串尾. 注意, 第一个参数dest要有足够的空间来容纳要拷贝的字符串. 返回参数dest的字符串起始地址.strncat: 连接两个字符串(指定数目)函数定义: char *strncat(char *dest, const char *src, size_t n);说明: strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾. 注意, 第一个参数dest要有足够的空间来容纳要拷贝的字符串. 返回参数dest的字符串起始地址.应用举例:#include <stdio.h>#include <string.h>int main(void){char *src = "abcdefghi";char dest1[30] = "jklmn";char dest2[30] = "jklmn";printf("%s\n", src);printf("%s\n", dest1);strcat(dest1, src);printf("%s\n", dest1);strncat(dest2, src, 6);printf("%s\n", dest2);return 0;}运行结果:abcdefghijklmnjklmnabcdefghijklmnabcdef3. 字符串查找strchr: 查找字符串中第一个出现的指定字符函数定义: char *strchr(const char *s, int c);说明: strrchr()用来找出参数s字符串中第一个出现的参数c地址, 然后将该字符出现的地址返回. 如果找不到就返回0.strrchr: 查找字符串中最后一个出现的指定字符函数定义: char *strrchr(const char *s, int c);说明: strrchr()用来找出参数s字符串中最后一个出现的参数c地址, 然后将该字符出现的地址返回. 如果找不到就返回0.strpbrk: 查找字符串中第一个出现的多个指定字符中的一个字符函数定义: char *strpbrk(const char *s, const char *accept);说明: strpbrk()用来找出参数s字符串中最先出现存在参数accept字符串中的任意字符. 如果找不到返回0.strstr: 在一字符串中查找指定的字符串函数定义: char *strstr(const char *haystack, const char *needle);说明: strstr()会从字符串haystack中搜寻字符串needle, 并将第一次出现的地址返回. 如果找到指定的字符则返回该字符所在地址,否则返回0.strcspn: 返回字符串中从头开始连续不含指定字符串内容的字符数函数定义: size_t strcspn(const char *s ,const char *reject);说明: strcspn()从参数s字符串的开头计算连续的字符, 而这些字符都完全不在参数reject所指的字符串中. 简单地说, 若strcspn()返回的数值为n, 则代表字符串s开头连续有n个字符都不含字符串reject内的字符.strspn: 返回字符串中从头开始连续含指定字符串内容的字符数函数定义: size_t strspn(const char *s, const char *accept);说明: strspn()从参数s字符串的开头计算连续的字符, 而这些字符都完全是accept所指字符串中的字符. 简单的说, 若strspn()返回的数值为n, 则代表字符串s开头连续有n个字符都是属于字符串accept内的字符.应用举例:#include <stdio.h>#include <string.h>int main(void){char *src = "15648499166581";char *pchr, *prchr, *ppbrk, *pstr;int ncspn, nspn;pchr = strchr(src, '5');prchr = strrchr(src, '5');ppbrk = strpbrk(src, "6489");pstr = strstr(src, "849");ncspn = strcspn(src, "489");nspn = strspn(src, "916");printf("%s\n", src);printf("%s\n", pchr);printf("%s\n", prchr);printf("%s\n", ppbrk);printf("%s\n", pstr);printf("%d\n", ncspn);printf("%d\n", nspn);return 0;}运行结果:1564849916658156484991665815816484991665818499166581314. 字符串拷贝strcpy: 拷贝字符串函数定义: char *strcpy(char *dest, const char *scr);说明: strcpy()会将参数src字符串拷贝至参数dest所指的地址. 返回参数dest的字符串起始地址. 注意, 如果参数dest所指的内存空间不够大, 可能会造成缓冲溢出的错误情况,在编写程序时请特别留意, 或用strncpy()来取代.strncpy: 拷贝字符串(指定数目)函数定义: char *strncpy(char *dest, const char *src, size_t n);说明: strncpy()会将参数src字符串拷贝前n个字符至参数dest 所指的地址, 返回参数dest的字符串起始地址strdup: 拷贝字符串(自动配置内存空间)函数定义: char *strdup(const char *s);说明: strdup()会先用maolloc()配置与参数s字符串相同的空间大小, 然后将参数s字符串的内容复制到该内存地址, 然后把该地址返回. 该地址最后可以利用free()来释放. 返回一指向复制后的新字符串地址的指针; 若返回NULL表示内存不足.应用举例:#include <stdio.h>#include <string.h>#include <stdlib.h>int main(void){char *src = "abcdefghi";char *destcpy, *destncpy, *destdup;printf("%s\n", src);destcpy = (char *)malloc(strlen(src));strcpy(destcpy, src);printf("%s\n", destcpy);destncpy = (char *)malloc(strlen(src));strncpy(destncpy, src, 6);printf("%s\n", destncpy);destdup = strdup(src);printf("%s\n", destdup);free(destcpy);free(destncpy);free(destdup);return 0;}运行结果:abcdefghiabcdefghiabcdefabcdefghi5. 其它操作strfry: 随机重组字符串内的字符函数定义: char *strfry(char *string);说明: strfry()会利用rand()来随机重新分配参数string字符串内的字符, 然后返回指向参数string的指针.strlen: 返回字符串长度, 不包括结束符'/0'函数定义: size_t strlen(const char *s);说明: strlen()用来计算指定的字符串s的长度, 不包括结束字符'\0'.strtok: 分割字符串函数定义: char *strtok(char *s, const char *delim);说明: strtok()用来将字符串分割成一个个片段. 参数s指向欲分割的字符串, 参数delim则为分割字符串, 当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0字符. 在第一次调用时, strtok()必需给予参数s字符串, 往后的调用则将参数s设置成NULL. 每次调用成功则返回下一个分割后的字符串指针.应用举例:#include <stdio.h>#include <string.h>int main(void){char s[] = "as-vd; efdaf;fe-fdef?";char *d = "-; f";char *ps;printf("%s\t%d\n", s, strlen(s));printf("%s\n", strfry(s));printf("%s ", strtok(s, d));while((ps = strtok(NULL, d))){printf("%s ", ps);}printf("\n");return 0;}运行结果:as-vd; efdaf;fe-fdef? 21;edfvdas-ad; efeff-f?ed vdas ad e e ?。

linux c 提取字符串的文件路径函数

linux c 提取字符串的文件路径函数

linux c 提取字符串的文件路径函数您可以使用`strrchr`函数从字符串中提取文件路径。

该函数在`string.h`头文件中声明。

以下是一个简单的示例:c#include <stdio.h>#include <string.h>char* getFilePath(const char* string) { char* lastSlash = strrchr(string, '/'); if (lastSlash != NULL) { int index = lastSlash - string + 1;char* filePath = malloc(index + 1); strncpy(filePath, string, index); filePath[index] = '\0'; return filePath; } return NULL;}int main() { const char* string = "/home/user/file.txt"; char* filePath = getFilePath(string); if (filePath != NULL) { printf("File path: %s\n", filePath); free(filePath); } else { printf("No file path found.\n"); } return 0;}在上面的示例中,`getFilePath`函数将接受一个字符串作为参数,并返回一个新分配的字符串,其中包含提取的文件路径。

如果在字符串中找不到斜杠字符(`/`),则返回`NULL`。

在`main`函数中,我们将使用`getFilePath`函数来提取文件路径并打印出来。

请注意,为了避免内存泄漏,必须在使用完提取的文件路径后调用`free`函数来释放分配的内存。

C函数_Linux_字符串操作

C函数_Linux_字符串操作

C函数_Linux_字符串操作1.strcat【功能】该函数与strcpy 类似,但是来自于from 的字符将连接或附加到to 的结尾处,而不是覆盖to,即from 的首字符覆盖to 的结尾标志空字符。

【原型】char * strcat (char *to, const char *from)【头文件】#include<string.h>【返回值】返回参数to的字符串起始地址。

【说明】与strcpy 类似。

【示例】2.strncat【功能】将from 中不超过size 个的字符附加到to 结尾处其余与strcat 一样。

一个单独的空字符也常附加到to,因此分配给to 的长度至少比其原长度多size+1 个字节。

【原型】char * strncat (char *to, const char *from, size_t size)【头文件】#include <string.h>【返回值】返回指向to的字符串起始地址。

【说明】如果两个串重叠,strncat 的影响不确定。

【示例】3.strchr【功能】在str 字符串中查找字符c。

【原型】char *strchr(const char *str, int c)【头文件】#include <string.h>【返回值】如果找到指定的字符则返回该字符所在地址, 否则返回NULL。

【说明】返回一个指针,指向str 中出现的一个字符c;如果str 中没有出现c,则strchr 返回NULL。

【示例】4.strrchr【功能】该函数和strchr 类似,但它是从串string 的尾部反向搜索(而不是从前面开始正向搜索)。

【原型】char * strrchr (const char *string, int c)【头文件】#include <string.h>【返回值】如果找到指定的字符则返回该字符所在地址, 否则返回NULL。

Linux C编程--string.h函数解析

Linux C编程--string.h函数解析

生活就是需要有创意--例如:Coding && Debug 分类: Linux C编程 2013-03-06 16:33 486人阅读 评论(0) 收藏举报String.hLinux C编程头文件函数名: stpcpy功能: 拷贝一个字符串到另一个用法: char *stpcpy(char *destin, char *source);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";stpcpy(string, str1);printf("%s\n", string);return 0;}函数名: strcat功能: 字符串拼接函数用法: char *strcat(char *destin, char *source);程序例:#include <string.h>#include <stdio.h>int main(void){char destination[25];char *blank = " ", *c = "C++", *Borland = "Borland"; strcpy(destination, Borland);strcat(destination, blank);strcat(destination, c);printf("%s\n", destination);return 0;}函数名: strchr功能: 在一个串中查找给定字符的第一个匹配之处\用法: char *strchr(char *str, char c);程序例:#include <string.h>#include <stdio.h>int main(void){char string[15];char *ptr, c = 'r';strcpy(string, "This is a string");ptr = strchr(string, c);if (ptr)printf("The character %c is at position: %d\n", c, ptr-string); elseprintf("The character was not found\n");return 0;}函数名: strcmp功能: 串比较用法: int strcmp(char *str1, char *str2);看Asic码,str1>str2,返回值 > 0;两串相等,返回0程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";int ptr;ptr = strcmp(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");elseprintf("buffer 2 is less than buffer 1\n");ptr = strcmp(buf2, buf3);if (ptr > 0)printf("buffer 2 is greater than buffer 3\n");elseprintf("buffer 2 is less than buffer 3\n");return 0;}函数名: strncmpi功能: 将一个串中的一部分与另一个串比较, 不管大小写用法: int strncmpi(char *str1, char *str2, unsigned maxlen);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = strcmpi(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strcpy功能: 串拷贝用法: char *strcpy(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";strcpy(string, str1);printf("%s\n", string);return 0;}函数名: strcspn功能: 在串中查找第一个给定字符集内容的段用法: int strcspn(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *string1 = "1234567890";char *string2 = "747DC8";int length;length = strcspn(string1, string2);printf("Character where strings intersect is at position %d\n", length); return 0;}函数名: strdup功能: 将串拷贝到新建的位置处用法: char *strdup(char *str);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *dup_str, *string = "abcde";dup_str = strdup(string);printf("%s\n", dup_str);free(dup_str);return 0;}函数名: stricmp功能: 以大小写不敏感方式比较两个串用法: int stricmp(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = stricmp(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n"); if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strerror功能: 返回指向错误信息字符串的指针: char *strerror(int errnum);程序例:#include <stdio.h>#include <errno.h>int main(void){char *buffer;buffer = strerror(errno);printf("Error: %s\n", buffer);return 0;}函数名: strcmpi功能: 将一个串与另一个比较, 不管大小写用法: int strcmpi(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = strcmpi(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strncmp功能: 串比较用法: int strncmp(char *str1, char *str2, int maxlen);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc"; int ptr;ptr = strncmp(buf2,buf1,3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");elseprintf("buffer 2 is less than buffer 1\n");ptr = strncmp(buf2,buf3,3);if (ptr > 0)printf("buffer 2 is greater than buffer 3\n"); elseprintf("buffer 2 is less than buffer 3\n");return(0);}函数名: strncmpi功能: 把串中的一部分与另一串中的一部分比较, 不管大小写用法: int strncmpi(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBBccc", *buf2 = "bbbccc";int ptr;ptr = strncmpi(buf2,buf1,3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n"); if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;函数名: strncpy功能: 串拷贝用法: char *strncpy(char *destin, char *source, int maxlen);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";strncpy(string, str1, 3);string[3] = '\0';printf("%s\n", string);return 0;}函数名: strnicmp功能: 不注重大小写地比较两个串用法: int strnicmp(char *str1, char *str2, unsigned maxlen);程序例:#include <string.h>#include <stdio.h>int main(void)char *buf1 = "BBBccc", *buf2 = "bbbccc";int ptr;ptr = strnicmp(buf2, buf1, 3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strnset功能: 将一个串中的所有字符都设为指定字符用法: char *strnset(char *str, char ch, unsigned n);程序例:#include <stdio.h>#include <string.h>int main(void){char *string = "abcdefghijklmnopqrstuvwxyz"; char letter = 'x';printf("string before strnset: %s\n", string);strnset(string, letter, 13);printf("string after strnset: %s\n", string);return 0;}函数名: strpbrk功能: 在串中查找给定字符集中的字符用法: char *strpbrk(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char *string1 = "abcdefghijklmnopqrstuvwxyz";char *string2 = "onm";char *ptr;ptr = strpbrk(string1, string2);if (ptr)printf("strpbrk found first character: %c\n", *ptr); elseprintf("strpbrk didn't find character in set\n");return 0;}函数名: strrchr功能: 在串中查找指定字符的最后一个出现用法: char *strrchr(char *str, char c);程序例:#include <string.h>#include <stdio.h>int main(void){char string[15];char *ptr, c = 'r';strcpy(string, "This is a string");ptr = strrchr(string, c);if (ptr)printf("The character %c is at position: %d\n", c, ptr-string); elseprintf("The character was not found\n");return 0;}函数名: strrev功能: 串倒转用法: char *strrev(char *str);程序例:#include <string.h>#include <stdio.h>int main(void){char *forward = "string";printf("Before strrev(): %s\n", forward); strrev(forward);printf("After strrev(): %s\n", forward); return 0;}函数名: strset功能: 将一个串中的所有字符都设为指定字符用法: char *strset(char *str, char c);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10] = "123456789";char symbol = 'c';printf("Before strset(): %s\n", string); strset(string, symbol);printf("After strset(): %s\n", string);return 0;}函数名: strspn功能: 在串中查找指定字符集的子集的第一次出现用法: int strspn(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *string1 = "1234567890";char *string2 = "123DC8";int length;length = strspn(string1, string2);printf("Character where strings differ is at position %d\n", length); return 0;}函数名: strstr功能: 在串中查找指定字符串的第一次出现用法: char *strstr(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char *str1 = "Borland International", *str2 = "nation", *ptr; ptr = strstr(str1, str2);printf("The substring is: %s\n", ptr);return 0;}函数名: strtod功能: 将字符串转换为double型值用法: double strtod(char *str, char **endptr);程序例:#include <stdio.h>#include <stdlib.h>int main(void){char input[80], *endptr;double value;printf("Enter a floating point number:");gets(input);value = strtod(input, &endptr);printf("The string is %s the number is %lf\n", input, value); return 0;}函数名: strtok功能: 查找由在第二个串中指定的分界符分隔开的单词用法: char *strtok(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char input[16] = "abc,d";char *p;/* strtok places a NULL terminatorin front of the token, if found */p = strtok(input, ",");if (p) printf("%s\n", p);/* A second call to strtok using a NULLas the first parameter returns a pointerto the character following the token */p = strtok(NULL, ",");if (p) printf("%s\n", p);return 0;}函数名: strtol功能: 将串转换为长整数用法: long strtol(char *str, char **endptr, int base);程序例:#include <stdlib.h>#include <stdio.h>int main(void){char *string = "87654321", *endptr;long lnumber;/* strtol converts string to long integer */lnumber = strtol(string, &endptr, 10);printf("string = %s long = %ld\n", string, lnumber); return 0;}函数名: strupr功能: 将串中的小写字母转换为大写字母用法: char *strupr(char *str);程序例:#include <stdio.h>#include <string.h>int main(void){char *string = "abcdefghijklmnopqrstuvwxyz", *ptr; /* converts string to upper case characters */ptr = strupr(string);printf("%s\n", ptr);return 0;}函数名: swab功能: 交换字节用法: void swab (char *from, char *to, int nbytes);程序例:#include <stdlib.h>#include <stdio.h>#include <string.h>char source[15] = "rFna koBlrna d";char target[15];int main(void){swab(source, target, strlen(source));printf("This is target: %s\n", target);return 0;}原型:extern char *strstr(char *haystack, char *needle);所在头文件:#include <string.h>功能:从字符串haystack中寻找needle第一次出现的位置(不比较结束符NULL)。

LinuxC字符串操作的基本使用

LinuxC字符串操作的基本使用

LinuxC字符串操作的基本使用展开全文Linux C 字符串操作的基本使用所属头文件:<string.h>0、获取字符串长度:int strlen(char *s)int strlen(char *s)函数说明:此函数用于获取s的长度,不包括'\0'注:切记最好保证s的尾部是'\0',strlen函数读到'\0'会自动停止然后统计字符数返回值:字符数1、查找指定的字符:index函数,rindex函数,strchr函数 strrchr(其中index函数和strchr函数基本相同,rindex函数和strchr函数相同)(1)char *index(const char* s, char c) char *strchr(const char* s, char c)函数说明:index函数用于查找字符串s中第一个出现c字符的地址,然后将该字符的地址返回.strchr函数与index相似返回值:若找到指定到字符则返回该字符的地址,否则返回0举例:char s[] = "abcdeabcde";char *sdest = NULL;sdest = index(s,'d');printf("sdest: %s\n",sdest);输出结果:sdest: deabcde(2)char *rindex(const char* s, char c) char *strrchr(const char* s, char c)函数说明:类似于index函数,但是他是从字符串开始查找字符c,并返回从字符串尾部开始第一个符合条件的字符的地址(strrchr与rindex相似)返回值:同index一样举例:char s[] = "abcdeabcde";char *sdest = NULL;sdest = rindex(s,'d');printf("sdest: %s\n",sdest);输出结果:sdest: de2、查找满足条件字符串中任意一个字符:strpbrk函数char *strpbrk(const char *s, const char *accept)函数说明:查找s字符串第一个符合accept字符串中任意一个字符的字符的地址返回值:符合条件的字符的地址举例:char s[] = "abcdefgefgbe";char t[] = "omgf";char *d = NULL;d = strpbrk(s,t);//应该会从s中找到‘f'字符的地址if(d != 0){printf("原字符串: %s\n",s);printf("获得到字符串: %s\n",d);}输出结果:原字符串: abcdefgefgbe获得到字符串: fgefgbe3、统计字符串中连续包含或不包含指定字符串内容到字符数:strspn 函数 ,strcspn函数(1)size_t strspn(const char *s, const char *accept)函数说明:从s的开头开始计算连续的字符,这些字符都属于accept中字符,遇到不是accept中的字符则停止,并返回字符个数n,即代表s开始处有连续n个属于accept字符串的字符.返回值:返回s字符串起始位置开始连续属于accept字符串的字符个数举例:char s[] = "abcdefgefgmmmmmbbe";char t[] = "bcdaefg";int inumber = 0;inumber = strspn(s,t);printf(" %d\n",inumber);输出结果:10(2)size_t strcspn(const char *s,const char *reject)函数说明:与strspn相反,从s的开头开始计算连续不属于reject 的字符数,并返回字符个数n,即代表s开头处有n个不属于accept字符串的字符。

c语言中string.h库函数 -回复

c语言中string.h库函数 -回复

c语言中string.h库函数-回复C语言中的string.h库函数是一个非常重要且广泛使用的库函数,它提供了许多用于操作字符串的函数。

本文将一步一步介绍string.h库函数的主要功能和用法。

首先,我们需要了解什么是字符串。

在C语言中,字符串是由一系列字符组成的字符数组。

字符串以'\0'(空字符)结尾,以便标记字符串的结束。

在C语言中,我们经常需要对字符串进行各种操作,如拷贝、比较、连接等。

string.h库函数提供了一系列函数来完成这些操作,并且这些函数都非常高效。

让我们从最常用的strcpy函数开始。

strcpy函数用于将一个字符串复制到另一个字符串中。

其函数原型如下:cchar *strcpy(char *dest, const char *src);其中,dest是目标字符串,src是源字符串。

这个函数会将src字符串中的内容复制到dest字符串中,并返回dest字符串的指针。

接下来是strcat函数,该函数用于将一个字符串连接到另一个字符串的末尾。

其函数原型如下:cchar *strcat(char *dest, const char *src);其中,dest是目标字符串,src是要连接的字符串。

这个函数会将src字符串连接到dest字符串的末尾,并返回dest字符串的指针。

另外一个常用函数是strlen函数,该函数用于计算字符串的长度。

其函数原型如下:csize_t strlen(const char *str);其中,str是要计算长度的字符串。

这个函数会返回str字符串的长度,不包括结束符'\0'。

除了上述常用函数外,string.h库还提供了一系列用于字符串比较的函数,如strcmp、strncmp等。

strcmp函数用于比较两个字符串的大小。

其函数原型如下:cint strcmp(const char *str1, const char *str2);其中,str1和str2是要比较的两个字符串。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

生活就是需要有创意--例如:Coding && Debug 分类: Linux C编程 2013-03-06 16:33 486人阅读 评论(0) 收藏举报String.hLinux C编程头文件函数名: stpcpy功能: 拷贝一个字符串到另一个用法: char *stpcpy(char *destin, char *source);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";stpcpy(string, str1);printf("%s\n", string);return 0;}函数名: strcat功能: 字符串拼接函数用法: char *strcat(char *destin, char *source);程序例:#include <string.h>#include <stdio.h>int main(void){char destination[25];char *blank = " ", *c = "C++", *Borland = "Borland"; strcpy(destination, Borland);strcat(destination, blank);strcat(destination, c);printf("%s\n", destination);return 0;}函数名: strchr功能: 在一个串中查找给定字符的第一个匹配之处\用法: char *strchr(char *str, char c);程序例:#include <string.h>#include <stdio.h>int main(void){char string[15];char *ptr, c = 'r';strcpy(string, "This is a string");ptr = strchr(string, c);if (ptr)printf("The character %c is at position: %d\n", c, ptr-string); elseprintf("The character was not found\n");return 0;}函数名: strcmp功能: 串比较用法: int strcmp(char *str1, char *str2);看Asic码,str1>str2,返回值 > 0;两串相等,返回0程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";int ptr;ptr = strcmp(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");elseprintf("buffer 2 is less than buffer 1\n");ptr = strcmp(buf2, buf3);if (ptr > 0)printf("buffer 2 is greater than buffer 3\n");elseprintf("buffer 2 is less than buffer 3\n");return 0;}函数名: strncmpi功能: 将一个串中的一部分与另一个串比较, 不管大小写用法: int strncmpi(char *str1, char *str2, unsigned maxlen);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = strcmpi(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strcpy功能: 串拷贝用法: char *strcpy(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";strcpy(string, str1);printf("%s\n", string);return 0;}函数名: strcspn功能: 在串中查找第一个给定字符集内容的段用法: int strcspn(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *string1 = "1234567890";char *string2 = "747DC8";int length;length = strcspn(string1, string2);printf("Character where strings intersect is at position %d\n", length); return 0;}函数名: strdup功能: 将串拷贝到新建的位置处用法: char *strdup(char *str);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *dup_str, *string = "abcde";dup_str = strdup(string);printf("%s\n", dup_str);free(dup_str);return 0;}函数名: stricmp功能: 以大小写不敏感方式比较两个串用法: int stricmp(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = stricmp(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n"); if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strerror功能: 返回指向错误信息字符串的指针: char *strerror(int errnum);程序例:#include <stdio.h>#include <errno.h>int main(void){char *buffer;buffer = strerror(errno);printf("Error: %s\n", buffer);return 0;}函数名: strcmpi功能: 将一个串与另一个比较, 不管大小写用法: int strcmpi(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBB", *buf2 = "bbb";int ptr;ptr = strcmpi(buf2, buf1);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strncmp功能: 串比较用法: int strncmp(char *str1, char *str2, int maxlen);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc"; int ptr;ptr = strncmp(buf2,buf1,3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");elseprintf("buffer 2 is less than buffer 1\n");ptr = strncmp(buf2,buf3,3);if (ptr > 0)printf("buffer 2 is greater than buffer 3\n"); elseprintf("buffer 2 is less than buffer 3\n");return(0);}函数名: strncmpi功能: 把串中的一部分与另一串中的一部分比较, 不管大小写用法: int strncmpi(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char *buf1 = "BBBccc", *buf2 = "bbbccc";int ptr;ptr = strncmpi(buf2,buf1,3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n"); if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;函数名: strncpy功能: 串拷贝用法: char *strncpy(char *destin, char *source, int maxlen);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10];char *str1 = "abcdefghi";strncpy(string, str1, 3);string[3] = '\0';printf("%s\n", string);return 0;}函数名: strnicmp功能: 不注重大小写地比较两个串用法: int strnicmp(char *str1, char *str2, unsigned maxlen);程序例:#include <string.h>#include <stdio.h>int main(void)char *buf1 = "BBBccc", *buf2 = "bbbccc";int ptr;ptr = strnicmp(buf2, buf1, 3);if (ptr > 0)printf("buffer 2 is greater than buffer 1\n");if (ptr < 0)printf("buffer 2 is less than buffer 1\n");if (ptr == 0)printf("buffer 2 equals buffer 1\n");return 0;}函数名: strnset功能: 将一个串中的所有字符都设为指定字符用法: char *strnset(char *str, char ch, unsigned n);程序例:#include <stdio.h>#include <string.h>int main(void){char *string = "abcdefghijklmnopqrstuvwxyz"; char letter = 'x';printf("string before strnset: %s\n", string);strnset(string, letter, 13);printf("string after strnset: %s\n", string);return 0;}函数名: strpbrk功能: 在串中查找给定字符集中的字符用法: char *strpbrk(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char *string1 = "abcdefghijklmnopqrstuvwxyz";char *string2 = "onm";char *ptr;ptr = strpbrk(string1, string2);if (ptr)printf("strpbrk found first character: %c\n", *ptr); elseprintf("strpbrk didn't find character in set\n");return 0;}函数名: strrchr功能: 在串中查找指定字符的最后一个出现用法: char *strrchr(char *str, char c);程序例:#include <string.h>#include <stdio.h>int main(void){char string[15];char *ptr, c = 'r';strcpy(string, "This is a string");ptr = strrchr(string, c);if (ptr)printf("The character %c is at position: %d\n", c, ptr-string); elseprintf("The character was not found\n");return 0;}函数名: strrev功能: 串倒转用法: char *strrev(char *str);程序例:#include <string.h>#include <stdio.h>int main(void){char *forward = "string";printf("Before strrev(): %s\n", forward); strrev(forward);printf("After strrev(): %s\n", forward); return 0;}函数名: strset功能: 将一个串中的所有字符都设为指定字符用法: char *strset(char *str, char c);程序例:#include <stdio.h>#include <string.h>int main(void){char string[10] = "123456789";char symbol = 'c';printf("Before strset(): %s\n", string); strset(string, symbol);printf("After strset(): %s\n", string);return 0;}函数名: strspn功能: 在串中查找指定字符集的子集的第一次出现用法: int strspn(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>#include <alloc.h>int main(void){char *string1 = "1234567890";char *string2 = "123DC8";int length;length = strspn(string1, string2);printf("Character where strings differ is at position %d\n", length); return 0;}函数名: strstr功能: 在串中查找指定字符串的第一次出现用法: char *strstr(char *str1, char *str2);程序例:#include <stdio.h>#include <string.h>int main(void){char *str1 = "Borland International", *str2 = "nation", *ptr; ptr = strstr(str1, str2);printf("The substring is: %s\n", ptr);return 0;}函数名: strtod功能: 将字符串转换为double型值用法: double strtod(char *str, char **endptr);程序例:#include <stdio.h>#include <stdlib.h>int main(void){char input[80], *endptr;double value;printf("Enter a floating point number:");gets(input);value = strtod(input, &endptr);printf("The string is %s the number is %lf\n", input, value); return 0;}函数名: strtok功能: 查找由在第二个串中指定的分界符分隔开的单词用法: char *strtok(char *str1, char *str2);程序例:#include <string.h>#include <stdio.h>int main(void){char input[16] = "abc,d";char *p;/* strtok places a NULL terminatorin front of the token, if found */p = strtok(input, ",");if (p) printf("%s\n", p);/* A second call to strtok using a NULLas the first parameter returns a pointerto the character following the token */p = strtok(NULL, ",");if (p) printf("%s\n", p);return 0;}函数名: strtol功能: 将串转换为长整数用法: long strtol(char *str, char **endptr, int base);程序例:#include <stdlib.h>#include <stdio.h>int main(void){char *string = "87654321", *endptr;long lnumber;/* strtol converts string to long integer */lnumber = strtol(string, &endptr, 10);printf("string = %s long = %ld\n", string, lnumber); return 0;}函数名: strupr功能: 将串中的小写字母转换为大写字母用法: char *strupr(char *str);程序例:#include <stdio.h>#include <string.h>int main(void){char *string = "abcdefghijklmnopqrstuvwxyz", *ptr; /* converts string to upper case characters */ptr = strupr(string);printf("%s\n", ptr);return 0;}函数名: swab功能: 交换字节用法: void swab (char *from, char *to, int nbytes);程序例:#include <stdlib.h>#include <stdio.h>#include <string.h>char source[15] = "rFna koBlrna d";char target[15];int main(void){swab(source, target, strlen(source));printf("This is target: %s\n", target);return 0;}原型:extern char *strstr(char *haystack, char *needle);所在头文件:#include <string.h>功能:从字符串haystack中寻找needle第一次出现的位置(不比较结束符NULL)。

相关文档
最新文档