文章目录

每篇前言
一、一维数组
二、字符数组
三、二维数组
四、模拟实现字符串库函数
五、模拟实现内存函数
- 1.memcpy()
- 2.memmove()
六、遇见安然遇见你，不负代码不负卿。

每篇前言

首先回顾一个知识点：

有两个例外：

sizeof(数组名)：单单一个数组名放到sizeof里面，此时的数组名表示的不再是首元素的地址，而是整个数组，计算的是整个数组的大小，单位是字节（注意这个单单！）；
&数组名：取出的是整个数组的地址。

好，介绍完这个知识点，那么请看下面一系列笔试题：

一、一维数组

//一维数组
#include<stdio.h>

int main()
{
	int a[] = { 1,2,3,4 };

	printf("%d\n", sizeof(a));//16
	//单单一个数组名a放到sizeof里面，此时的数组名表示的是整个数组，计算的是整个数组的大小（注意这个单单！）

	printf("%d\n", sizeof(a + 0));//4/8 - 在32位平台占4个字节，64位平台占8个字节
	//此时不止数组名a一个放在sizeof里，所以a表示的是首元素的地址，类型是int*，a+0跳过0个整型，表示的还是首元素的地址
	//地址就是指针，指针在32位平台占4个字节，在64位平台占8个字节

	printf("%d\n", sizeof(*a));//4
	//此时a表示的是首元素的地址，对其进行解引用操作，拿到的是首元素，所以这里计算的是首元素的大小

	printf("%d\n", sizeof(a + 1));//4/8
	//此时a表示的是首元素的地址，类型是int*，a+1跳过一个整型，所以a+1表示的是第二个元素的地址，也就是2的地址

	printf("%d\n", sizeof(a[1]));//4
	//计算的是第二个元素的大小

	printf("%d\n", sizeof(&a));//4/8
	//&a取出的是整个数组的地址，类型是int(*)[4]，属于数组指针，数组指针依然是指针

	printf("%d\n", sizeof(*&a));//16
	//理解1：可认为*和&操作抵消了，此时只剩下sizeof(a),a表示的是整个数组，计算的是整个数组的大小；
	//理解2：&a，取出整个数组的地址，类型是int(*)[4]数组指针类型，然后对其解引用，此时访问到的是整个数组，大小是16字节

	printf("%d\n", sizeof(&a + 1));//4/8
	//&a取出的是整个数组的地址，类型是int(*)[4]数组指针，&a+1跳过了整个数组的地址，是地址就是4/8个字节

	printf("%d\n", sizeof(&a[0]));//4/8
	//&a[0]，取出的是首元素的地址

	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]+1，跳过1个整型，所以&a[0]+1访问的是第二个元素的地址

	return 0;
}

二、字符数组

1.题型一

注意这样的一个概念：

sizeof只关注占用空间的大小；
sizeof不关注类型；
sizeof是操作符

strlen()关注的是字符串中’\0’之前字符的个数；
strlen()只针对于字符串；
strlen()是库函数

好，请看下面的代码：

代码1：

#include<stdio.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };

	printf("%d\n", sizeof(arr));//6
	//计算的是整个数组的大小

	printf("%d\n", sizeof(arr + 0));//4/8
	//计算的是首元素的地址

	printf("%d\n", sizeof(*arr));//1
	//计算的是首元素的大小

	printf("%d\n", sizeof(arr[1]));//1
	//计算的是第二个字符的大小

	printf("%d\n", sizeof(&arr));//4/8
	//&arr，取出的是整个数组的地址，地址就是指针

	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr+1,跳过了整个数组，不过依然是地址

	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0]表示首字符的地址，类型是char*,所以&arr[0]+1跳过一个字符，指向第二个字符的地址

	return 0;
}

代码2：

#include<stdio.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };

	printf("%d\n", strlen(arr));//随机值
	//strlen()遇到'\0'结束，统计的是'\0'之前字符的个数，但是arr中没有'\0'，所以不知道在具体哪里结束，故而这里是随机值

	printf("%d\n", strlen(arr + 0));//随机值
	//同上

	printf("%d\n", strlen(*arr));//内存访问冲突
	//strlen()里面的参数是指针类型（可认为里面存放的是地址），*arr表示的是首元素，也就是'a'，'a'的ACSII值是97，
	//所以strlen(*arr)将'97'当作内存地址去访问了，这里就会导致内存访问冲突

	printf("%d\n", strlen(arr[1]));//内存访问冲突
	//同上，arr[1]表示的是'b',ACSII值是98，strlen(arr[1])表示将'98'当作内存地址去访问了

	printf("%d\n", strlen(&arr));//随机值
	//&arr，取出的是整个数组的地址，由于数组中没有'\0'，所以不知道会具体在哪里结束

	printf("%d\n", strlen(&arr + 1));//随机值

	printf("%d\n", strlen(&arr[0] + 1));//随机值

	return 0;
}

2.题型二

代码1：

#include<stdio.h>

int main()
{
	char arr[] = "abcdef";

	printf("%d\n", sizeof(arr));//7
	//注意哦，sizeof(arr)计算的是arr数组所占内存空间的大小，包括'\0'在内

	printf("%d\n", sizeof(arr + 0));//4/8
	//比较简单，我就不过多赘述咯
	printf("%d\n", sizeof(*arr));//1

	printf("%d\n", sizeof(arr[1]));//1

	printf("%d\n", sizeof(&arr));//4/8

	printf("%d\n", sizeof(&arr + 1));//4/8

	printf("%d\n", sizeof(&arr[0] + 1));//4/8

	return 0;
}

代码2：

#include<stdio.h>

int main()
{
	char arr[] = "abcdef";

	printf("%d\n", strlen(arr));//6

	printf("%d\n", strlen(arr + 0));//6

	printf("%d\n", strlen(*arr));//内存访问冲突

	printf("%d\n", strlen(arr[1]));//内存访问冲突

	printf("%d\n", strlen(&arr));//6(这里要格外注意一下)

	printf("%d\n", strlen(&arr + 1));//随机值

	printf("%d\n", strlen(&arr[0] + 1));//5

	return 0;
}

3.题型三

代码1：

#include<stdio.h>

int main()
{
	char* p = "abcdef";

	printf("%d\n", sizeof(p));//4/8

	printf("%d\n", sizeof(p + 1));//4/8

	printf("%d\n", sizeof(*p));//1

	printf("%d\n", sizeof(p[0]));//1

	printf("%d\n", sizeof(&p));//4/8

	printf("%d\n", sizeof(&p + 1));//4/8

	printf("%d\n", sizeof(&p[0] + 1));//4/8

	return 0;
}

代码2：

#include<stdio.h>

int main()
{
	char* p = "abcdef";

	printf("%d\n", strlen(p));//6

	printf("%d\n", strlen(p + 1));//5

	printf("%d\n", strlen(*p));//内存访问冲突

	printf("%d\n", strlen(p[0]));//内存访问冲突

	printf("%d\n", strlen(&p));//随机值（注意哦，这里是特别容易出错的地方，特别容易错写成6）
	//这里要说的是，p指的是常量字符串，和字符数组是不一样的，p有自己的一块空间

	printf("%d\n", strlen(&p + 1));//随机值

	printf("%d\n", strlen(&p[0] + 1));//5

	return 0;
}

补充常量字符串

在指针类型中我们知道有一种指针类型是char*，它有两种使用方法：

一般使用：

 #include<stdio.h>
 
 int main()
 {
      char ch = 'w';
      char* pc = &ch;
      *pc = 'a';
      printf("%c\n", ch);

      return 0;
 }

这种使用方法比较简单，我就不过多阐述了，看看下面这种使用方法：

 #include<stdio.h>
 
 int main()
 {
      char* p = "abcdef";
      printf("%s\n", p);
      return 0;
 }

所以下面代码是有问题的：

#include<stdio.h>
 
 int main()
 {
      char* p = "abcdef";
      *p = 'w';//目的是将'a'改成'w'（bug）

      return 0;
 }

上面的第6行代码是错误的，因为常量字符串不可以修改，所以为避免上述错误，可将第5行代码修改为：

const char* p = "abcdef";

这样的话就会避免上述错误。

面试题：

#include <stdio.h>

int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    char* str3 = "hello bit.";
    char* str4 = "hello bit.";
    if (str1 == str2)
        printf("str1 and str2 are same\n");
    else
        printf("str1 and str2 are not same\n");

    if (str3 == str4)
        printf("str3 and str4 are same\n");
    else
        printf("str3 and str4 are not same\n");

    return 0;
}

在这里插入图片描述
解题思路：

在这里插入图片描述

三、二维数组

#include<stdio.h>

int main()
{
	int arr[3][4] = { 0 };

	printf("%d\n", sizeof(arr));//12*4=48
	//sizeof(数组名)，计算的是整个数组的大小，单位是字节

	printf("%d\n", sizeof(arr[0][0]));//4
	
	printf("%d\n", sizeof(arr[0]));//4*4=16
	//arr[0]相当于第一行的数组名，由于是单独放在sizeof内部，所以计算的是第一行数组的大小，单位是字节

	printf("%d\n", sizeof(arr[0] + 1));//4/8
	//arr[0]相当于第一行的数组名，由于不是单独放在sizeof内部，所以此时的arr[0]表示的是第一行首元素的地址

	printf("%d\n", sizeof(*(arr[0] + 1)));//4
	//前面提到arr[0]表示的是第一行首元素的地址，所以*(arr[0] + 1)表示的是arr[0][1]这个元素本身

	printf("%d\n", sizeof(arr + 1));//4/8
	//arr数组名表示的是首元素的地址，也就是第一行数组的地址，所以arr+1表示的是第二行数组的地址

	printf("%d\n", sizeof(*(arr + 1)));//4*4=16
	//前面提到arr+1表示的是第二行数组的地址，对其进行解引用操作，访问到的是第二行数组，单独放到sizeof内部，计算的是第二行数组的大小

	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0]表示取出第一行数组的地址，那么&arr+1表示取出第二行数组的地址，地址就是指针

	printf("%d\n", sizeof(*(&arr[0] + 1)));//4*4=16
	//前面提到，&arr[0]+1表示的是第二行数组的地址，所以对其解引用表示的是第二行数组，单独放到sizeof内部，计算的是第二行数组的大小

	printf("%d\n", sizeof(*arr));//4*4=16
	//arr表示的是首元素的地址，也就是第一行数组的地址，对其进行解引用表示的是第一行数组，单独放到sizeof内部，计算的是第一行数组的大小

	printf("%d\n", sizeof(arr[3]));//4*4=16
	//这里我们可能会觉得arr[3]越界了，但是对于本题不影响，sizeof内部会推导出arr[3]类型是int[4]

	return 0;

}

四、模拟实现字符串库函数

1.strlen()

函数原型：

函数功能：

注意：返回值类型是 size_t，这 size_t 到底是什么？

解读下面代码，请问输出结果是什么：

#include<stdio.h>
#include<string.h>
 
int main()
{
	if (strlen("abc") - strlen("abcdef") > 0)
		printf(">");
	else
		printf("<=");
	return 0;
}

没错，答案是输出 “>”，为什么呢？3 - 6 = -3鸭，这是怎么回事？

这是因为strlen的返回值是 size_t ，属于无符号数，所以两个无符号数相减，答案一定是无符号数。

那怎么修改呢？

方案一：强制类型转换

#include<stdio.h>
#include<string.h>
 
int main()
{
	if ((int)strlen("abc") - (int)strlen("abcdef") > 0 )
		printf(">");
	else
		printf("<=");
	return 0;
}

方案二：直接比较

#include<stdio.h>
#include<string.h>
 
int main()
{
	if (strlen("abc") > strlen("abcdef"))
		printf(">");
	else
		printf("<=");
	return 0;
}

注意：

代码示例：

#include<stdio.h>
#include<string>
 
int main()
{
    int len = strlen("abcdef");
	printf("%d\n", len);
 
	return 0;
}

自定义函数模拟实现strlen():

方法：

方法一：计数器的方法

int my_strlen(const char* str)
{
	assert(str);//断言str非空
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

方法二：递归的方法

int my_strlen(const char* str)
{
	assert(str);//断言str非空
	//找边界
	if (*str == '\0')
	{
		return 0;
	}
	int count = my_strlen(str + 1);
	//注意str++和str+1是不同的概念
	count++;
	return count;
}

方法三：指针 - 指针

int my_strlen(const char* str)
{
	assert(str);
	const char* cur = str;
	while (*cur != '\0')
	{
		cur++;
	}
	return cur - str;
}

2.strcpy()

函数原型：

函数功能：

解读下列代码：

#include<stdio.h>
#include<string.h>
 
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	printf("%s\n", strcpy(arr2, arr1));
 
	return 0;
}

本题是将字符串 arr2 拷贝给字符串 arr1 ，返回的是 arrr2 首元素的地址（目标字符串首元素的地址）。所以上面代码输出的是：abcdef，那么这里的问题是，会不会将字符串arr1中的 ‘\0’ 拷贝给字符串 arr2 ，所以这里用以下代码验证这个问题：

#include<stdio.h>
#include<string.h>
 
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "XXXXXXXXXX";
	printf("%s\n", strcpy(arr2, arr1));
 
	return 0;
}

首先，还没有将字符串 arr1 拷贝给 arr2 时，它们存放的数据是这样的：

当执行 strcpy(arr2, arr1) 完后，此时 arr2 中存放的数据是这样的：

这里又有一个问题是：如果源字符串末尾没有加上 ‘\0’ （这里用字符数组的形式演示，正常的字符串末尾会自动填充 ‘\0’），请看如下代码：

#include<stdio.h>
#include<string.h>
 
int main()
{
	char arr1[] = { 'a','b','c','d','e','f' };
	char arr2[20] = "XXXXXXXXXX";
	
	printf("%s\n", strcpy(arr2, arr1));
	return 0;
}

代码执行结果：

所以，使用 strcpy 拷贝字符串是需要注意以下几点：

请看下面的代码：

#include<stdio.h>
#include<string.h>
 
int main()
{
	char arr1[] = "abcdef";
	const char* p = "XXXXXXXXXX";
	printf("%s\n", strcpy(p, arr1));
	return 0;
}

自定义函数模拟实现strcpy()

代码执行：

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)//很妙
	{
		;
	}
	return ret;
}

3.strcat()

函数原型：

函数功能：

解读下列代码：

#include<stdio.h>
#include<string.h>
 
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
 
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

以上代码是将 “world” 拼接到 “hello” 的后面，所以打印结果如下：

其实，使用 strcat 库函数的注意事项与 strcpy 是十分相似的，在这里的话我就不重复解释了：

那么试想：如果让我们自己实现 strcat 函数，该怎么做呢？先想一下大致思路，我们首先要找到目标字符串的结束标志’\0’，然后将源字符串拼接到目标字符串的后面，最后返回目标字符串的首字符的地址，看起来好像挺简单的，那我们实现一下：

自定义函数模拟实现strcat()

代码执行：

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	//1、找到目标字符串的\0
	while (*dest)//注意循环条件写成*dest++是错误的，因为会跳过\0，请细品
	{
		dest++;
	}
	//2、拷贝源字符串
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

4.strcmp()

函数原型：

函数功能：

标准规定：

敲黑板：

自定义函数模拟实现strcmp()

代码执行：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)//注意是在循环体中判断相等的情况，想想为什么
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)//return *str1 - *str2;
		return 1;
	else
		return -1;
}

五、模拟实现内存函数

1.memcpy()

函数原型：

看下面一段代码：

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

自定义函数模拟实现memcpy()

代码执行：

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;//注意返回类型是void*,而不是void，
	assert(dest && src);
	while (num--)//先使用，后--
	{
		*(char*)dest = *(char*)src;//想想为什么强制类型转换成char*，因为只有它最合适
		dest = (char*)dest + 1;//注意直接进行dest++,src++是错误的，因为它是空类型
		src = (char*)src + 1;
	}
	return ret;
}

2.memmove()

函数原型：

那么何为重叠的内存拷贝呢，请看下面一段代码：

#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(arr1[0]));//处理同一块空间时会发生重叠内存拷贝
 
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	 }
	return 0;
}

自定义函数模拟实现memmove

代码执行：

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//从后向前拷贝
	{
		//src = (char*)src + num - 1;//注意一定要-1
		//dest = (char*)dest + num - 1;
		//while (num--)
		//{
		//	*(char*)dest = *(char*)src;
		//	dest = (char*)dest - 1;
		//	src = (char*)src - 1;
		//}
		while (num--)//先使用，后--，在循环体中是--后的num（真的妙）
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

六、遇见安然遇见你，不负代码不负卿。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存失败,源站可能有防盗链机制,建议将图片保存下来直接上传上传(imgkQ7Z4d8cz-1646509564179)(file:///D:\搬移\Tencent Files\1684788544\Image\C2C\E53F079D783B81C7AE88AAE8D7DD959442)(file:///D:\搬移\Tencent Files\19C38.788544\Image\C2C\E53F079D783B8pCnAE88AAE8D7DDg9C3.png)]$