详解C语言—字符串和内存函数

目录

1、求字符串长度

strlen

 模拟实现：

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

strcpy

 模拟实现： 

strcat

 模拟实现： 

assert ：

strcmp

  模拟实现： 

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

strncpy

strncat

strncmp

4、字符串查找

strstr

strtok

5、错误信息报告

strerror

6、字符分类函数 

7、字符操作—内存操作函数：

memcpy

 模拟实现：

memmove

 模拟实现：

memcmp

memset 

---

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在

常量字符串中或者字符数组中，字符串常量 适用于那些对它不做修改的字符串函数，意思是你可以安全地将字符串常量传递给那些不会尝试修改其参数的函数。

1、求字符串长度

• strlen

 size_t strlen ( const char * str ); 

strlen是一个库函数，用于计算给定字符串的长度。它是在<string.h>头文件中定义的。strlen函数接受一个指向字符数组的指针（一个字符串）作为参数，并返回一个size_t类型的值，表示字符串的长度（不包括终止的null字符）。

字符串结束标志为 ' \0 ' ，strlen函数返回在字符串中 ' \0 ' 前出现的字符个数（不包含 ’ \0 '）。

 例子：

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

int main ()
{
  char szInput[256];
  printf ("Enter a sentence: ");
  gets (szInput);
  printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
  return 0;
}

返回结果： 

 模拟实现：

size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str++) {
		count++;
	}
	return count;
}

int main()
{
	size_t sz = my_strlen("aasaad");
	printf("%d\n", sz);
	return 0;
}

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

• strcpy

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

strcpy 是一个库函数，用于复制一个字符串到另一个字符串。它是在 <string.h> 头文件中定义的。strcpy 函数接受两个参数：一个目标字符数组的指针和一个源字符串的指针。它将源字符串复制到目标字符数组，并返回目标字符数组的指针。

注意！！！ 

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。

 例子：

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

int main() {
    char source[] = "Hello, World!";
    char destination[50];

    strcpy(destination, source);

    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}

 

 模拟实现： 

char* my_strcpy(char* dest, char* src)
{
	char* ret = dest;
	while (*dest++ = *src++);
	return ret;
}

• strcat

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

strcat是一个库函数，用于将一个字符串追加到另一个字符串的末尾，它是在 <string.h>头文件中定义的，strcat接受两个参数，一个目标字符数组的指针和一个源字符串的指针，他将源字符串追加到目标字符串数组的末尾，并返回目标字符数组的字符。

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

int main() {
    char destination[50] = "Hello";
    char source[] = ", World!";

    strcat(destination, source);

    printf("Combined string: %s\n", destination);

    return 0;
}

 

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

 模拟实现： 

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

如果用模拟函数，不能自己追加自己，由于目标字符串数组和源字符串数组相同，即在第一个while循环之后，dest指向字符串最后一位 ' \0 '，而src等于dest也指向字符串最后一位 ' \0 '，所以在第二个while循环中无法进行追加。 

如果用字符串函数strcat是可以自己追加自己的，只要目标空间足够大。 

这里的assert确保了以下两点：

1. dest 不是 NULL。
2. src 不是 NULL。

如果任何一个条件不满足（即，如果 dest 或 src 是 NULL），assert 将触发一个错误消息并终止程序。这是为了防止后续的代码在无效的指针上操作，从而可能导致未定义的行为或程序崩溃。

• assert ：

•  在C编程中，assert 是一个宏，用于在程序中设置断言如果断言失败（即表达式为false），assert会调用一个错误处理例程，并通常终止程序执行。 
•  assert 宏用于确保传递给函数的两个字符串指针 dest 和 src 都不是 NULL。
• assert 宏在 <assert.h>头文件中定义。

• strcmp

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

 strcmp）是一个库函数，用于比较两个字符串。这个函数是在<string.h>头文件中定义的。strcmp函数接受两个字符串（字符指针）作为参数，并返回一个整数来表示这两个字符串的相对顺序。

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2) {
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

int main()
{
	int ret = my_strcmp("bbq", "bbb");	
	if (ret > 0)
		printf("大于\n");
	else if (ret < 0)
		printf("小于\n");
	else
		printf("等于\n");

	return 0;
}

  模拟实现： 

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2) {
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

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

• strncpy

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

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

#include <stdio.h>
#include <string.h>
int main()
{
    char str1[20];
    char str2[20];
    strcpy(str1, "To be ");
    strcpy(str2, "or not to be");
    strncpy(str2, str1, 10);
    puts(str2);
    return 0;
}

 在这个程序中，strncpy 函数用于将 str1 中的内容复制到 str2 中，但最多只复制 10 个字符。

虽然输出结果是  ，但后面超过字符串长度的部分被赋值为\0。

• strncat

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

• 将源字符的 第一个字符 到 第num字符追加到目标空间末尾，再加上一个终止的空字符   ’ \0 ' 。
• 如果源字符中的C字符串的长度小于num，则只复制直到终止的空字符的内容。

• strncmp

• int strncmp ( const char * str1, const char * str2, size_t num );
• strncmp用于比较两个字符串的前 num 个字符。

4、字符串查找

• strstr

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

• strstr 返回一个指向str1中第一次出现的str2的指针
• 如果str2不是str1的一部分，则返回一个空指针。

下面我们来看两个例子： 

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "This is a simple string";
    char* pch;
    pch = strstr(str, "simple");
    printf("%s\n", pch);
    strncpy(pch, "sample", 6);
    puts(str);
    return 0;
}

输出结果： 

 

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "This is a simple string";
    char* pch;
    pch = strstr(str, "smple");
    printf("%s\n", pch);
    return 0;
}

 输出结果： 

 

模拟实现： 

char* my_strstr(char* str1, char* str2)
{
	char* s1 = str1;
	char* cp = str1;
	char* s2 = str2;
	if (*str2 == '\0')
		return str1;
	while (*cp) {
		s1 = cp;
		s2 = str2;
		while (*s1 == *s2 && *s1 && *s2) {
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;
		cp++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	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 指针。

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

int main()
{
	char arr[] = "[email protected]@666#777";
	char copy[30];
	strcpy(copy, arr);

	char sep[] = "@.#";
	char* ret = NULL;

	for (ret = strtok(copy, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}

	return 0;
}

5、错误信息报告

• strerror

char * strerror ( int errnum );  

当库函数在执行的时候发生了错误，会将一个错误码存放在errno这个变量中，errno是C语言提供的一个全局变量。输入错误码，所对应的错误信息。

int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d: %s\n", i, strerror(i));//
	}
	return 0;
}

 

 strerror到底有什么用呢？ 

int main()
{
	//C语言中可以操作文件
	//操作文件的步骤
	//1. 打开文件
	//2. 读/写
	//3. 关闭文件

	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		printf("fopen: %s\n", strerror(errno));
		//通过错误码知道打印失败的原因。
        perror("fopen"); 
		return 1;
	}
	//读文件
	//...
	//关闭文件
	fclose(pf);

	return 0;
}

可以将 printf("fopen: %s\n", strerror(errno)); 换成 perror("fopen"); ，他们输出结果相同。

perror功能更强大，它先打印fopen: 加上错误信息。

结果如下：

6、字符分类函数 

需要包含 #include <ctype.h>头文件。

int main()
{
	printf("%d\n", isupper('a'));
	printf("%d\n", isdigit('2'));
	printf("%c\n", tolower('A'));
	printf("%c\n", tolower('s'));
	return 0;
}

 输出结果：

int main()
{
	char arr[20] = { 0 };
	gets(arr);//遇到空格继续读
	char* p = arr;
	while (*p)
	{
		if (isupper(*p))// *p>='A' && *p<='Z'
		{
			*p = tolower(*p);//*p = *p+32;
		}
		p++;
	}
	printf("%s\n", arr);
	return 0;
}

 输出结果： 

7、字符操作—内存操作函数：

• memcpy

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

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。
• 函数拷贝结束后，返回目标空间的起始地址。
• 我们看下面的例子就明白了

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 40);
	for (int i = 0; i < 20; i++)
		printf("%d ", arr2[i]);
	return 0;
}

 

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };

	float arr3[] = { 1.0,2.0,3.0 };
	float arr4[5] = { 0 };

	memcpy(arr2, arr1, 40);
	memcpy(arr4, arr3, 8);//8个字节：拷贝两个元素

	for (int i = 0; i < 20; i++)
		printf("%d ", arr2[i]);

	printf("\n");

	for (int i = 0; i < 5; i++)
		printf("%f ", arr4[i]);
	return 0;
}

 模拟实现：

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

• 不能拷贝负数个元素，所以定义为无符号整型size_t类型不能拷贝负数个元素，所以定义为无符号整型size_t类型 。
• 不能转换为(int*)类型，因为传入其他类型则无法实现函数功能，比如num如果是7，意味着函数要7个字节，而int*类型加一拷贝四个字节，所以转换成(char*)类型，每次加一拷贝一个字节，拷贝七次从而完美解决上述问题。
• 不能写成(char*)dest++，强制转换是临时的。

注意！！！memcpy不能自己任何位置拷贝自己任何位置。

如果source和destination有任何的重叠，复制的结果都是未定义的。

这时我们可以用memmove函数。

---

• memmove

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

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1, arr1+2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

输出结果：

---

 模拟实现：

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

首先我们要考虑三种情况，他们分别对应不同的拷贝模式，dest位于src前面时，将src对应位置的值从前往后复制给dest对应位置，这样不会造成src的值尚未复制给dest就被改变。同理第二种和第三种也一样。

 

 第三种情况从前向后和从后向前都可以，我们就选择与第二种情况相同方式从后向前，这样判断拷贝方式只有两种情况了。

输出结果：

• memcpy 只要实现了不重叠拷贝就行
• 但vs 上memcpy 函数实现了重叠拷贝
• 重叠的内存拷贝还是交给memmove来做
• memmove 当然也可以拷贝不重叠的拷贝

---

• memcmp

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

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

返回值如下：

int main()
{
	int arr1[] = { 1,2,1,4,5,6 };
	int arr2[] = { 1,2,257 };
	int ret = memcmp(arr1, arr2, 10);
	printf("%d\n", ret);
	return 0;
}

输出结果：

memset 

void * memset ( void * ptr, int value, size_t num )

    把ptr指向的前num个字节设置成我们想要的value值

int main()
{
	char arr[] = "hello bit";
	memset(arr+1,'x',4);
	printf("%s\n", arr);
	return 0;
}

以字节为单位设置的,从arr+1开始的四个字节赋成'x'.

输出结果： 

我们看下面例子的结果就理解memset以字节为单位设置了：

int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 40);

	return 0;
}

好的，字符串函数和内存函数到此就介绍完了，希望这篇文章 可以帮你回忆曾经所学过的知识 。

---