自学内容网 自学内容网
自学内容网 > 正文

你不知道的C语言知识（第六期：字符/字符串/内存库函数）

🕗 发布于 2024-10-10 14:46 c语言  数据库  开发语言  

在这里插入图片描述

本期介绍🍖
主要介绍：C语言中一些大家熟知知识点中的盲区，这是第六期，主讲字符、字符串、内存库函数。

文章目录

1. 字符函数

1.1 字符分类函数

  在C语言中有一系列库函数专门做字符分类的，也就是一个字符是属于什么类型的字符。这些函数的使用都需要包含一个头文件<ctype.h>。如下所示：

在这里插入图片描述

  举个例子，写一个代码将字符串中的小写字母转换成大写字母，其他字符不变。代码实现如下：

#include<stdio.h>
#include<ctype.h>
int main()
{
char str[] = "Hello This World.";
int i = 0;
while (str[i] != '\0')
{
if (isupper(str[i]) == 1)
{
str[i] += 32;
}
i++;
}
printf("%s\n", str);
return 0;
}

在这里插入图片描述

1.2 字符转换函数

  在C语言中提供了2个字符转换函数tolower()和toupper()，这两个函数的使用都需要包含一个头文件<ctype.h>。

  1. int tolower (int c);（将大写字母传进去返回小写字母）
  2. int toupper(int c);（将小写字母传进去返回大写字母）

  还是上面那个例子，写一个代码将字符串中的小写字母转换成大写字母，其他字符不变。代码实现如下：

#include<stdio.h>
#include<ctype.h>
int main()
{
char str[] = "Hello This World.";
int i = 0;
while (str[i] != '\0')
{
if (isupper(str[i]) == 1)
{
str[i] = tolower(str[i]);
}
i++;
}
printf("%s\n", str);
return 0;
}

在这里插入图片描述

2. 字符串函数

  在C语言中，提供了许多处理字符串的库函数，使用这些库函数的时候需要包含一个头文件<string.h>。

2.1 strlen函数

  strlen()函数用于求字符串的长度，将字符串的起始地址作为参数传给strlen()函数。返回值类型为size_t，返回值为该字符串的长度。

    size_t strlen(const char* str);

  模拟实现strlen()函数，首先该函数实现的功能是求字符串的长度，只需要统计字符串中字符串结束标志'\0'前的字符个数。有3中实现方式：计数法、指针减指针法、递归法。如下所示：

  1. 计数法

  实现思路：首先创建一个计数的临时变量count，然后遍历字符串所有中字符，每遍历一个字符count就加一，直到遇见字符'\0'才停下来。实现代码如下：

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
assert(str != NULL);
size_t count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char str[] = "abcdef";
size_t len = my_strlen(str);
printf("字符串长度：%zd", len);
return 0;
}

在这里插入图片描述

  1. 指针减指针法

  实现思路：指针减指针的绝对值，计算的是指针与指针之间元素的个数。只需记住字符串起始位置的地址，然后求得字符串结尾的地址，两者相减就能得到字符串的长度。实现代码如下：

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
assert(str != NULL);
char* head = str;
while (*str != '\0')
str++;
return str - head;
}
int main()
{
char str[] = "abcdef";
size_t len = my_strlen(str);
printf("字符串长度：%zd", len);
return 0;
}

在这里插入图片描述

  1. 递归法

  使用递归思路将一个较大的且复杂的问题，层层转化为一个相同的但规模较小的问题，计算字符长度"abcdef" = 1 + "bcdef"。实现代码如下：

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
assert(str != NULL);
if (*str == '\0')
return 0;
return 1 + my_strlen(str + 1);
}
int main()
{
char str[] = "abcdef";
size_t len = my_strlen(str);
printf("字符串长度：%zd", len);
return 0;
}

在这里插入图片描述

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

2.2.1 strcpy函数

  strcpy()函数用于字符串的拷贝，将字符串从源头src拷贝到目的地dest中（包含字符串结束标志\0），dest中原本的数据会被覆盖掉。值得注意，dest指向的空间的长度必须大于src指向字符串的长度，为了防止越界访问。拷贝结束后函数将dest作为返回值返回。

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

  使用strcpy()函数拷贝str1到str2字符串中，通过调试发现strcpy()会将字符串末尾的'\0'也一并拷贝，代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
char str1[] = "hello world";
char str2[20] = "xxxxxxxxxxxxxxxx";
strcpy(str2, str1);
printf("%s\n", str2);
return 0;
}

在这里插入图片描述
  模拟实现strcpy()函数，实现思路：遍历整个src数组，每遍历一个元素都将其从src赋值到dest中，直至遇见文件结尾\0。实现代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
assert(dest != NULL && src != NULL);
char* tmp = dest;
while (*dest++ = *src++)
{
;
}
return tmp;
}
int main()
{
char str1[] = "hello world";
char str2[20] = "xxxxxxxxxxxxxxxx";
my_strcpy(str2, str1);
printf("%s\n", str2);
return 0;
}

在这里插入图片描述

2.2.2 strcat函数

  strcat()函数用于字符串的追加，将源头字符串src追加到目标字符串dest后（dest中的结束字符\0会被src的第一个字符覆盖，追加结束后会在dest末尾添上结束标志\0）。值得注意，dest指向的空间的长度必须大于dest和src空间之和，为了防止越界访问。拷贝结束后函数将dest作为返回值返回。

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

  使用strcat()函数将str2字符串追加到str1字符串的后面，通过调试可以发现，strcat()会从str1字符串第一个遇到的\0开始往后追加。代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "abc\0xxxxxxxxxxx";
char str2[] = "defg";
strcat(str1, str2);
printf("%s\n", str2);
return 0;
}

在这里插入图片描述
  模拟实现strcat()函数，实现思路：首先在str1字符串中找到第一个结束标志\0，然后再将str2字符串中的数据拷贝进去。实现代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest != NULL && src != NULL);
char* tmp = dest;
//1.找dest中的结束标志
while (*dest != '\0')
dest++;
//2.开始追加，将src全部拷贝到dest中
while (*dest++ = *src++)
{
;
}
return tmp;
}
int main()
{
char str1[20] = "abc\0xxxxxxxxxxx";
char str2[] = "defg";
my_strcat(str1, str2);
printf("%s\n", str1);
return 0;
}

在这里插入图片描述

2.2.3 strcmp函数

  strcmp()函数用于字符串的比较，判断两个字符串的大小。从字符串的第一个字符开始，相对位置依次进行比较，直到比较的两个字符不同或遇见结束标志才停下。返回值当str1 > str2返回值大于0，str1 < str2返回值小于0，str1 = str2返回0。

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

  模拟实现strcmp()，实现思路：使两个字符串相对位置上的字符进行比较，若相等就往后查找下一对，直到遇见不相等的两个字符或者是遇见字符结尾才停下。

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 != NULL && str2 != NULL);
while (*str1 != '\0' && *str2 != '\0' && *str1 == *str2)
{
str1++;
str2++;
}
return *str1 - *str2;
}
int main()
{
char str1[] = "abcdef";
char str2[] = "abc";
int res = my_strcmp(str1, str2);
if (res > 0)
printf("%s > %s\n", str1, str2);
else if(res < 0)
printf("%s < %s\n", str1, str2);
else
printf("%s = %s\n", str1, str2);
return 0;
}

在这里插入图片描述

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

2.3.1 strncpy函数

  strncpy()是长度受限制的字符串拷贝函数，与strcpy()相比多出了一个参数num，限制了一次能够拷贝的数量。该函数的返回值为dest。

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

  值得注意有两点：

  1. 当num小于src源头字符串长度，拷贝完后是不会追加\0
#include<stdio.h>
#include<string.h>
int main()
{
char str1[] = "abcdef";
char str2[20] = "xxxxxxxxxxxxxxx";
strncpy(str2, str1, 4);
printf("%s\n", str2);
return 0;
}

在这里插入图片描述

  1. 当num大于src源头字符串长度，在拷贝完字符串后，会继续追加\0直到num。
#include<stdio.h>
#include<string.h>
int main()
{
char str1[] = "abcdef";
char str2[20] = "xxxxxxxxxxxxxxx";
strncpy(str2, str1, 10);
printf("%s\n", str2);
return 0;
}

在这里插入图片描述
  模拟实现strncpy()，实现思路：首先将src字符串中的num个字符拷贝到dest中，如果中途遇见src的字符串结束标志\0，那么结束拷贝开始向后追加\0到dest中，直至达到num个。代码实现如下：

#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* dest, const char* src, size_t num)
{
assert(dest != NULL && src != NULL);
char* tmp = dest;
while (num > 0 && *src != '\0')
{
*dest++ = *src++;
num--;
}
while (num > 0)
{
*dest++ = '\0';
num--;
}
return tmp;
}
int main()
{
char str1[] = "abcdef";
char str2[20] = "xxxxxxxxxxxxxxx";
my_strncpy(str2, str1, 4);
return 0;
}

在这里插入图片描述

2.3.2 strncat函数

  strncat()是长度受限制的字符串追加函数，与strcat()函数相比多出了一个参数num，限制了一次能够追加的数量。该函数的返回值为dest。

    char* strncat(char* dest, const char* src, size_t num)

  值得注意两点：

  1. 当num小于src字符串的长度，在追加完num个字符后，会再追加一个\0
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "abc\0xxxxxxxxxxx";
char str2[] = "defgh";
strncat(str1, str2, 3);
printf("%s\n", str1);
return 0;
}

在这里插入图片描述

  1. 当num大于src字符串的长度，只会将src字符串中到\0的所有内容追加到dest中，不会过多追加‘\0’
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "abc\0xxxxxxxxxxx";
char str2[] = "defgh";
strncat(str1, str2, 10);
printf("%s\n", str1);
return 0;
}

在这里插入图片描述
  模拟实现strncat()，实现思路：首先找到dest字符串的结束标志\0，其次开始向后追加src字符串的内容到dest中，直至拷贝到num个或src先遇见\0才停下，最后在dest后追加一个\0即可。

#include<stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, size_t num)
{
assert(dest != NULL && src != NULL);
char* tmp = dest;
//1.找到dest的结束标志
while (*dest != '\0')
dest++;
//2.追加字符串
while (num > 0 && *src != '\0')
{
*dest++ = *src++;
num--;
}
*dest = '\0';
return tmp;
}
int main()
{
char str1[20] = "abc\0xxxxxxxxxxx";
char str2[] = "defgh";
my_strncat(str1, str2, 3);
printf("%s\n", str1);
return 0;
}

在这里插入图片描述

2.3.3 strncmp函数

  strncmp()是长度受限制的字符串比较函数，与strcmp()函数相比多出了一个参数num，限制了比较的数量。该函数的返回值一个整数，若str1 > str2返回值大于0，若str1 < str2返回值小于0，若str1 = str2返回值0。

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

  模拟实现strncmp()，代码实现如下：

#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, size_t num)
{
assert(str1 != NULL && str2 != NULL);
while ((--num > 0) && (*str1 != '\0') && (*str2 != '\0') && (*str1 == *str2))
{
str1++;
str2++;
}
return *str1 - *str2;
}
int main()
{
char str1[] = "abcdef";
char str2[] = "abcfgk";
int ret = my_strncmp(str1, str2, 3);
if (ret > 0)
printf("%s > %s\n", str1, str2);
else if (ret < 0)
printf("%s < %s\n", str1, str2);
else
printf("%s = %s\n", str1, str2);
 return 0;
}

在这里插入图片描述

2.4 strstr函数

  strstr()是查找字符串函数，在一个字符串str1中查找是否存在另一个字符串str2，如果存在则返回str2在str1中的起始地址，否则返回NULL。

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

  使用strstr()函数，在字符串"abcdef"中查找字符串"bcd"，并打印返回地址处的字符串，代码如下。

#include<stdio.h>
#include<string.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "bcd";
char* p = strstr(str1, str2);
if (p != NULL)
printf("%s\n", p);
else
printf("没有找到字符串\n");
return 0;
}

在这里插入图片描述

  模拟实现strstr()函数，实现思路：想要在一个字符串中找另一个字符串，需要每一个位置向后遍历。意思就是，如果从某位置起没有匹配到字符串，那么就应从该位置的下个位置开始继续查找字符串，才能避免漏查导致没有找到。举个例子：在字符串"abbbcdef"中查找字符串"bbcd"，如果只想遍历一遍就找到字符串的话，那么必然会错过。值得注意，当需要查找的是空字符串(即"")，函数返回被查找字符串的起始地址。实现代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 != NULL && str2 != NULL);
const char* p1 = NULL;
const char* p2 = NULL;
const char* current = str1;
while (current != '\0')
{
p1 = current;
p2 = str2;
while (*p1 != '\0' && *p2 != '\0' && *p1 == *p2)
{
p1++;
p2++;
}
if (*p2 == '\0')
return (char*)current;
if (*p1 == '\0')
return NULL;
current++;
}
return NULL;
}
int main()
{
char str1[] = "abbbcdef";
char str2[] = "bbcd";
char* ret = my_strstr(str1, str2);
if (ret != NULL)
printf("%s\n", ret);
else
printf("没有找到字符串\n");
return 0;
}

在这里插入图片描述

  在模拟实现strstr()函数时，有两个指针需要注意current和p1，当current指向'\0'时就代表没有找到字符串，当p1指向'\0'时代表找到了字符串。

2.5 strtok函数

  strtok()函数作用是：提取字符串中用分隔符分隔开的字符串。第一个参数str指向需要被切割字符串，第二个参数sep指向分隔符的字符集合。函数声明如下：

    char* strtok(char* str, const char* sep);
  1. 若参数str ！= NULL时，函数将找到str中第一个分隔符将其改为'\0'，并记住这个位置，最后返回被分隔字符串的起始地址。
  2. 若参数str == NULL时，函数将从上一次保存的位置开始向后找下一个分隔符，然后将其改为'\0'，记住该位置，返回被分隔字符串的起始地址。(字符串结束标志也可以认为是一个分隔符)
  3. 如果被切割的字符串中不存在更多分隔符，函数返回NULL指针。

  下面使用strtok()函数分隔字符串"FeiLieChen@qq.com"，并打印每次分隔后返回的字符串。


#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "FeiLieChen@qq.com";
char str[] = "@.";
char* ret = NULL;
ret = strtok(arr, str);
printf("%s\n", ret);

ret = strtok(NULL, str);
printf("%s\n", ret);

ret = strtok(NULL, str);
printf("%s\n", ret);

ret = strtok(NULL, str);
printf("%s\n", ret);
return 0;
}

在这里插入图片描述

  strtok()函数的正确使用方法，可以根据函数的返回值判断是否还有多余的分隔符。代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "FeiLieChen@qq.com";
char str[] = "@.";
char* ret = NULL;
for (ret = strtok(arr, str); ret != NULL; ret = strtok(NULL, str))
{
printf("%s\n", ret);
}
return 0;
}

在这里插入图片描述

  模拟实现strtok()函数，实现思路：首先，根据函数的记忆特性，需要创建一个strtic的静态变量，用于在下次调用函数时记得上次保存的地址。其次，需要创建一个变量用于记忆每次开始的起始地址，用于返回分隔后的字符串。具体代码实现如下所示：

#include<stdio.h>
#include<assert.h>
char* my_strtok(char* str, const char* sep)
{
assert(sep != NULL);
static const char* store = NULL;
const char* current = NULL;
char* p1 = NULL;
const char* p2 = NULL;
static int flag = 0;//用于记录字符串中不存在更多分隔符时的情况
//1.判断是否存在更多的分隔符
if (flag == 1)
return NULL;
//2.判断str是否为NULL
if (str != NULL)
current = str;
else
current = store + 1;
//3.初始化
p1 = current;
p2 = sep;
//4.开始分隔字符串
while (*p1 != '\0')
{
while (*p2 != '\0')
{
if (*p1 == *p2)
break;
p2++;
}
if (*p1 == *p2)
{
*p1 = '\0';
store = p1;
return (char*)current;
}
p1++;
p2 = sep;
}
flag = 1;
return (char*)current;
}
int main()
{
char arr[] = "FeiLieChen@qq.com";
char str[] = "@.";
char* ret = NULL;
for (ret = my_strtok(arr, str); ret != NULL; ret = my_strtok(NULL, str))
{
printf("%s\n", ret);
}
return 0;
}

在这里插入图片描述

2.6 strerror函数

  strerror()函数可以把错误码对应的错误信息返回，函数类型声明如下：

    char* strerror(int errnum);

  在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在<errno.h>的这个头文件中说明。C语言程序启动的时候会创建一个全局变量errno来记录程序当前的错误码，就譬如：当调用库函数的时候发生了错误，库函数自身会主动把错误码存入errno中。错误码仅仅只是一个数字，每个错误码都有对应的错误信息，只有翻译成错误信息后才更方便解读。所以就要使用strerror()函数将错误码翻译成对应的错误信息。
  使用strerror()函数打印1~10错误码对应的错误信息，如下所示：

#include<stdio.h>
#include<string.h>
int main()
{
int i = 0;
for (i = 0; i <= 10; i++)
{
printf("错误码%d：%s\n", i, strerror(i));
}
return 0;
}

在这里插入图片描述

2.7 perror函数

    void perror ( const char * str );

  perror()函数是有能力直接打印错误信息，打印的时候先打印传给perror()的字符串，再打印冒号和空格，最后打印错误码所对应的错误信息。使用需要引用头文件<stdio.h>。举例如下所示：

#include<stdio.h>
int main()
{
//1.打开文件
FILE* pf = fopen("text.exe", "r");
if (pf == NULL)
{
perror("test");
return 1;
}
//2.读文件
//……

//3.关闭文件
fclose(pf);
return 0;
}

在这里插入图片描述

3. 内存函数

3.1 memcpy函数

  memcpy()是内存拷贝函数，可以把num个字节的内容从src源头空间拷贝到dest目标空间。该函数不检查原空间中是否存在任何终止符号，总是经确的复制num个字节。函数返回目标空间的起始地址，使用该函数需要引用头文件<string.h>。

    void* memcpy(void* dest, const void* src, size_t num);

  下面使用memcpy()函数将一个整型数组的5个元素拷贝到另一个整型数组中去，代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
memcpy(arr2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 20; i++)
printf("%d ", arr2[i]);
return 0;
}

在这里插入图片描述

  模拟实现memcpy()函数，实现思路：该函数是内存拷贝函数，也就是说操作的对象的类型是不确定的，所以参数部分需要使用void*类型。代码实现如下：

#include<stdio.h>
#include<assert.h>
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;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
my_memcpy(arr2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 20; i++)
printf("%d ", arr2[i]);
return 0;
}

在这里插入图片描述

  值得注意，memcpy()函数是无法解决目标空间和源头空间重叠的情况，如果强行处理重叠问题会发生错误。

3.2 memmove函数

  memmove()是内存移动函数，也是对内存空间进行拷贝的函数。与memcpy()区别是：memcpy()只适用内存空间独立不重叠的情况，memmove()是专门用于处理内存空间重叠的情况。函数返回目标空间的起始地址，使用该函数需要引用头文件<string.h>。

    void* memmove(void* dest, const void* src, size_t num);

  下面使用memmove()函数将一个整型数组开始的5个元素拷贝第3个元素后面，代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1+2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
printf("%d ", arr1[i]);
return 0;
}

在这里插入图片描述

  思考几个问题：为什么memcpy()函数处理内存块重叠的情况会发生错误？本质的原因是什么？该怎么解决这个问题？举例如下：

在这里插入图片描述
在这里插入图片描述

  memcpy()函数在进行内存重叠拷贝时，之所以会出错，本质上是因为源空间的内存重叠部分在拷贝的过程中被提前覆盖了，导致了数据的丢失。解决方法如下图所示：
在这里插入图片描述
  思考一个问题：如果此时src > dest还能使用从后向前拷贝的方法来解决吗？答案是否定的，可以发现位置不同，处理解决问题的方式也不同。如下图所示：
在这里插入图片描述
  结论：若src>dest则内存因该从前向后拷贝，若src<dest则内存应该从后向前拷贝。若重叠部分在源内存块的前面，就从前向后拷贝；若重叠部分在源内存块的后面，就从后向前拷贝。
  模拟实现memmove()函数，实现思路如上所述，实现代码如下：

#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
if (src > dest)
{
//从前向后拷贝
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;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1+2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
printf("%d ", arr1[i]);
return 0;
}

在这里插入图片描述

3.3 memset函数

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

  memset()是内存设置函数，可以使得ptr指向空间的前num个字节设置为值得的值value。函数返回ptr指向空间的起始地址，使用函数需要引用头文件<string.h>。下面使用函数将内存中的值以字节为单位设置成想要的内容。

#include<stdio.h>
#include<string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
memset(arr, 0, 10 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

在这里插入图片描述

3.4 memcmp函数

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

  memcmp()是内存比较函数，将ptr1指向的内存块的前num个字节，与ptr2指向的内存块的前num个字节进行比较。与strcmp()字符串比较函数类似，都是相对位置逐个进行比较。如果ptr1 > ptr2返回值大于0，如果ptr1 < ptr2返回值小于0，如果ptr1 = ptr2返回值等于0。
  下面使用memcmp()函数，比较两个整型数组的大小。如下所示：

#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5,4,3,2,1 };
int ret = memcmp(arr1, arr2, 9 * sizeof(int));
if (ret > 0)
printf("arr1 > arr2\n");
else if (ret < 0)
printf("arr1 < arr2\n");
else
printf("arr1 = arr2\n");
return 0;
}

在这里插入图片描述

在这里插入图片描述

这份博客👍如果对你有帮助，给博主一个免费的点赞以示鼓励欢迎各位🔎点赞👍评论收藏⭐️，谢谢！！！
如果有什么疑问或不同的见解，欢迎评论区留言欧👀。


原文地址：https://blog.csdn.net/m0_66769266/article/details/142626936

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024