基本的字符串操作及其实现

于 2013-12-11 17:20:01 发布
阅读量1.9k 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： C 字符串 基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pngynghay/article/details/17266577
版权

本文主要实现基本的字符串操作，这些操作大部分都有C API，本文虽然是在重复造轮子，但是，并不是无用功。这些重造的轮子增加了参数判断，可以让自己的代码更加健壮。

为了简便且可以说明问题，本文中使用了assert，而没有使用if判断。是个缺陷~~~安静 

需要包含的头文件

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

字符串长度

C原型：

size_t strlen(const char *s);

功能：计算字符串长度

返回值：字符个数

注：计算出来的长度，不包括最后的'\0'字符

size_t mystrlen(const char *s)
{
	size_t len = 0;	
	assert(NULL != s);
	while('\0' != *s++)
		++len;
	return len;	
}

 转换成大写（小写）字母

功能：将字符串中的字母字符全部转成大写或者小写

返回值：转换后的字符串

注：非字母字符不做任何变化；入参会被改变，改变后的值同返回值

char *mystrtolower(char *s)
{
        char *ps = s;
        assert(NULL != s);
        while('\0' != *ps)
        {
                if('A' <= *ps && 'Z' >=*ps)
                        *ps = *ps - 'A' + 'a';
                ps++;
        }
        return s;
}

char *mystrtoupper(char *s)
{
        char *ps = s;
        assert(NULL != s);
        while('\0' != *ps)
        {
                if('a' <= *ps && 'z' >=*ps)
                        *ps = *ps - 'a' + 'A';
                ps++;
        }
        return s;
}

字符串赋值

C原型：

char *strcpy(char *dest, const char *src);

功能：将字符串从src复制到dest

返回值：指向dest的指针

说明：dest要有足够的空间去存储从src复制来的字符

 

char *strncpy(char *dest, const char *src, size_t n);

功能：从src复制最多复制n个字符到dest

返回值：指向dest的指针

说明：如果复制的n个字符没有以'\0'结束，dest也不会以'\0'结束

注：在下面的函数实现中，添加了'\0'结束dest，这一点与C API实现有点不同，且'\0'并不包含n个字符之中

char *mystrcpy(char *dest, const char *src)
{
	char *addr = NULL;
	if(dest == src)
		return dest;
	assert((NULL != dest) && (NULL != src));
	addr = dest;
	while('\0' != (*dest++ = *src++));
	return addr;
}

char *mystrncpy(char *dest, const char *src, size_t n)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while(n-- && '\0' != *src)
		*dest++ = *src++;
	*dest = '\0';
	return addr;
}

定位给定字符在字符串中的位置

C原型：

char *strchr(const char *s, int c);

功能：定位给定字符c在字符串s中首次出现的位置

返回值：指向匹配的字符的指针，如果找不到该字符，则返回NULL

 

char *strrchr(const char *s, int c);

功能：定位给定字符c在字符串s中最后一次出现的位置

返回值：指向匹配的字符的指针，如果找不到该字符，则返回NULL

char *mystrchr(const char *s, int c)
{	
	char ch = (char)c;
	assert(NULL != s);	
	for(; ch != *s; ++s)
		if('\0' == *s)
			return NULL;
	return (char *)s;
}

char *mystrrchr(const char *s, int c)
{
	char ch = (char)c;
	const char *st = s;
	assert(NULL != s);
	while('\0' != *st)
		st++;

	for(--st; ch != *st; --st)
		if(st == s)
			return NULL;
	return (char *)st;
}

字符串比较

C原型：

int strcmp(const char *s1, const char *s2);

功能：比较两个给定的字符串

返回值：s1==s2返回0；s1<s2,返回负值；s1>s2返回正值

 

int strncmp(const char *s1, const char *s2, size_t n);

功能：比较两个给定的字符串，最多比较前n个字符

返回值：最多前n个字符，s1==s2返回0；s1<s2,返回负值；s1>s2返回正值

 

int strcasecmp(const char *s1, const char *s2);

int strncasecmp(const char *s1, const char *s2, size_t n);

说明：功能同上述两个函数，只是，这两个函数忽略字母的大小写

int mystrcmp(const char *s1, const char *s2)
{
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && *s1 == *s2)
	{
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrncmp(const char *s1, const char *s2, size_t n)
{
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && *s1 == *s2 && n--)
	{
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrcasecmp(const char *s1, const char *s2)
{
	char st1, st2;
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2)
	{
		st1 = *s1;
		st2 = *s2;
		if('A' <= st1 && 'Z' >= st1)
			st1 = st1 - 'A' + 'a';
		if('A' <= st2 && 'Z' >= st2)
			st2 = st2 - 'A' + 'a';
		if(st1 != st2)
			break;
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int mystrncasecmp(const char *s1, const char *s2, size_t n)
{
	char st1, st2;
	assert(NULL != s1 && NULL != s2);
	while(*s1 && *s2 && n--)
	{
		st1 = *s1;
		st2 = *s2;
		if('A' <= st1 && 'Z' >= st1)
			st1 = st1 - 'A' + 'a';
		if('A' <= st2 && 'Z' >= st2)
			st2 = st2 - 'A' + 'a';
		if(st1 != st2 || 0 == n)
			break;
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

字符串拼接

C原型：

char *strcat(char *dest, const char *src);

功能：将src拼接到dest后面

返回值：指向拼接后的dest的指针

说明：dest需要有足够的空间

 

char *strncat(char *dest, const char *src, size_t n);

功能：将src的最多前n个字符拼接到dest后面

返回值：指向拼接后的dest的指针

说明：dest需要有足够的空间，由于总是以'\0'结束，所以，最多向dest写入n+1个字符

char *mystrcat(char *dest, const char *src)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while('\0' != *dest)
		dest++;
	while('\0' != (*dest++ = *src++));
	return addr;
}

char *mystrncat(char *dest, const char *src, size_t n)
{
	char *addr = NULL;
	assert(NULL != dest && NULL != src);
	addr = dest;
	while('\0' != *dest)
		dest++;
	while(n-- && '\0' != *src)
		*dest++ = *src++;
	*dest = '\0';
	return addr;
}

查找字串

C原型：

char *strstr(const char *haystack, const char *needle);

功能：定位给定字串needle在字符串s中首次出现的位置

返回值：指向字串的起始位置的的指针，如果找不到该字串，则返回NULL

说明：在Linux libc起初版本中，needle不能为空，但从4.6.27版本开始，needle为空时，返回haystack

 

#define _GNU_SOURCE

char *strcasestr(const char *haystack, const char *needle);

功能：定位给定字串needle在字符串s中首次出现的位置，查找时忽略字符的大小写

返回值：指向字串的起始位置的的指针，如果找不到该字串，则返回NULL

说明：The strcasestr() function is a non-standard extension.strcasestr不是非标准扩展，用到该函数时，需要定义宏_GNU_SOURCE

char * mystrstr(const char *haystack, const char *needle)
{
        const char *s = NULL;
        const char *t = NULL;
        assert(NULL != haystack && NULL != needle);
        for(; *haystack != '\0'; haystack++)
        {
                for(s = haystack, t = needle; *t != '\0' && *s != '\0'; ++s, ++t)
                {
                        if(*t != *s)
                                break;
                }
                if('\0' == *t)
                        return (char *)haystack;
        }
        return NULL;
}

char * mystrcasestr(const char *haystack, const char *needle)
{
        const char *s = NULL;
        const char *t = NULL;
        char cs, ts;
        assert(NULL != haystack && NULL != needle);
        for(; *haystack != '\0'; haystack++)
        {
                for(s = haystack, t = needle; *t != '\0' && *s != '\0'; ++s, ++t)
                {
                        cs = *s;
                        ts = *t;
                        if('A' <= cs && 'Z' >= cs)
                                cs = cs - 'A' + 'a';
                        if('A' <= ts && 'Z' >= ts)
                                ts = ts - 'A' + 'a';
                        if(cs != ts)
                                break;
                }
                if('\0' == *t)
                        return (char *)haystack;
        }
        return NULL;
}

 

复制字符串

C原型

char *strdup(const char *s);

功能：复制一个字符串

返回值：复制后，新的字符串的起始地址的指针

说明：内部以malloc分配空间，调用者需要调用free释放，以防内存泄露

 

#define _GNU_SOURCE

char *strndup(const char *s, size_t n);

功能：复制最多n个字符到新的字符串

返回值：复制后，新的字符串的起始地址的指针

说明：复制后的新字符串会被加上'\0'以结尾；该字符串同样需要free释放

注：strndp不是非标准扩展，用到该函数时，需要定义宏_GNU_SOURCE

char *mystrdup(const char *s)
{
        size_t len = 0;
        const char *start = NULL;
        char *addr = NULL;
        if(NULL == s)
                return NULL;
        while(*s++ != '\0')
                len++;
        addr = (char *)malloc(len + 1);
        assert(NULL != addr);
        start = s;
        while((*addr++ = *start++) != '\0');
        return addr - (len + 1);
}

char *mystrndup(const char *s, size_t n)
{
        size_t len = 0;
        const char *start = NULL;
        char *addr = NULL;
        if(NULL == s)
                return NULL;
        while(*s++ != '\0')
                len++;
        if(len > n)
                len = n;
        addr = (char *)malloc(len + 1);
        assert(NULL != addr);
        n++;
        start = s;
        while(n-- && (*addr++ = *start++) != '\0');
        *(addr-1) = '\0';
        return addr - (len + 1);
}

多字符搜索

C原型：

size_t strspn(const char *s, const char *accept);

功能：从参数s 字符串的开头计算连续的字符，而这些字符都完全是accept 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。

返回值：返回字符串s开头连续包含字符串accept内的字符数目

 

size_t strcspn(const char *s, const char *reject); 

功能：从参数s字符串的开头计算连续的字符，而这些字符都完全不在参数reject 所指的字符串中。简单地说，若strcspn()返回的数值为n，则代表字符串s开头连续有n个字符都不含字符串reject内的字符。

返回值：返回字符串s开头连续不含字符串reject内的字符数目

size_t mystrspn(const char *s, const char *accept)
{
        const char *st = NULL;
        const char *at = NULL;
        assert(NULL != s && NULL != accept);
        for(st = s; *st != '\0'; st ++)
        {
                for(at = accept; *at != '\0'; at++)
                {
                        if(*st == *at)
                                break;
                }
                if(*at == '\0')
                        return st - s;
        }
        return st - s;
}

size_t mystrcspn(const char *s, const char *reject)
{
        const char *st = NULL;
        const char *at = NULL;
        assert(NULL != s && NULL != reject);
        for(st = s; *st != '\0'; st++)
                for(at = reject; *at != '\0'; at++)
                        if(*st == *at)
                                return st - s;
        return st - s;
}

搜索多个字符中的第一个字符

C原型：

char *strpbrk(const char *s, const char *accept);

功能：找出参数s 字符串中最先出现存在参数accept 字符串中的任意字符

返回值：指向找到的字符的位置，找不到则返回NULL

char *mystrpbrk(const char *s, const char *accept)
{
        const char *st = NULL,*at = NULL;
        assert(NULL != s && NULL != accept);
        for(st = s; *st != '\0'; st++)
                for(at = accept; *at != '\0'; at++)
                        if(*st == *at)
                                return (char *)st;
        return NULL;
}

根据分隔符提取字符串

C原型：

char *strtok(char *str, const char *delim);

功能：strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。

返回值：每次调用成功则返回指向被分割出片段的指针，如果不再含有delim，则返回NULL

说明：strtok用static变量保存上次的分割位置，所以，不是线程安全的。

注：strtok函数会破坏被分解字符串的完整，调用前和调用后的s已经不一样了。

 

char *strtok_r(char *str, const char *delim, char **saveptr);

功能：同strtok，只是该函数是线程安全的。

说明：用*saveptr来保存上次的分割位置，代替了strtok的静态变量缺陷

 

char *strsep(char **stringp, const char *delim);

功能：同strtok

说明：如果*stringgp为NULL，则直接返回NULL；而strtok不允许str为NULL

注：strtok的替代函数，它可以接受空串；但strtok具有更好的可移植性

char *mystrtok(char *str, const char *delim)
{
        assert(delim != NULL);
        static char *last;
        char *s = NULL;
        const char *t = NULL;
        if ( NULL == str  && NULL == (str = last))
                return NULL;
        for( s = str ; *s != '\0'; s++)
                for(t = delim; *t != '\0'; t++)
                        if(*s == *t)
                        {
                                last = s + 1;
                                if (s - str == 0)
                                {
                                        str = last;
                                        break;
                                }
                                *(str + (s - str)) = '\0';
                                return str;
                        }
        return NULL;
}

char *mystrtok_r(char *s, const char *delim, char **save_ptr) {
        char *token;
        if (NULL == s)
                s = *save_ptr;
        s += mystrspn(s, delim);
        if (*s == '\0')
                return NULL;
        token = s;
        s = mystrpbrk(token, delim);
        if (NULL == s)
                *save_ptr = mystrchr(token, '\0');
        else {
                *s = '\0';
                *save_ptr = s + 1;
        }
        return token;
}

char *mystrtok2(char *str, const char *delim)
{
        static char * save;
        return mystrtok_r(str, delim,&save);
}

char *mystrsep(char **stringp, const char *delim)
{
        char *sbp = *stringp, *end;
        if(NULL == sbp)
                return NULL;
        end = mystrpbrk(sbp, delim);
        if(NULL != end)
                *end++ = '\0';
        *stringp = end;
        return sbp;
}

 

由于分割字符串不太好理解，附上测试程序：

另外，为了运行下面的测试程序，需要自己添加上所需要的本博文上述实现的函数。

#include <string.h>

void systok()
{
	char str[] ="This is a sample string,just testing.";
	char * pch;
	printf ("Splitting string \"%s\" in tokens:\n",str);
	pch = strtok (str," ");
	while (pch != NULL)
	{
		printf ("%s\n",pch);
		pch = strtok (NULL, " ,.");
	}
}

void mytok()
{
	char str[] ="This is a sample string,just testing.";
	char * pch;
	printf ("Splitting string \"%s\" in tokens:\n",str);
	pch = mystrtok (str," ");
	while (pch != NULL)
	{
		printf ("%s\n",pch);
		pch = mystrtok (NULL, " ,.");
	}
}

void systok_r()
{
	int in=0,j;
	char buffer[]="Fred male 25,John male 62,Anna female 16";
	char *p[20];
	char *buf=buffer;
	char *outer_ptr=NULL;
	char *inner_ptr=NULL;
	while((p[in] = strtok_r(buf, ",", &outer_ptr))!=NULL) 
	{
		buf=p[in];
		while((p[in]=strtok_r(buf, " ", &inner_ptr))!=NULL) 
		{
			in++;
			buf=NULL;
		}
		buf=NULL;
	}
	printf("Here we have %d strings\n",in);
	for (j=0; j<in; j++)
	{	
		printf("%s\n",p[j]);
	}
}

void mytok_r()
{
	int in=0,j;
	char buffer[]="Fred male 25,John male 62,Anna female 16";
	char *p[20];
	char *buf=buffer;
	char *outer_ptr=NULL;
	char *inner_ptr=NULL;
	while((p[in] = mystrtok_r(buf, ",", &outer_ptr))!=NULL)
	{
		buf=p[in];
		while((p[in]=mystrtok_r(buf, " ", &inner_ptr))!=NULL)
		{
			in++;
			buf=NULL;
		}
		buf=NULL;
	}
	printf("Here we have %d strings\n",in);
	for (j=0; j<in; j++)
	{
		printf("%s\n",p[j]);
	}
}

int main()
{
	systok();
	printf("=============================================\n");
	mytok();
	printf("=============================================\n");
	systok_r();
	printf("=============================================\n");
	mytok_r();
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值