linux中C语言函数：字符串处理函数

现在的位置: 首页 > 综合 > 正文

linux中C语言函数：字符串处理函数

2017年12月14日 ⁄ 综合 ⁄ 共 6210字 ⁄ 字号小中大 ⁄ 评论关闭

所有函数的头文件都为<string.h>,测试环境redhat enterprise 6.0

bcmp ：比较两个内存中的内容
bcopy : 复制内存中的内容
bzero ：将一个内存内容全清零
ffs : 在一个整数中查找第一个值为真的位
index : 查找字符串中第一个出现的指定字符
memccpy ：复制内存中的内容
memchr ：在一块内存指定范围内查找一个指定字符
memcmp ：比较内存中存放的内容
memcpy ：复制一块内存内容到另一块
memfrob ：对某个内存区重新编码
memmove ：复制内存内容
memset ：将某值填入到一个内存区域
rindex ：查找字符串中最后一个出现的指定字符
strcasecmp ：忽略大小写比较字符串
strcat ：将一个字符串连接到另一个字符串的尾部
strchr ；查找字符串中指定字符
strcmp ：比较两个字符串
strcoll ：根据当前环境信息来比较字符串
strcpy ：复制一个字符串的内容到另一个字符串中
strdup ：复制字符串的内容
strfry ：随机重组一个字符串
strlen ：返回字符串的长度
strncasecmp ：忽略大小写比较两个字符串
strncat ：将一个字符串的前n个字符连接到另一个字符串的尾部
strncmp ：比较字符串前n个字符
strncpy ：复制字符串的前n个字符
strpbrk ：查找字符串中第一个出现的指定字符
strrchr ：查找字符串中最后一个出现的指定字符
strspn ：计算字符串中由指定字符集字符组成的子字符串的长度
strcspn ：计算字符串中由非指定字符集字符组成的子字符串的长度

bcmp ：比较两个内存中的内容

#include<stdio.h>
#include<string.h>
int main()
{
	char s1[] = "abca";
	char s2[] = "abcb";
	char a = 'a';
	int b = 97;
	
	printf("%d\n",bcmp(s1,s2,3));
	printf("%d\n",bcmp(s1,s2,4));
	printf("%d\n",bcmp(s1,s2,5));
	printf("%d\n",bcmp(&a,&b,1));
	return 0;
}//运行结果：0,-1，-1,0
/*
函数原型:int bcmp(const void *s1,const void *s2,int n)
函数的功能是比较前n个字节是否相同，相同返回0，否则返回非零值
*/

bcopy : 复制内存中的内容

#include<stdio.h>
#include<string.h>
int main()
{
	char s1[10] = "0";
	char s2[] = "hello";
	bcopy(s2,s1,5);
	printf("%s\n",s1);	
	return 0;
}
//运行结果 hello
/*
函数原型void bcopy(const void* src,const void* dest,int n)
函数功能是将src的前n个字节拷贝到dest中
*/

bzero ：将一个内存内容全清零

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

int main()
{
	char s[] = "hello world";
	bzero(s,5);
	printf("[%s]\n",s);
	printf("[%s]\n",s+5);

	int a[] = {1,2,3,4,5,6,7};
	bzero(a,5);
	int i;
	for (i=0;i<7;i++)
	{
		printf("[%d]",a[i]);
	}

	return 0;
}
/*
运行结果：
[]
[ world]
[0][0][3][4][5][6][7],一个int型是4个字节
函数原型：bzero(void *s,int n)，将s指向的内容后n个字节清零
*/

ffs : 在一个整数中查找第一个值为真的位

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

int main()
{
	int a[] = {0,1,2,3,4,5};
	int pos = -1;
	int i;
	for (i=0;i<6;i++)
	{
		pos = ffs(a[i]);
		printf("the true bit of number %d is : %d\n",a[i],pos);
	}

	return 0;
}
/*
运行结果：
the true bit of number 0 is : 0
the true bit of number 1 is : 1  //二进制1
the true bit of number 2 is : 2	 //二进制10
the true bit of number 3 is : 1  //二进制11
the true bit of number 4 is : 3	 //二进制100
the true bit of number 5 is : 1  //二进制101

函数原型：int ffs(int i)
函数返回第一个为1的位置，若找到为1 的位置，返回1到31之间的值，否则返回0
*/

index : 查找字符串中第一个出现的指定字符

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

int main()
{
	char s[] = "hello world";
	char *ptr;

	printf("[%s]\n",index(s,'o'));
	printf("[%s]\n",index(s,'l'));

	return 0;
}
/*
运行结果：
[o world]
[llo world]
函数原型：char *index(const char *s,int c)
如果找到参数c，则返回指向该字符的指针，否则返回NULL
*/

memccpy ：复制内存中的内容

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

int main()
{
	char s1[20] = "0";
	char s2[] = "welcome to china";
	char *p;

	p = (char*)memccpy(s1,s2,'o',strlen(s2));
	printf("%s\n",s1);

	return 0;
}
/*
运行结果：welco
函数原型：void* memccpy(void *dest,const void*src,int c,size_t n);
如果c代表的字符在源内存区中存在，返回指向下一个字符的指针，否则返回NULL

*/

memchr ：在一块内存指定范围内查找一个指定字符

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

int main()
{
	char s[] = "welcome to china";
	char *p;

	p = (char*) memchr(s,'t',10);
	printf("%s\n",p);

	return 0;
}
/*
运行结果：to china
函数原型 void memchr(const void*s,int c,size_t n)
在指定的内存区域的前n个字节中查找c，如果找到参数c，返回指向c的指针，否则返回null
*/

memcmp ：比较内存中存放的内容

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

int main()
{
	char s1[] = "hello linux";
	char s2[] = "hello world";

	printf("%d\n",memcmp(s1,s2,5));
	printf("%d\n",memcmp(s1,s2,8));	

	return 0;
}
/*
运行结果：0,-1
函数原型 int memcmp(const void*s1,cosnt void*s2,size_t n)
比较两个内存区前n个字节的大小
*/

memcpy ：复制一块内存内容到另一块

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

int main()
{
	char s2[] = "welcome to china";
	char s1[] = "0";
	

	char *p = (char*)memcpy(s1,s2,10);

	printf("%d\n",(long)(&s1)-(long)(&s2));
	printf("%s\n",p);
	printf("%s\n",s1);
	printf("%s\n",s2);

	return 0;
}
/*
运行结果：
-2
welcome toto china
welcome toto china
lcome toto china

函数原型void* memcpy(void *dest,const void*src,size_t n),返回指向dest的指针
注意：当参数dest和src有重叠时，结果不可预测，可能出现错误

*/

memfrob ：对某个内存区重新编码

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

int main()
{
	char s[] = "123456";
	memfrob(s,8);
	printf("<%s>\n",s);
	memfrob(s,8);
	printf("<%s>\n",s);

	return 0;
}
/*
运行结果 <乱码> <123456>
函数原型 void *memfrob(void*s,size_t n)
对指定内存区的前n个字节进行编码

*/

memmove ：复制内存内容

void*memmove(void* dest,const void* src,size_t n)

功能和memcpy一样，只是当内存区域出现重叠时，memmove依然可以正常执行复制

memmove的处理措施：

（1）当源内存的首地址等于目标内存的首地址时，不进行任何拷贝

（2）当源内存的首地址大于目标内存的首地址时，实行正向拷贝

（3）当源内存的首地址小于目标内存的首地址时，实行反向拷贝

memset ：将某值填入到一个内存区域

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

int main()
{
	char s[] = "hello world";

	char *p = memset(s,'a',5);

	printf("%s\n",p);
	printf("%s\n",s);
	

	return 0;
}
/*
运行结果： 
aaaaa world
aaaaa world

函数原型 void memset(void *dest,int c,size_t n)
将参数c填入参数dest所指向的内存区的前n个字节中
*/

rindex ：查找字符串中最后一个出现的指定字符

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

int main()
{
	char s[] = "hello world";

	char *p = rindex(s,'o');

	printf("%s\n",p);
	printf("%s\n",s);
	

	return 0;
}
/*
运行结果： 
ord
hello world

函数原型 char* rindex(const char*s,int c)
反向查找指定字符，返回指向该字符的指针，否则返回null
*/

strcasecmp ：忽略大小写比较字符串

同strcmp，只不过忽略了大小写

strcat ：将一个字符串连接到另一个字符串的尾部

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

int main()
{
	char s[20] = "hello world";

	char *p = strcat(s," hello");

	printf("%s\n",p);
	printf("%s\n",s);
	

	return 0;
}
/*
运行结果： 
hello world hello
hello world hello

函数原型 char *strcat(char* dest,char* src)
注意总的字符串之和不能超过dest的长度
*/

strchr ；查找字符串中指定字符

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

int main()
{
	char s[20] = "hello world";

	char *p = strchr(s,'o');

	printf("%s\n",p);

	

	return 0;
}
/*
运行结果： 
o world

函数原型 char * strchr(const char*s,int c)
找到指定字符，返回指向该字符的指针，否则返回null
*/

strcmp ：比较两个字符串

同memcmp，只不过memcmp比较的是内存内容，而strcmp比较的是字符串

strcoll ：根据当前环境信息来比较字符串

根据LC_COLLATE目录来进行比较

strcpy ：复制一个字符串的内容到另一个字符串中

函数原型：char* strcpy(char*dest,char*src)，拷贝字符串

strdup ：复制字符串的内容

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

int main()
{
	char s[] = "hello world";

	char *p = strdup(s);

	printf("%s\n",p);

	

	return 0;
}
/*
运行结果： 
hello world

函数原型char *strdup(const char* str)
使用malloc分配内存空间，返回复制后的地址
*/

strfry ：随机重组一个字符串

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

int main()
{
	char s[] = "hello";

	printf("%s\n",strfry(s));
	printf("%s\n",strfry(s));
	printf("%s\n",strfry(s));

	

	return 0;
}
/*
运行结果： 
ohlel
eohll
lhoel

函数原型char *strfry(char *s)
随机重组字符串，返回首地址
*/

strlen ：返回字符串的长度

函数原型：size_t strlen(const char*s),返回'\0'之前的字符数

strncasecmp ：忽略大小写比较两个字符串

函数原型：int strncasecmp(const char*s1,const char*s2,size_t int)

同strcmp,只不过忽略大小

strncat ：将一个字符串的前n个字符连接到另一个字符串的尾部

函数原型： char* strncat(char *dest,const char* src,size_t n)

strncmp ：比较字符串前n个字符

函数原型：int strncmp(const char*s1,const char*s2,size_t n)，比较前n个字符的大小

strncpy ：复制字符串的前n个字符

函数原型：char* strncpy(char*dest,const char*src,size_t n),

复制前n个字符，如果碰到'\0',复制停止

strpbrk ：查找字符串中第一个出现指定字符集中指定的字符

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

int main()
{
	char s[] = "hello";
	char charset[] = "abcde";
	printf("%s\n",strpbrk(s,charset));

	return 0;
}
/*
运行结果： 
ello

函数原型：char* strpbrk(const char*s,const char*accept)
*/

strrchr ：查找字符串中最后一个出现的指定字符

同strchr，反向查找

函数原型：char* strrchr(const char*s,int c)

strspn ：计算字符串中由非指定字符集字符组成的子字符串的长度

函数原型：size_t strscpn(const char*s,cosnt char*accept)

strcspn ：计算字符串中由非指定字符集字符组成的子字符串的长度

函数原型：size_t strcscpn(const char*s,cosnt char*reject)

【上篇】C++书籍
【下篇】经典排序算法设计与分析（插入排序、冒泡排序、选择排序、shell排序、快速排序、堆排序、分配排序、基数排序、桶排序、归并排序）

作者: embryonic

该日志由 embryonic 于6年前发表在综合分类下，最后更新于 2017年12月14日.
转载请注明: linux中C语言函数：字符串处理函数 | 学步园 +复制链接

抱歉!评论已关闭.

学步园

linux中C语言函数：字符串处理函数

作者: embryonic

书签

最新文章New

本站推荐

返回首页