开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 数据结构与算法 -> 【校招面经】学完C语言，这些面试真题你都会了吗？ -> 正文阅读

[数据结构与算法]【校招面经】学完C语言，这些面试真题你都会了吗？

大家好，我是安然无虞。

每篇前言

博客主页：安然无虞

作者介绍：2021年博客新星Top2

咱的口号：🌹小比特，大梦想🌹

作者请求：由于博主水平有限，难免会有错误和不准之处，我也非常渴望知道这些错误，恳请铁汁批评斧正。

火爆专栏：蓝桥杯基础算法剖析

首先回顾一个知识点：

传统上，数组名表示首元素的地址

有两个例外：

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不关注类型；
sizeof是操作符

strlen()：

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;
}

这里再重点强调一下这行代码：
printf("%d\n", strlen(*arr));
strlen()需要的是一个地址，从这个地址开始向后找字符直到’\0’，统计的是’\0’之前字符的个数，但是*arr表示的是首元素，也就是’a’，这时传递给strlen()的就是’a’的ACSII值97，strlen()会把97作为起始地址来统计字符串，这样的话也就会形成内存访问冲突。

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;
 }

注意上面的 abcdef 是常量字符串，存储在内存的只读数据区（只读不可写）

特别容易让我们以为是把字符串 abcdef 放到字符指针 p 里了，其实本质上是把字符串 abcdef 首字符的地址放到 p 中

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

#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;
}

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

str1 和 str2 是两个字符数组，数组的操作方式是将右边的常量字符串拷贝到数组的空间中，所以它们是两块空间，只是内容相同，而作为数组名，str1 和 str2 是数组首元素的地址，所以 str1 != str2
str3 和 str4 是两个字符指针，指向的是同一个常量字符串，而常量字符串存储在单独的一个内存区域（只读数据区），当几个指针指向同一个常量字符串的时候，它们实际上会指向同一块内存

在这里插入图片描述

三、二维数组

#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 到底是什么？

其实 size_t 是为 sizeof 操作符返回值设计的，可以浅显的认为 size_t 就是我们熟知的 unsigned int ，因为是求长度，所以肯定不会是负数，故而使用无符号整型，但是由此也容易产生 bug，请看下面代码：

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

#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;
}

注意：

字符串以 ‘\0’ 作为结束标志，strlen 返回的是在字符串中 ‘\0’ 之前的字符个数（不包括’\0’）;
参数中指向的字符串必须以 ‘\0’ 结束；
注意strlen函数的返回值是 size_t 类型，属于无符号类型（特易错）

代码示例：

#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;
}

这里需要注意的是，str++ 和 str+1 不是一个概念，str++是先使用后++，本题可以写成++str的形式，先++再使用。

方法三：指针 - 指针

指针-指针其实表示的是两个指针中间的元素个数，注意哦，不是中间有几个字节。

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 中存放的数据是这样的：

可以看到，将字符串 arr1（源字符串）拷贝给字符串 arr2（目标字符串）时会自动将源字符串末尾的 ‘\0’ 拷贝过去，返回的是目标字符串起始位置的地址。

这里又有一个问题是：如果源字符串末尾没有加上 ‘\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;
}

代码执行结果：

所以需要注意的是：如果想将源字符串拷贝给目标字符串，那么就要保证源字符串中是包含 ‘\0’ 的，否则会拷贝失败。

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

源字符串必须以 ‘\0’ 结束；
拷贝时会将源字符串中的 ‘\0’ 一同拷贝给目标字符串；
目标字符串（目标空间）必须足够大，以确保能存放源字符串；
还有一点就是，目标字符串必须是可以改变的

请看下面的代码：

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

执行程序是错误的，因为此时的目标字符串是被 const 修饰的，是不可以修改的。

自定义函数模拟实现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 是十分相似的，在这里的话我就不重复解释了：

源字符串必须以 ‘\0’ 结束；
目标空间必须足够大，能容纳下源字符串的内容;
目标空间必须可变。

那么试想：如果让我们自己实现 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()

函数原型：

函数功能：

比较对应位置上字符的字典序

标准规定：

第一个字符串 > 第二个字符串，则返回大于0的数字；
第一个字符串 == 第二个字符串，则返回0；
第一个字符串 < 第二个字符串，则返回小于0的数字。

敲黑板：

两个字符串不能直接进行比较，也不能直接进行相加相减运算，因为字符串表示的是首字符的地址。也就是说，如果直接进行比较的话，比的不是字符串的内容，而是地址，所以是错误的。

自定义函数模拟实现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()

函数原型：

注意哦，内存操作函数中的第三个参数单位是字节。

想想为什么是void*类型？

因为设计者在设计这个库函数的时候不知道会用来拷贝何种类型，所以只有设计成void*最合适。

看下面一段代码：

#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()

函数原型：

其实C语言只要求：

memcpy能拷贝不重叠的内存空间就可以了，memmove去处理那些重叠的内存拷贝，也就是说，如果记memcpy的功能是A，那么memmove的功能就是A+B

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

#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)]$