linuxc字符串操作的基本使用

合集下载

Linux下C语言的文件读写

Linux下C语言的文件（fputc,fgetc,fwrite,fread对文件读写操作）//==================================fputc 向文件写入字符#include <stdio.h>#include <stdlib.h>main(){FILE *fp;char ch;if((fp=fopen("test.txt","w"))==NULL){printf("不能打开文件\n");exit(0);}while ((ch=getchar())!='\n')fputc( ch, fp );fclose(fp);}-------------小提示：fp=fopen("test.txt","w") ，把"w"改为"a" 可以创建文件并且追加写入内容exit(0); 需要包含stdlib.h 头文件，才能使用//============================================================fgetc 读取字符#include <stdio.h>#include <stdlib.h>main( int argc, char *argv[] ){char ch;FILE *fp;int i;if((fp=fopen(argv[1],"r"))==NULL){printf("不能打开文件\n");exit(0);}while ((ch=fgetc(fp))!=EOF)putchar(ch);fclose(fp);}文件结尾，通过判断EOF//============================================================== fwrite 的使用使数组或结构体等类型可以进行一次性读写#include <stdio.h>#include <stdlib.h>main(){FILE *fp1;int i;struct student{char name[10];int age;float score[2];char addr[15];}stu;if((fp1=fopen("test.txt","wb"))==NULL){printf("不能打开文件");exit(0);}printf("请输入信息，姓名年龄分数1 分数2 地址:\n");for( i=0;i<2;i++){scanf("%s %d %f %f %s",,&stu.age,&stu.score[0],&stu.score[1], stu.addr);fwrite(&stu,sizeof(stu),1,fp1);}fclose(fp1);}//=============================================================== fread 的使用#include <stdio.h>#include <stdlib.h>main(){FILE *fp1;int i;struct student{char name[10];int age;float score[2];char addr[15];}stu;if((fp1=fopen("test.txt","rb"))==NULL){printf("不能打开文件");exit(0);}printf("读取文件的内容如下:\n");for (i=0;i<2;i++){fread(&stu,sizeof(stu),1,fp1);printf("%s %d %7.2f %7.2f %s\n",,stu.age,stu.score[0],stu.score[1],stu.addr);}fclose(fp1);}。

c语言字符串的简单处理

c语言字符串的简单处理C语言字符串的简单处理在C语言中，字符串是一种常见的数据类型，用于存储字符序列。

在程序中，我们经常需要对字符串进行一些简单的处理，例如字符串的拼接、查找特定字符、计算字符串的长度等操作。

本文将介绍一些常用的字符串处理方法，帮助读者更好地理解和应用C语言中的字符串操作。

一、字符串的定义和初始化在C语言中，字符串是由字符组成的字符数组。

我们可以通过以下两种方式来定义和初始化字符串：1. 使用字符数组方式定义和初始化字符串：char str1[] = "Hello World";2. 使用指针方式定义和初始化字符串：char *str2 = "Hello World";二、字符串的输出和输入在C语言中，我们可以使用printf函数来输出字符串，使用scanf 函数来输入字符串。

1. 输出字符串：printf("%s\n", str1);2. 输入字符串：scanf("%s", str1);需要注意的是，在使用scanf函数输入字符串时，需要保证输入的字符串长度不超过定义的字符数组长度，否则会发生溢出错误。

三、字符串的拼接在C语言中，我们可以使用strcat函数来实现字符串的拼接。

1. 使用strcat函数拼接字符串：char str3[20] = "Hello";char str4[] = "World";strcat(str3, str4);printf("%s\n", str3); // 输出结果为"HelloWorld"需要注意的是，在使用strcat函数拼接字符串时，需要保证目标字符数组长度足够大，以避免发生溢出错误。

四、字符串的复制在C语言中，我们可以使用strcpy函数来实现字符串的复制。

1. 使用strcpy函数复制字符串：char str5[20];char str6[] = "Hello World";strcpy(str5, str6);printf("%s\n", str5); // 输出结果为"Hello World"需要注意的是，在使用strcpy函数复制字符串时，需要保证目标字符数组长度足够大，以避免发生溢出错误。

由Linux中管道的buffer，浅谈C语言中char类型字符串拷贝使用strcpy（）和。。。

由Linux中管道的buffer，浅谈C语⾔中char类型字符串拷贝使⽤strcpy（）和。

今天在写⽗⼦进程⽤两个单向管道通信时，出现了错误：Segmentation fault (core dumped)打开core⽂件发现：附上源码：1 #include <stdlib.h>2 #include <unistd.h>3 #include <stdio.h>4 #include <sys/wait.h>5 #include <errno.h>6 #include <string.h>78void erreur(const char *msg)9 {10 perror(msg);11 }1213#define NBCAR 2561415int main(void)16 {17 pid_t pid;18int tube[2];19int tube2[2];20int ret_out, ret_in;21char *buffer,*buffer2;2223if (pipe(tube) == -1) {//from parent to son24 erreur("Erreur de creation du pipe");25 exit(EXIT_FAILURE);26 }27if (pipe(tube2) == -1) {//from son to parent28 erreur("Erreur de creation du pipe");29 exit(EXIT_FAILURE);30 }31 buffer = (char *) malloc(NBCAR * sizeof(char));32 buffer2 = (char *) malloc(NBCAR * sizeof(char));33switch (pid = fork()) {34case (pid_t) -1:35 erreur("fork");36case (pid_t) 0:37 close(tube[1]);38 close(tube2[0]);39if (printf("Je suis le fils de PID %d\n write dans le tube : %s\n Nbr Caracteres lus: %d\n",getpid(), buffer, ret_in =write(tube2[1], buffer="tube1 s to p", NBCAR - 1)) == -1) {40 erreur(" Pb Lecture ");41 exit(EXIT_FAILURE);42 }43if (printf("Je suis le fils de PID %d\n Lecture dans le tube : %s\n Nbr Caracteres lus: %d\n",getpid(), buffer2, ret_in =read(tube[0], buffer2, NBCAR - 1)) == -1) {44 erreur(" Pb Lecture ");45 exit(EXIT_FAILURE);46 }4748 exit(0);49break;50default:51 close(tube[0]);52 close(tube2[1]);53if (printf("Je suis le parent de PID %d\n Lecture dans le tube : %s\n Nbr Caracteres lus: %d\n",getpid(), buffer, ret_in =read(tube2[0], buffer, NBCAR - 1)) == -1) {54 erreur(" Pb Lecture ");55 exit(EXIT_FAILURE);}56if (printf("Je suis le parent de PID %d\n write dans le tube : %s\n Nbr Caracteres lus: %d\n",getpid(), buffer2, ret_in =write(tube[1], buffer2="tube2 p to s", NBCAR - 1)) == -1) {57 erreur(" Pb Lecture ");58 exit(EXIT_FAILURE);}5960 wait(NULL);61break;6263 }64free(buffer);65free(buffer2);66return EXIT_SUCCESS;67 }关于SIGSEGV错误SIGSEGV --- Segment Fault. The possible cases of your encountering this error are:1.buffer overflow --- usually caused by a pointer reference out of range.2.stack overflow --- please keep in mind that the default stack size is 8192K.3.illegal file access --- file operations are forbidden on our judge system.后来通过邮件问⽼师，发现是buffer出现内存泄漏。

Linux下C语言编程：编写函数,删除字符串中的空格

Linux下C语言编程：编写函数,删除字符串中的空格.
//一维字符串数组" h a sdf g "
//指针指着第一个元素,判断是否为零,为零则++,不为零则赋值给另一个指针
//再把两个指针都++操作
//最后需要把新的数组后加'\0'
#include<stdio.h>
void del_space (char *s1);
//定义,定义后面要加分号";"表示语句结束
int main(int argc,char*argv[])
{
char s[] = " h a sdf g " ;
puts(s);
//字符串输出
del_space(s);
//调用删除空格函数
puts(s);
//打印删除空格后的字符串
return 0;
}
void del_space (char *s1)
//实现部分,后面不加封号";"表示语句没有结束
{
char *s2;
//去空格后保存的位置
s2 = s1;
//赋初值
while (*s1) {
if (*s1 != ' ')
{
*s2 = *s1;
s1 ++;
s2 ++;
}
else
{
s1 ++;
}
}
*s2 = '\0'; //新字符串最后加'\0' }
结果：
>> h a sdf g
>>hasdfg。

c输入字符串的几种方式

c输入字符串的几种方式C语言是一种广泛应用于计算机编程的语言，它具有灵活、高效的特点，因此在输入字符串方面也有多种方式。

本文将介绍C语言中几种常见的输入字符串的方式。

一、使用scanf函数输入字符串scanf函数是C语言中常用的输入函数，可以用于输入各种类型的数据，包括字符串。

在输入字符串时，可以使用%s格式控制符。

例如：```#include <stdio.h>int main(){char str[20];printf("请输入字符串：");scanf("%s", str);printf("您输入的字符串是：%s\n", str);return 0;}```在上述代码中，通过scanf函数和%s格式控制符，可以实现字符串的输入，并将输入的字符串打印出来。

二、使用gets函数输入字符串gets函数是C语言中用于输入字符串的函数，它可以一次性输入一整行字符串。

例如：```#include <stdio.h>int main(){char str[20];printf("请输入字符串：");gets(str);printf("您输入的字符串是：%s\n", str);return 0;}```在上述代码中，通过gets函数实现了字符串的输入，并将输入的字符串打印出来。

需要注意的是，gets函数会将输入的整行字符串存储到指定的字符数组中，当输入的字符串长度超过数组长度时，可能会导致缓冲区溢出的问题，因此在实际使用中需要进行长度检查。

三、使用fgets函数输入字符串fgets函数是C语言中用于输入字符串的函数，与gets函数相比，它更加安全。

fgets函数可以指定输入字符串的最大长度，并且可以指定输入的结束标志（通常为换行符）。

例如：```#include <stdio.h>int main(){char str[20];printf("请输入字符串：");fgets(str, sizeof(str), stdin);printf("您输入的字符串是：%s\n", str);return 0;}```在上述代码中，通过fgets函数实现了字符串的输入，并将输入的字符串打印出来。

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:他们分别是将字符串转换成浮点型，长整型数。

c语言中字符串操作函数及功能

c语言中字符串操作函数及功能C语言中字符串操作函数及功能在C语言中，字符串是一组由字符组成的数据，用于存储和操作文本信息。

C语言提供了许多字符串操作函数，以便开发者能够方便地处理字符串。

本文将介绍一些常用的字符串操作函数及其功能。

1. strlen函数：用于获取字符串的长度。

它接受一个字符串作为参数，并返回该字符串的长度，即字符的个数。

例如，strlen("hello")将返回5。

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

它接受两个参数，第一个参数是目标字符串，第二个参数是源字符串。

例如，strcpy(dest, src)将源字符串src复制到目标字符串dest中。

3. strcat函数：用于将一个字符串连接到另一个字符串的末尾。

它接受两个参数，第一个参数是目标字符串，第二个参数是要追加的字符串。

例如，strcat(dest, src)将字符串src追加到字符串dest的末尾。

4. strcmp函数：用于比较两个字符串。

它接受两个参数，分别是要比较的两个字符串。

如果两个字符串相等，返回0；如果第一个字符串小于第二个字符串，返回负数；如果第一个字符串大于第二个字符串，返回正数。

例如，strcmp("hello", "world")将返回负数。

5. strchr函数：用于在字符串中查找指定字符的第一次出现的位置。

它接受两个参数，第一个参数是要查找的字符串，第二个参数是要查找的字符。

如果找到了指定字符，返回该字符在字符串中的位置；如果未找到，返回NULL。

6. strstr函数：用于在字符串中查找指定子串的第一次出现的位置。

它接受两个参数，第一个参数是要查找的字符串，第二个参数是要查找的子串。

如果找到了指定子串，返回该子串在字符串中的位置；如果未找到，返回NULL。

7. strtok函数：用于将字符串分割为多个子串。

它接受两个参数，第一个参数是要分割的字符串，第二个参数是分割的分隔符。

linuxshell字符串操作详解（长度，读取，替换，截取，连接，对比，删除，位置）

linuxshell字符串操作详解（长度，读取，替换，截取，连接，对⽐，删除，位置）1.Linux shell 截取字符变量的前8位实现⽅法有如下⼏种：1. expr substr “$a” 1 82. echo $a|awk ‘{print substr(,1,8)}’3. echo $a|cut -c1-84. echo $5. expr $a : ‘$.\$.*’6. echo $a|dd bs=1 count=8 2>/dev/null2.按指定的字符串截取(1)第⼀种⽅法:从左向右截取最后⼀个string后的字符串${varible##*string}从左向右截取第⼀个string后的字符串${varible#*string}从右向左截取最后⼀个string后的字符串${varible%%string*}从右向左截取第⼀个string后的字符串${varible%string*}“*”只是⼀个通配符可以不要请看下⾯的例⼦：$ MYVAR=foodforthought.jpg$ echo ${MYVAR##*fo}rthought.jpg$ echo ${MYVAR#*fo}odforthought.jpg(2)第⼆种⽅法：${varible:n1:n2}:截取变量varible从n1开始的n2个字符，组成⼀个⼦字符串。

可以根据特定字符偏移和长度，使⽤另⼀种形式的变量扩展，来选择特定⼦字符串。

试着在 bash 中输⼊以下⾏：$ EXCLAIM=cowabunga$ echo ${EXCLAIM:0:3}cow$ echo ${EXCLAIM:3:7}abunga这种形式的字符串截断⾮常简便，只需⽤冒号分开来指定起始字符和⼦字符串长度。

3.按照指定要求分割：⽐如获取后缀名ls -al | cut -d “.” -f2⼩结：shell对应字符串的处理⽅法很多，根据需求灵活选择。

在做shell批处理程序时候，经常会涉及到字符串相关操作。

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是要查找的字符集。

(完整版)C语言字符串操作总结大全(超详细)

功能：将字符串source接到字符串target的后面
例程：
#include <iostream.h>
#include <string.h>
void main(void)
{
char str1[] = { "Tsinghua "};
char str2[] = { "Computer"};
cout <<strcpy(str1,str2)<<endl;
strncpy(char destination[], const char source[], int numchars);
strncpy：将字符串source中前numchars个字符拷贝到字符串destination中。
strncpy函数应用举例
原型：strncpy(char destination[], const char source[], int numchars);
C语言字符串操作总结大全(超详细)
1）字符串操作
strcpy(p, p1)复制字符串
strncpy(p, p1, n)复制指定长度字符串
strcat(p, p1)附加字符串
strncat(p, p1, n)附加指定长度字符串
strlen(p)取字符串长度
strcmp(p, p1)比较字符串
strcasecmp忽略大小写比较字符串
查找字串string中首次出现的位置, NULL结束符也包含在查找中.返回一个指针,指向字符c在字符串string中首次出现的位置,如果没有找到,则返回NULL.
char *strrchr(const char *string, int c);

string在c语言中的用法

string在c语言中的用法字符串是一种重要的数据类型，它在C语言中有很多的应用。

在C语言中，字符串是由char类型的字符数组来实现的。

每个字符都占用一个字节，以\0作为字符串的结束标志。

字符串的定义：字符串的定义方式为：char str[]=”Hello World”;其中，str是一个字符数组，用于存储字符串，“Hello World”是字符串字面值。

由于字符串需要以\0作为结束标志，因此在定义字符串时，必须保证字符串后面有一个\0。

字符串的输入输出：字符串的输入输出可以使用库函数puts和gets。

其中，puts用于输出字符串，gets用于输入字符串。

puts(str) 输出字符串strgets(str) 输入字符串str字符串的长度：在C语言中，可以使用strlen函数来计算字符串的长度。

strlen函数用于计算字符串的字符个数，不包括字符串末尾的\0。

例如，strlen("hello")的返回值为5。

字符串的复制：在C语言中，可以使用strcpy函数来复制字符串。

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

例如，strcpy(dest, src)表示将src复制到dest中。

字符串的比较：在C语言中，可以使用strcmp函数来比较两个字符串的大小。

strcmp函数用于比较两个字符串的大小，根据比较结果返回一个整数。

如果第一个字符串小于第二个字符串，返回负数；如果第一个字符串等于第二个字符串，返回0；如果第一个字符串大于第二个字符串，返回正数。

例如，strcmp("hello", "world")的返回值为负数。

字符串的连接：在C语言中，可以使用strcat函数来连接两个字符串。

strcat函数用于将一个字符串连接到另一个字符串的后面。

例如，strcat(dest, src)表示将src连接到dest的后面。

字符串的查找：在C语言中，可以使用strstr函数来查找字符串。

Linux系统下C语言编程及技巧研究

Linux系统下C语言编程及技巧研究Linux是一种自由和开放源代码的类Unix操作系统，广泛用于服务器领域。

同时，Linux系统也是许多开发者和程序员首选的开发环境。

因此，掌握在Linux系统下C语言编程及技巧非常重要。

本文将重点介绍在Linux下进行C语言编程的一些技巧和要点。

1. GNU编译器工具集（GCC）GCC是 GNU编译器工具集的简称，支持多种编程语言，如C、C++、Objective-C、Java等。

在Linux系统下，GCC是编译C程序的主要工具。

开发者可以通过命令行或集成式开发环境（IDE）使用GCC。

2. 环境变量环境变量是Linux系统的重要概念，能够帮助开发者方便地访问系统资源和软件库。

开发者可以通过设置环境变量，指定GCC的默认搜索路径和库路径。

例如，下列命令可将环境变量C_INCLUDE_PATH设置为当前目录：export C_INCLUDE_PATH=.3. 头文件头文件在C语言程序的编写过程中是非常重要的。

Linux系统提供了许多C语言头文件，例如stdio.h、stdlib.h等。

开发者也可以根据需求编写自己的头文件。

在编写程序时，一定要正确地包含头文件。

否则编译器将无法识别预定义的类型和函数。

例如，下列程序演示了如何使用stdio.h头文件中的printf函数：4. 动态链接库动态链接库（Dynamic Linking Libraries，DLL）提供了跨多个程序共享函数和代码的能力。

在Linux系统下，动态链接库通常以.so文件形式出现。

开发者可以通过指定链接器选项使用动态链接库。

例如，下列命令将可执行文件myprog连接到数学库libm.so：gcc -o myprog myprog.c -lm5. 调试器调试器是程序员的重要工具。

调试器能够帮助开发者在程序崩溃或产生错误时追踪问题。

在Linux系统下，调试器gdb（GNU调试器）是普遍使用的工具。

例如，下列命令启动了gdb并加载了可执行文件：gdb ./myprog在gdb命令行下，可以执行多种命令来分析程序的行为，如查看变量的值、单步执行代码、设置断点等。

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 ?。

LinuxC中内联汇编的语法格式及使用方法（InlineAssemblyinLinuxC）【转】

LinuxC中内联汇编的语法格式及使⽤⽅法（InlineAssemblyinLinuxC）【转】阅读Linux内核源码或对代码做性能优化时，经常会有在C语⾔中嵌⼊⼀段汇编代码的需求，这种嵌⼊汇编在CS术语上叫做inline assembly。

本⽂的笔记试图说明Inline Assembly的基本语法规则和⽤法（建议英⽂阅读能⼒较强的同学直接阅读本⽂参考资料中推荐的技术⽂章 ^_^）。

注意：由于gcc采⽤AT&T风格的汇编语法（与Intel Syntax相对应，⼆者的区别参见这⾥），因此，本⽂涉及到的汇编代码均以AT&T Syntax为准。

1. 基本语法规则内联汇编（或称嵌⼊汇编）的基本语法模板⽐较简单，如下所⽰（为使结构更清晰，这⾥特意做了换⾏，其实完全可以全部写到单⾏中）：asm [ volatile ] (assembler template[ : output operands ] /* optional */[ : input operands ] /* optional */[ : list of clobbered registers ] /* optional */);备注：本⽂遵从linux系统的统⼀风格，以[ ]来表⽰其对应的内容为可选项。

由代码模板可以看到，基本语法规则由5部分组成，下⾯分别进⾏说明。

1）关键字asm和volatileasm为gcc关键字，表⽰接下来要嵌⼊汇编代码。

为避免keyword asm与程序中其它部分产⽣命名冲突，gcc还⽀持__asm__关键字，与asm 的作⽤等价。

volatile为可选关键字，表⽰不需要gcc对下⾯的汇编代码做任何优化。

同样出于避免命名冲突的原因，__volatile__也是gcc⽀持的与volatile 等效的关键字。

BTW: C语⾔中也经常⽤到volatile关键字来修饰变量（不熟悉的同学，请参考）2）assembler template这部分即我们要嵌⼊的汇编命令，由于我们是在C语⾔中内联汇编代码，故需⽤双引号""将命令括起来，以便gcc以字符串形式将这些命令传给汇编器AS。

c语言中string用法

c语言中string用法C语言中string的用法在C语言中，string是一个用来存储字符序列的数据类型。

在C语言中并没有内置的string类型，而是通过字符数组来表示字符串。

下面是关于C语言中string 的一些常见用法：1. 字符串声明和初始化要声明一个字符串变量，可以使用字符数组来表示。

例如：```cchar str[20]; // 声明一个可以容纳20个字符的字符串char str[] = "Hello"; // 声明并初始化一个包含字符串"Hello"的字符串```2. 字符串赋值可以使用strcpy函数来将一个字符串赋值给另一个字符串。

例如：```cchar str1[20];char str2[] = "Hello";strcpy(str1, str2); // 将str2复制到str1中```3. 字符串连接可以使用strcat函数来连接两个字符串。

例如：char str1[20] = "Hello";char str2[] = "World";strcat(str1, str2); // 将str2连接到str1的末尾```4. 字符串长度可以使用strlen函数来获取一个字符串的长度。

例如：```cchar str[] = "Hello";int length = strlen(str); // 获取字符串的长度```5. 字符串比较可以使用strcmp函数来比较两个字符串是否相同。

例如：```cchar str1[] = "Hello";char str2[] = "World";int result = strcmp(str1, str2); // 比较str1和str2是否相同，返回0表示相同```6. 字符串截取可以使用strncpy函数来从一个字符串中截取指定长度的子字符串。

Linux C语言的编程规范

Linux C语言的编程规范（Linux）有独特的（编程）风格,在内核源代码目录Documentation/CodingStyle,详细描述代码风格。

建议大家可以去看一下，老外写技术文档还是很有意思的，上来就狂喷，“你不这样写就会完蛋，异教徒才不这样写……”，没有国内那么刻板，多阅读英语文档对技术增长很有帮助。

1. 命名规范在一般编程中,习惯以如下方式命名宏、变量和函数:#define （PI）3.1415926 /*用大写字母代表宏*/int minValue, maxValue; /*变量:第一个单词全小写,其后单词的第一个字母大写*/void SendData (void); /* 函数:所有单词第一个字母都大写*/ 这种通过单词之间通过首字母大写来区分的方式非常流行。

通过第1个单词的首字母是否大写可以区分名称属于变量还是属于函数,而看到整串的大写字母可以断定为宏。

许多领域的程序开发都遵照此习惯。

但是Linux不以这种习惯命名,对于上面的一段程序,在Linux中它会被命名为:#define PI 3.1415926int min_value, max_value;void send_data (void); 在上述命名方式中,宏还是一样用大写，但变量和函数名，不按照Windows所采用的用首字母大写来区分单词，而是采用下划线。

而且Linux下命名，全局变量命名最好用长的准确的描述，局部变量最好简短，甚至直接用tmp，i之类的。

其实两种命名方式都行，写Liunx下的程序时，与Linux社区代码风格一致更好，但你用第一种我觉得也无伤大雅。

2.缩进缩进统一使用"TAB",而不是空格括号。

另外提一句：在Linux下，"TAB"代表8个字符，而不是4个，Linux代码风格认为8个字符更能体现层次结构。

文档里喷"TAB"为4字符的是异教徒，对于8字符在多层次时，代码太偏右的问题，文档又喷层次超过三层，你的代码就会完蛋，哈哈哈。

C语言字符串处理方法

C语言字符串处理方法C语言作为一种广泛应用的编程语言，具有丰富的字符串处理方法。

本文将探讨C语言中常用的字符串处理技巧，包括字符串的定义、拼接、比较、复制、分割、查找和替换等方法。

一、字符串的定义在C语言中，字符串是由字符组成的数组。

可以使用字符数组或者字符指针来定义字符串。

下面是两种常见的定义方式：1. 使用字符数组定义字符串：char str[] = "Hello, C language!";2. 使用字符指针定义字符串：char *str = "Hello, C language!";二、字符串的拼接字符串的拼接是将两个或者多个字符串连接在一起形成一个新的字符串。

C语言中，可以使用strcat函数来实现字符串的拼接。

下面是一个示例：```c#include <stdio.h>#include <string.h>int main() {char str1[20] = "Hello, ";char str2[20] = "C language!";strcat(str1, str2);printf("%s\n", str1);return 0;}```三、字符串的比较在C语言中，可以使用strcmp函数比较两个字符串是否相等。

该函数会返回一个整数值来表示比较结果，如果返回值为0，则表示两个字符串相等。

下面是一个示例：```c#include <stdio.h>#include <string.h>int main() {char str1[] = "Hello";char str2[] = "Hello";if (strcmp(str1, str2) == 0) {printf("The strings are equal.\n");} else {printf("The strings are not equal.\n");}return 0;}```四、字符串的复制事实上，C语言中并没有提供直接复制字符串的函数，但可以使用strcpy函数来实现字符串的复制。

linux c中write、read的用法

linux c中write、read的用法Linux C中write、read的用法在Linux C中，write和read是两个重要的系统调用，用于在文件描述符上进行数据的写入和读取。

它们是在POSIX标准中定义的函数，在Unix和类Unix 操作系统中被广泛使用。

在本文中，我们将详细介绍write和read函数的用法，以及它们在实际编程中的应用。

write函数的用法write函数用于向文件描述符写入数据。

其基本语法如下：cssize_t write(int fd, const void *buf, size_t count);其中，fd是文件描述符，buf是要写入的数据的指针，count是要写入的字节数。

该函数返回实际写入的字节数，如果发生错误则返回-1。

下面是一个简单的示例，演示了如何使用write函数向一个文件写入数据：c#include <unistd.h>#include <fcntl.h>int main() {int fd = open("file.txt", O_WRONLY O_CREAT, 0644);if(fd == -1) {handle error}const char *data = "Hello, world!";ssize_t bytes_written = write(fd, data, strlen(data));if(bytes_written == -1) {handle error}close(fd);return 0;}在这个示例中，我们首先通过open函数打开了一个名为file.txt的文件，然后使用write函数向文件中写入了一个字符串。

最后，我们通过close函数关闭了文件描述符。

read函数的用法read函数用于从文件描述符读取数据。

其基本语法如下：cssize_t read(int fd, void *buf, size_t count);其中，fd是文件描述符，buf是用于存储读取数据的缓冲区的指针，count是要读取的字节数。

LinuxC字符串替换函数实例详解

LinuxC字符串替换函数实例详解Linux C字符串替换函数实例详解最近学习linux 的基础编程知识，字符串替换函数，在⽹上找下资料，觉得这篇⽂章写的不错，记录下来，和⼤家分享⼀下：实例代码：#include <stdio.h>#include <string.h>#include <stdlib.h>/****@author:************** @reference: lovesnow1314@/Expert/TopicView3.asp?id=5198221** ⽤新⼦串newstr替换源字符串src中的前len个字符内所包含的oldstr⼦串** @param char* dest ⽬标串，也就是替换后的新串* @param const char* src 源字符串，被替换的字符串* @param const char* oldstr 旧的⼦串，将被替换的⼦串* @param const char* newstr 新的⼦串* @param int len 将要被替换的前len个字符** @return char* dest 返回新串的地址**/char *strreplace(char *dest, char *src, const char *oldstr, const char *newstr, size_t len){//如果串相等，则直接返回if(strcmp(oldstr, newstr)==0)return src;//⼦串位置指针char *needle;//临时内存区char *tmp;//把源串地址赋给指针dest，即让dest和src都指向src的内存区域dest = src;//如果找到⼦串, 并且⼦串位置在前len个⼦串范围内, 则进⾏替换, 否则直接返回while((needle = strstr(dest, oldstr)) && (needle -dest <= len)){//分配新的空间: +1 是为了添加串尾的'\0'结束符tmp=(char*)malloc(strlen(dest)+(strlen(newstr)-strlen(oldstr))+1);//把src内的前needle-dest个内存空间的数据，拷贝到arrstrncpy(tmp, dest, needle-dest);//标识串结束tmp[needle-dest]='\0';//连接arr和newstr, 即把newstr附在arr尾部, 从⽽组成新串(或说字符数组)arrstrcat(tmp, newstr);//把src中从oldstr⼦串位置后的部分和arr连接在⼀起，组成新串arrstrcat(tmp, needle+strlen(oldstr));//把⽤malloc分配的内存，复制给指针retvdest = strdup(tmp);//释放malloc分配的内存空间free(tmp);}return dest;}int main(){char *str="wo i love iyou";char *old="i";char *new="ILOVEYOUYA";char *dest;//分配内存空间: ⼤⼩ == src的长度＋ newstr和oldstr长度差(可能是正负或0)+1 printf("%s\n",strreplace(dest, str, old, new,1));printf("%s\n",strreplace(dest, str, old, new,5));printf("%s\n",strreplace(dest, str, old, new,40));return 0;}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

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

Linux C 字符串操作的基本使用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字符串的字符。

返回值:返回s字符串起始位置开始连续不属于accept字符串到字符个数举例:char s[] = "abcdefgefgmqmmmmbbe";char t[] = "mq";int inumber = 0;inumber = strcspn(s,t);printf(" %d\n",inumber);输出结果:104、查找指定字符串:char *strstr(const char *s, const char *need);函数说明：从s中找到与need匹配到子字符串，并将该子字符串的地址返回返回值:匹配的子字符串的起始地址举例：char s[] = "abcdefgefgmqmmmmbbe";char t[] = "fge";char *score = NULL;score = strstr(s,t);printf(" %s\n",score);输出结果:fgefgmqmmmmbbe5、字符串分割:char *strtok(char *s, const char *delim)函数说明:strtok函数将s按照delim字符串中的字符分割成一个个子字符串，对于字符串s，当遇到delim中到字符，则将该字符替换成'\0'然后返回'\0'之前的字符串子串。

若继续分割，则将第一个参数设置为NULL,程序会从上一次分割结束的位置('\0'之后)开始继续分割，若已经无法分割则返回NULL返回值：分割所得到子字符串的地址.，若无法分割则返回NULL举例:char s[] = "abc:bcd:ef bg_op fq:yz_dd";char t[] = ": _";char *score = NULL;/*第一次调用*/if((score = strtok(s,t)) == NULL){printf("failed!\n");return 0;}printf("%s;",score);/*继续分割，将第一个参数这是为NULL*/while((score = strtok(NULL,t))){printf("%s;",score);}输出结果:abc;bcd;ef;bg;op;fq;yz;dd;6、字符串比较:strcmp函数, strncmp函数,strcasecmp函数,strncasecmp函数(1)int strcmp(const char *s1,const char *s2);函数说明:s1字符串与s2字符串从开头开始逐字符比较，先用s1的第一个字符的ASCII码的值与s2到第一个字符值到ASCII码值相减，若差值等于0,则继续用s1,s2字符串的第二个字符比较，若不等于0则返回差值。

所有字符比较完后差值依然为0，但是其中一个字符串长度较长，如s2比s1多一个字符'a'，那么返回差值0-'a'的值返回值：若两个字符串完全相同则返回0，否则返回字符差值举例：char s1[] = "abcdefg";char s2[] = "abcdefgopq";char s3[] = "abcdefm";printf("s1与s2比较:%d\n",strcmp(s1,s2));printf("s1与s3比较:%d\n",strcmp(s1,s3));return 1;输出结果：s1与s2比较:-111s1与s3比较:-6(2) int strncmp(const char *s1,const char *s2,size_t n);函数说明：原理与strcmp函数一样，只不过多了一个参数来限制比较用于比较的字符的个数不能超过n，如果两个字符串前n个字符完全一样则返回0,相比strcmp，strncmp函数灵活性更强。

返回值：若两个字符串完全相同则返回0，否则返回字符差值(3)int strcasecmp(char *s1, char *s2)函数说明:与strcmp相似，只不过比较的时候忽略大小写差异返回值：在忽略大小写的情况下，若两个字符串完全相同则返回0，否则返回字符差值(4)int strncasecmp(char *s1, char *s2,size_t n)函数说明：于strcasecmp函数相比，多了个参数限定比较字符的个数返回值:在忽略大小写的情况下，若两个字符串完全相同则返回0，否则返回字符差值7、字符串复制：strcpy函数、strncpy 函数、strdup函数(1)char *strcpy(char *dest, const char*src)函数说明：将src字符串到内容拷贝到dest指向到字符串中，注:拷贝的长度由src字符串的'\0'空字符的位置决定，因此使用到时候要考虑到src末尾是否有空字符，并且考虑dest字符串的大小，有可能dest无法容纳src导致溢出返回值：dest字符串的起始位置举例:char dest[50];char src[] = "adfdasfa";printf("%s",strcpy(dest,src));输出结果: adfdasfa(2)char*strncpy(char *dest, const char *src, size_t n)函数说明:与strcpy用法类似，将src最多前n个字符拷贝到dest,如果src长度小于n则到'\0'为止，相比strcpy，strncpy 函数安全性更高，使用更灵活返回值:dest字符串的起始位置(3)char *strdup(char *src)函数说明:会调用malloc函数动态分配一块大小与src一样的内存，然后将src的内容拷贝到该块内存中，并将内存的起始地址返回，这意味着如果我们不再需要这个字符串的副本，我们最好使用free()将它释放。

返回值:复制成功后的字符串的地址，若失败则返回NULL。