字符串和字符函数

Posted 闫鹏举

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了字符串和字符函数相关的知识，希望对你有一定的参考价值。

文章目录

前言

C语言中对字符以及字符串的处理是很频繁的，因此C语言库函数中包含了许多可以对字符及字符串进行一系列操纵的库函数，下面笔者将介绍一些常用的处理字符及字符串的的库函数，并且对其中一些进行模拟实现以加深理解。若有错误，请多多指教。

求字符串长度

strlen()

strlen()函数用于计算字符串的长度，由于字符串是以'\\0'作为结束标志，因此strlen(）返回的是在字符串中'\\0'之前的字符个数。

下面我们来看strlen()的参数类型：

size_t strlen(const char* str)

我们可以看到strlen()函数的使用需要把要计算长度的字符串的首地址进行传参，同时strlen()函数返回一个无符号类型的数，也就是字符串内字符的个数。

具体用法：

#include<string.h> // 要使用strlen()需要包含的头文件
int main()
{
     char arr[] = "abcdefg" ;
     //我们现在要计算arr数组内存放的字符串长度
     
     int ret = strlen(arr) ; 
     //将arr数组的首元素地址传过去
     //同时这里我们用一个整型来接收返回值，也就是字符串的长度
     return 0 ;
}

strlen()的模拟实现

//模拟实现strlen()
int my_strlen(const char* p)
{
	int count = 0; //统计字符的个数
		while (*p) //当*p为'\\0'时跳出循环
	{
		count++;   //当字符不为'\\0'count便加1
		p++;       //同时地址加1
	}
	return count; 
}

长度不受限制的字符串函数

strcpy()

strcpy()用于拷贝字符串，源字符串必须以'\\0'结束，strcpy（）会将源字符串完整到拷到目标字符串内，包括结尾的'\\0'。同时必须保证目标空间可变并且足够大，可以存放源字符串。

下面我们来看strcpy(）的参数类型：

char* strcpy(char* destination, const char* source) ;

第一个参数是目标空间首元素的地址，第二个参数是源字符串首元素的地址，返回参数是是拷贝后目标空间首元素的地址。

具体用法：

include<string.h> // 需要包含的头文件
int main()
{
      char arr1[] = "abcdefg" ;//目标字符串
      char arr2[] = "hijkl" ; //源字符串
      strcpy(arr1, arr2) ;
      return 0 ;
}

strcpy()的模拟实现

//模拟实现strcpy()
char* my_strcpy(char* p1, const char* p2) 
{
	assert(p2 != NULL);
	char* ret = p1; //先记录下目标空间首元素的地址
	while (*(p1++) = *(p2++)) //将源字符串内容一一拷贝到目标字符串内
	{
		;
	}
	return ret;//返回目标字符串首地址元素
}

strcat()

strcat()用于追加字符串，将源字符串内容拷贝到目标字符串后，同时必须保证目标空间可以修改，并且足够大，源字符串必须以'\\0'结尾。

下面我们来看strcat()的参数类型

char* strcat(char* destination, const char* source) ;

第一个参数为目标字符串首元素地址，第二个参数为源字符串首元素地址，返回参数为追加后，目标字符串首元素地址。

具体用法：

#include<string.h> //需要包含的头文件
int main()
{
     char arr1[] = "hello " ;//目标字符串
     char arr2[] = "world!" ; //源字符串
     strcat(arr1, arr2) ;
     return 0 ;
}

strcat()的模拟实现

//模拟实现strcat()
char* my_strcat(char* p1, const char* p2)
{
	char* ret = p1;//记录目标字符串首元素地址
	assert(p1 != NULL);
	assert(p2 != NULL);
	while(*p1)//先找到目标字符串结尾
	{
	 p1++;
	}
	while (*p1++ = *p2++)//从目标字符串结尾开始追加源字符串
	{
		;
	}
	return ret;
}

strcmp()

strcmp()用于比较两个字符串，标准规定，若第一个字符串大于第二个字符串，则返回大于0的数字；若第一个字符串等于第二个字符串则返回0；若第一个字符串小于第二个字符串则返回小于0的数字。具体比较方法为：首先比较首元素的ASCII码值若第一个字符串首元素的ASCII值大于第二个字符串首元素则返回大于0的数，若小于返回小于0的数，若相等继续下一个字符的比较，以此类推。

下面我们来看strcmp()的参数类型

int strcmp(const char* str1, const char* str2) ;

第一个参数为目标字符串首元素地址，第二个参数为源字符串首元素地址，返回参数是一个整型。

strcmp()的模拟实现

//模拟实现strcmp()

int my_strcmp(const char* p1, const char* p2)
{
	while (*p1 == *p2)
	{
		if (*p2 == '\\0')
		{
			return 0;
		}
		p1++;
		p2++;
	}

	return *p1 - *p2;
}

长度受限制的字符串函数介绍

上面介绍的这些库函数能够操作的字符串长度都是不受限制的，下面所介绍的这些库函数基本原理与以上相同，只不过增加了长度的限制。

strncpy()

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

strncpy()与strcpy()相比新增加了一个参数，这个参数是一个无符号的整型，它规定了必须要拷贝num个字符从源字符串到目标字符串，若源字符串的长度小于num,则拷贝完源字符串之后，在目标字符串的后面追加0，直到num个。

strncat()

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

strncat()的第三个参数规定了在目标字符串后追加的源字符串内字符的个数

strncmp()

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

与上同理，比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

字符串查找

strstr()

strstr()函数用于查找目标字符串中指定的内容。

下面我们来看strstr()的参数类型：

 char * strstr ( char * str1, const char * str2 );

第一个参数为要扫描的 C 字符串，第二个参数为包含要匹配的字符序列的 C 字符串。返回值为指向str2 中指定的整个字符序列在str1中第一次出现的指针，如果该序列不存在于str1 中，则为空指针。

具体用法：

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

int main ()
{
  char str[] ="This is a simple string";
  char * pch;
  pch = strstr (str,"simple");
  if (pch != NULL)
    strncpy (pch,"sample",6);
  puts (str);
  return 0;
}

strstr()的模拟实现

//模拟实现strstr()
char* my_strstr(const char* p1, const char* p2)
{
	char* ret1 = (char*)p1;
	char* ret2 = (char*)p2;
	char* ret = NULL;
	if (*p2 == '\\0')
	{
		return NULL;
	}
	while (*ret1)
	{
		ret = ret1;
		ret2 = (char*)p2;
		while (*ret1 == *ret2 && *ret1 && *ret2)
		{
			ret1++;
			ret2++;
		}
		if (*ret2 == '\\0')
		{
			return ret;
		}
		ret1++;
	}
	return NULL;
}

strtok()

strtok()用于将字符串中指定的位置进行分割。

下面我们来看strtok（）的参数类型：

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

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \\0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改
变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

具体用法：

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

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \\"%s\\" into tokens:\\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}

内存操作函数

memcpy()

memcpy()用于从原字符串首元素的位置开始向后赋值指定个字节的数据到目标字符串

参数类型：

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

第一个参数为指向要复制内容的目标数组的指针，类型转换为void类型的指针，第二个参数为指向要复制的数据源的指针，类型转换为const void类型的指针，第三个参数为要复制的字节数。返回值为目标字符串首元素地址。需要注意的是如果源字符串和目标字符串的地址有任何重叠，复制的结果都是未定义的。

具体用法：

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

struct {
  char name[40];
  int age;
} person, person_copy;

int main ()
{
  char myname[] = "Pierre de Fermat";

  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;

  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );

  printf ("person_copy: %s, %d \\n", person_copy.name, person_copy.age );

  return 0;
}

memcpy（）的模拟实现

void* my_memcpy(void* dest, const void* sour, size_t num)
{
	assert(dest);
	assert(sour);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)sour;
		dest = (char*)dest + 1;
		sour = (char*)sour + 1;
	}
	return ret;
}

memmove()

和memcpy（）的差别就是memmove()处理的源内存块和目标内存块是可以重叠的。因此若出现源空间与目标空间出现重叠，就可以用memmove进行处理。

参数类型：

void * memmove ( void * destination, const void * source, size_t num );

参数类型及用法与memcpy相同。下面我们来看看具体是如何实现的。

memmove()的模拟实现

void* my_memmove(void* dest, const void* sour, size_t num)
{
	assert(dest);
	assert(sour);
	void* ret = dest;
	if (dest <= sour)
	{
		while (num--)
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
		}
	}
	else
	{
		dest = (char*)dest + num - 1;
		sour = (char*)sour + num - 1;
		while (num--)
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest - 1;
			sour = (char*)sour - 1;
		}
	}
	return ret;
}

memcmp()

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

memcmp()用于比较从ptr1和ptr2开始的num个字节，若在两个内存块中不匹配的第一个字节在ptr1中的值低于在ptr2 中的值则返回小于0的数字，若两个内存块的内容相等，则返回0，若在两个内存块中不匹配的第一个字节在ptr1中的值大于在ptr2 中的值，则返回大于0的数字。

具体用法：

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

int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";

  int n;

  n=memcmp ( buffer1, buffer2, sizeof(buffer1) );

  if (n>0) printf ("'%s' is greater than '%s'.\\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\\n",buffer1,buffer2);

  return 0;

以上是关于字符串和字符函数的主要内容，如果未能解决你的问题，请参考以下文章

21个常用代码片段

sql数据库截取字符串函数

web代码片段

Python代码阅读（第38篇）：根据谓词函数和属性字符串构造判断函数

sql将字符串拆分为始终相同数量的片段

字符串插值和片段之间有啥显着区别吗？