字符函数和字符串函数

字符函数和字符串函数

• strlen（字符串长度函数）
  size_t strlen ( const char * str )
• 字符串以’\0’作为结束标志，strlen函数返回的是在字符串’\0’前面出现的字符个数（不含’\0’）
• 参数指向的字符串必须以’\0’结束
• 函数返回值为size_t，是无符号的
  strlen函数的模拟实现

//模拟实现strlen
#include<stdio.h>
#include<assert.h>
#include<Windows.h>
int Mystrlen(const char *str)
{
	int n = 0;
	assert(str);
	while (*str)
	{
		n++;
		str++;
	}


	return n;
}
int main()
{
	const char str[] = "abcdefg";
	printf("%d\n", Mystrlen(str));
	system("pause");
	return 0;
}

• strcpy（字符串拷贝函数）
  char* strcpy(char * destination,const char * source);
• 源字符串必须以’\0’结束
• 会将源字符串中的’\0’拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
  strcpy函数的模拟实现

//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
#include<windows.h>
void Mystrcpy(char*dst, const char *str)
{
	assert(dst);
	assert(str);
	while (*dst++=*str++)
	{
		;
	}	
}
int main()
{
	char dst[20];
	const char str[] = "hello!";
	Mystrcpy(dst, str);
	printf("%s\n", dst);
	system("pause");
	return 0;
}

• strcat（字符串拼接函数）
  char * strcat(char * destination,const char * source);
• 源字符串必须以 ‘\0’ 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。
  strcat函数的模拟实现

//模拟实现strcat
#include<stdio.h>
#include<assert.h>
#include<windows.h>
void Mystrcat(char *dst, const char*str)
{
	assert(dst);
	assert(str);
	while (*dst)
	{
		dst++;
	}
	while (*dst = *str)
	{
		*dst++;
		str++;
	}
}
int main()
{
	char dst[20] = "hello";
	const char str[] = " world!";
	Mystrcat(dst, str);
	printf("%s\n", dst);
	system("pause");
	return 0;
}

• strcmp（字符串比较函数）
  int strcmp ( const char * str1, const char * str2 );
• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字
  strcmp函数的模拟实现

//模拟实现strcmp
#include<stdio.h>
#include<assert.h>
#include<Windows.h>
int Mystrcmp(const char*str1, const char*str2)
{
	assert(str1);
	assert(str2);
	while (*str1&&*str2)
	{
		if (*str1 > *str2)
			return 1;
		if (*str1 < *str2)
			return -1;
		str1++;
		str2++;
	}
	if (*str1)
	{
		return 1;
	}
	if (*str2)
	{
		return -1;
	}
	else return 0;
}
int main()
{
	const char str1[] = "abcde";
	const char str2[] = "abcdd";
	int n = Mystrcmp(str1,str2);
	if (n)
	{
		if (n == -1)
			printf("str2>str1\n");
		else  printf("str1>str2\n");
	}
	else
		printf("str1=str2\n");
	system("pause");
	return 0;
}

• strncpy
  char * strncpy ( char * destination, const char * source, size_t num);

• 拷贝num个字符从源字符串到目标空间

• 如果源字符串的长度小于num，则拷贝完源字符串后，在目标串的后面追加0，直到num个,不自动添加’\0’

• strcpy只是复制字符串，但不限制复制的数量，很容易造成缓冲溢出。strncpy要安全一些。

• strncat
  char * strncat( char * destination,const char * source,size_t num)

• 将源字符串的num个字符附加到目标串，再加上’\0’

• 如果源字符的串长度小于num，则只复制不超过字符’\0’的内容

• strncmp
  int strcmp(const char * str1,const char *str2,size_t num);

• 比较到出现某个字符不一样的时候或是某个字符串结束或是num个字符全部比较完

• strstr（）（字符串搜索函数）
  char strstr(const char *str1,const char *str2);

• 返回的是在str1中第一次出现str2的首地址，没找到的话返回NULL
  strstr函数的模拟实现

• 该函数对大小写敏感,如需进行大小写不敏感的搜索，请使用 stristr()

//模拟实现strstr
void *Mystrstr(const char *dst, const char* str)
{
	assert(dst);
	assert(str);
	while (*dst)
	{
		const char *p = dst;
		const char*q = str;
		while (*p && *q && *p == *q)
		{
			p++;
			q++;
		}
		if (*q == '\0')
			return dst;
		dst++;
	}
	return 0;
}

• strtok(字符串分隔函数）
  char * strtok ( char * str, const char * sep );

• sep参数是个字符串，定义了用作分隔符的字符集合

• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

• 如果字符串中不存在更多的标记，则返回 NULL 指针。

• strerror
  char * strerror(int errnum)

• 返回错误码所对应的错误信息

• 必须包含头文件 #include<errno.h>

• 字符转换：

• int tolower(int c);//大写转小写

• int toupper(int c);//小写转大写

• memcpy
  void * memcpy ( void * destination, const void * source, size_t num );

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

• 这个函数在遇到 ‘\0’ 的时候并不会停下来。

• 如果source和destination有任何的重叠，复制的结果都是未定义的。
  memcpy函数的模拟实现

void * Mymemcpy(void * dst, const void * str, int n)
{
	assert(dst);
	assert(str);
	char*p = (char*)dst;
	const char*q= (const char*)str;
	while (n)
	{
		*p = *q;
		p++;
		q++;
		n--;
	}
	return dst;
}

• memmove
  void * memmove ( void * destination, const void * source, size_t num );
• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
  memmove函数的模拟实现

void *Mymemmove(void *dst, const void *str, int n)
{
   assert(dst);
   assert(str);
   char *_dst = (char *)dst;
   const char *_str = (const char *)str;
   if (_dst > _str && _dst < _str + n)//right -> left
   {
   	_dst = _dst + n - 1;
   	_str = _str + n - 1;


   	while (n){
   		*_dst = *_str;
   		_dst--;
   		_str--;
   		n--;
   	}
   }
   else//left -> right
   {
   	while (n)
   	{
   		*_dst = *_str;
   		_dst++;
   		_str++;
   		n--;
   	}
   }
   return dst;
}

• memcmp
  int memcmp(const void * ptr1,const void * ptr2,size_t num);

• 比较从ptr1和ptr2指针开始的num个字节

• 返回值方式和strcmp基本类似