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

strlen部分

strlen函数的易错小知识

strlen函数的实现

strcpy部分

strcat部分

自己实现strcat

strstr函数部分

简单例子：

分析

strcmp部分

长度受限制的字符串函数

strncpy

简单例子

strncat

strncmp

简单例子

👉 本菜鸡&总结 👈

😎博客昵称：陈大大陈

😊座右铭：所谓觉悟，就是在漆黑的荒野上开辟出一条理当前进的光明大道。

😋博主简介：一名热爱C/C++和算法等技术，喜欢运动，爱胡思乱想却胸怀大志的小博主！

😚博主&唠嗑：早午晚哈喽Ciao！😄各位CSDN的朋友！😄我是博客新人陈大大陈，希望我的文章能为你带来帮助！欢迎大家在评论区畅所欲言！也希望大家多多为我提出您宝贵的建议！😘如果觉得我写的不错的话还请点个赞和关注哦~😘😘😘

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

strlen部分

strlen函数的易错小知识

我们知道，strlen函数是用来求字符串的长度的。

size_t strlen( const char *string );

Each of these functions returns the number of characters in string, excluding the terminal NULL.

其中每个函数都返回字符串中的字符数，到\0为止（不包括\0）,不包括NULL指针。

需要注意的是，strlen的返回类型是size_t.

size_t 是一些C/C++标准在stddef.h中定义的，size_t 类型表示C中任何对象所能达到的最大长度，它是无符号整数。

初学者很容易误以为strlen的返回类型是int，这点需要特别注意，看下面的代码来巩固。

#include <stdio.h>
#include<string.h>
int main()
{
	const char* str1 = "chendada";
	const char* str2 = "chen";
	if (strlen(str2) - strlen(str1) > 0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}
	return 0;
}

运行结果如下：

嘻嘻，不知道有多少老铁踩坑了？😋可不能想当然地认为结果是个负数，切记strlen的返回类型是无符号整形！

这两个字符串长度相减的结果，如果从整形的角度来看，是-4没错，但是我们的返回类型是无符号整形，而无符号整形减去无符号整形的结果也是一个无符号整形。

也就是说，-4储存在内存中的补码并没有转换成源码来参与运算，而是直接被当成是一个数字来参与运算，我们知道，这个运算的结果一定是一个正数。

strlen函数的实现

strlen函数的实现更是多种多样，我在这里列出以下三种。

1.计数器

2.递归

3.指针-指针

//计数器方式
int my_strlen(const char * str)
{
 int count = 0;
 while(*str)
 {
 count++;
 str++;
 }
 return count;
}

//递归，不需要创建临时变量计数器
int my_strlen(const char * str)
{
 if(*str == '\0')
 return 0;
 else
 return 1+my_strlen(str+1);
}

//指针-指针的方式
int my_strlen(char* str)
{
	char* p = str;
	while (*p != '\0')
	{
		p++;
	}
	return p - str;
}

我们在这里将返回类型改成int，这样可以有效规避上面无符号整形导致误判的情况。

在以上代码里，我们都可以加入const和assert断言函数来让程序更安全。

strcpy部分

函数的参数形式char* strcpy(char*destination,const char*source)；

该参数说明了strcpy返回类型是char类型的指针，将源头（不能被改）拷贝到目的地。

strcpy特点和strlen类似，遇到‘\0’就停止。

看下面的代码，最后打印的是什么呢？

#include <stdio.h>
#include<string.h>}
int main()
{
    char str1[100] = "chen\0dada";
    char str2[100] = "xxxxxxxxx";
	strcpy(str2, str1);
	printf("%s", str2);
	return 0;
}

运行结果如下：

正如上面所说，遇到\0就停止。

可以看到，strcpy会将\0也一并拷过去。

需要特别注意的是，目标空间必须可变，且必须足够大，用来确保能存放源字符串。

自己实现strcpy的方式非常多，在自制strcpy函数之前，我们需要知道，strcpy函数返回的是目标空间的起始地址，所以它的返回类型是一个指针，例如char *。

我们知道源头的地址不能改变，所以我们要加上const来修饰。

同时，为了确保指针有效，我们使用断言函数。

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;//目标空间的起始地址
	assert(dest && src);
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

strcpy函数返回的是目标空间的起始地址，所以它的返回类型是一个指针，例如char *。

我们可以用这一点实现下面的代码。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}
int main()
{
	char a[10] = "";
	char b[] = "dada";
	printf("%s", my_strcpy(a, b));
	return 0;
}

strcat部分

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

Appends a copy of the source string to the destination string. The terminating null character

in destination is overwritten by the first character of source, and a null-character is included

at the end of the new string formed by the concatenation of both in destination.

源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。

简单的例子如下：

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

void main( void )
{
   char string[80];
   strcpy( string, "Hello world from " );
   strcat( string, "strcpy " );
   strcat( string, "and " );
   strcat( string, "strcat!" );
   printf( "String = %s\n", string );
}

strcat函数是从\0的位置开始，会将\0用第一个元素覆盖。

那strcat能不能将自己拷贝到自己后面，即函数的参数为同一字符串呢？

我们看下面的代码。

自己实现strcat

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest)
	{
		dest++;
	}
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

答案自然是不行的，调试会一直卡在这个位置，程序是死循环的结果。

为什么会死循环呢？请看我做的图。

一开始是这样，dest和src全都指向第一个字符。

然后dest找到\0的位置，准备开始拷贝。

紧接着\0被转化为c，且src向后位移一个字节。

这样下去的结果是。

dest应该去找下一个\0，可是\0已经在上面被字符'C'覆盖，也就是说,\0已经不复存在，程序崩溃。

strstr函数部分

char *strstr( const char * string , const char * strCharSet )

Each of these functions returns a pointer to the first occurrence of strCharSet in string, or NULL if strCharSet does not appear in string. If strCharSet points to a string of zero length, the function returns string.

Each of these functions returns a pointer to the first occurrence of strCharSet in string, or NULL if strCharSet does not appear in string. If strCharSet points to a string of zero length, the function returns string.

函数返回一个指针，指向字符串中第一次出现的地址，如果该地址未出现在字符串中，则返回 NULL。如果该地址指向长度为零的字符串，则该函数返回字符串。

简单例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
char* my_strstr(const char* a, const char* b)
{
	char* s1 = NULL;
	char* s2 = NULL;
	char* cp = (char*)b;
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)b;
		while(*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cp;
		}
			cp++;
	}
	return NULL;
}
int main()
{
	char a[10] = "bcdef" ;
	char b[10] = "cde";
	if (my_strstr(a,b) == NULL)
	{
		printf("找不到");
	}
	else
	{
		printf("%p", my_strstr(a,b));
	}
	return 0;
}

分析

假设有两个字符串，指针str1, str2分别指向字符串首字母。
要在str1中查找str2并打印出来，先判断str1和str2指向的字符是否相等，此时有两种情况：第一种情况指向的字符不相等，str1要指向下一个字符，再判断，如此循环往复，当str1指向的是 '\0' 时，可以判断出str1中不存在str2，此时返回NULL；
第二种情况下指向的字符相等，那么不仅str1要向后读取字符，str2也要向后读取字符，再判断是否相等。
在向后读取字符的过程中，仍有两种情况：1.str1和str2指向的字符一直相等，直到str2指向'\0'，这时可以知道str1中存在str2字符串，返回的是str1中的str2字串的第一个字符地址；
2.str1和str2指向的字符不全相等，例如下图中，*(str1+1) == *str2，*(str1+2) == *(str2+1)，*(str1+3) != *(str2+2)，此时指针str2就要返回到字符串str2首字符的地址，而指针str1需要返回到第一次和str2指向的字符相等的后一个位置，即字符串str1中第二个 'b' 的地址。然后又回到一开始的判断。

strcmp部分

strcmp函数是专门用来字符串之间的的比较的
这个比较是比较两个字符串是否相同，如果不相同那就比较两个字符串的长度大小。

int strcmp( const char *string1, const char *string2 );

strcmp函数的参数是两个字符串，返回值为整形

当如果字符串1与字符串2相等则返回值为0。
如果字符串不一样，并且字符串1>字符串2,则返回值>0。

反之返回值小于零。

strcmp函数比较的是两个字符串不相等的第一个字符的ASCII值。

如果有一方是\0，则非零的字符串较大。

模拟实现strcmp函数

我给出以下两种方法：

#define _CRT_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
#include<assert.h>
int my_strcmp(char* a, char* b)
{
	assert(a && b);
	while (*a == *b)
	{
		if (*a == '\0')
		{
			return 0;
		}
		a++;
		b++;
	}
	return *a - *b;
}
int main()
{
	char a[10]="abcdef";
	char b[10]="abc";
	if (my_strcmp(a,b) > 0)
	{
		printf("a>b");
	}
	if (my_strcmp(a, b) == 0)
	{
		printf("a==b");
	}
	if(my_strcmp(a,b)==0)
	{
		printf("a<b");
	}
	return 0;
}

int my_strcmp (const char * src, const char * dst)
{
        int ret = 0 ;
 assert(src != NULL);
   assert(dest != NULL);
        while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
                ++src, ++dst;
        if ( ret < 0 )
                ret = -1 ;
        else if ( ret > 0 )
                ret = 1 ;
        return( ret );
}

长度受限制的字符串函数

strncpy

char *strncpy( char *strDest, const char *strSource, size_t count );

复制字符串src中的内容到字符串dest中，复制多少由size_t参数的值决定。
如果src的前n个字符不含NULL字符，则结果不会以NULL字符结束。
如果n<src的长度，只是将src的前n个字符复制到dest的前n个字符，不自动添加'\0'，结果dest不包括'\0'，需要我们再手动添加一个'\0'。
如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符长度+'\0'。

简单例子

#define _CRT_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
int main()
{
	char a[10]="******";
	char b[10]="chenda";
	strncpy(a, b, 2);
	printf("%s", a);
	return 0;
}

strncat

char *strncat( char *strDest, const char *strSource, size_t count );

#define _CRT_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
int main()
{
	char a[15]="hello \0 ******";
	char b[15]="world";
	strncat(a, b, 6);
	printf("%s", a);
	return 0;
}

如图所示：

调试过程如图所示。

我们可以看到，strncat会自动添加\0,且到\0为止，不会再去将其它字符化为\0。

strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完为止。

返回值判断方法和strcmp基本相等。

简单例子

#include <string.h>
#include <stdio.h>
int main()
{
	char a[20]="hello world";
	char b[15]="hello";

	if (strncmp(a, b, 4) == 0)
	{
		printf("相等");
	}
	else
		printf("不相等");
	return 0;
}