C语言零基础入门级进阶数组+指针+面试题全讲解下
【1】数组名涵义
数组名有两个含义：
第一含义是：整个数组
第二含义是：首元素地址
当出现以下情形时，那么数组名就代表整个数组：在数组定义中 在 sizeof 运算表达式中
在取址符&中
其他任何情形下，那么数组名就代表首元素地址。
即：此时数组名就是一个指向首元素的指针。
示例：
int a[3]; // 此处，a 代表整个数组
printf("%d\n", sizeof(a)); // 此处，a 代表整个数组
printf("%p\n", &a); // 此处，a 代表整个数组，此处为整个数组的地址
int *p = a; // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
p = a + 1; // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
function(a); // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
scanf("%d\n", a); // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
C语言只有在第一含义的场合下表现为数组，其他大部分场合都表现为首元素的地址，当数组表现为首元素地址时，实际上就是一个指向其首元素的指针。数组运算实际上就是指针运算。
【2】数组下标
数组下标实际上是编译系统的一种简写.
其等价形式是： a[i] = 100; 等价于 *(a+i) = 100;
根据加法交换律，以下的所有的语句均是等价的：
a[i] = 100;
*(a+i) = 100;
*(i+a) = 100;
i[a] = 100;
数组运算，等价于指针运算。
例如:
int a[3];
// 此处的a等价于 &a[0]，而a[0]是一个int，因此此处a的类型是 int (*)
int *p = a+1;
int a[2][3];
// 此处的a等价于 &a[0]，而a[0]是一个int[3]，因此此处a的类型是 int (*)[3]
int (*p)[3] = a+1;
int *a[3];//相当于二级指针，int **a;
// 此处的a等价于 &a[0]，而a[0]是一个int *，因此此处a的类型是 int (*)*
int **p = a+1;
【3】字符串常量（匿名数组）
字符串常量在内存中的存储，实质是一个匿名数组 匿名数组，同样满足数组两种涵义的规定
示例：
printf("%d\n", sizeof("abcd")); // 此处 "abcd" 代表整个数组
printf("%p\n", &"abcd"); // 此处 "abcd" 代表整个数组
printf("%c\n", "abcd"[1]); // 此处 "abcd" 代表匿名数组的首元素地址
char *p1 = "abcd"; // 此处 "abcd" 代表匿名数组的首元素地址
char *p2 = "abcd" + 1; // 此处 "abcd" 代表匿名数组的首元素地址
【4】零长数组（结构体空间扩充）
概念：长度为0的数组，比如 int data[0];
用途：放在结构体的末尾，作为可变长度数据的入口
示例：
struct node
{
/* 结构体的其他成员 */
// 成员1
// 成员2
// ... ...
int len;
char *data[0];
};
// 给结构体额外分配 10 个字节的内存。
struct node *p = malloc(sizeof(struct node) + 10);
p->len = 10;
// 额外分配的内存可以通过 data 来使用
p->data[0] ~ p->data[9]
【5】变长数组
概念：定义时，使用变量作为元素个数的数组。
要点：变长数组仅仅指元素个数在定义时是变量，而绝非指数组的长度可长可短。实际上，不管是普通数组还是所谓的变长数组，数组一旦定义完毕，其长度则不可改变。
示例：
int len = 5;
int a[len]; // 数组元素个数 len 是变量，因此数组 a 是变长数组
int x = 2;
int y = 3;
int b[x][y]; // 数组元素个数 x、y 是变量，因此数组 b 是变长数组
int b[2][y]; // 数组元素个数 y 是变量，因此数组 b 是变长数组
int b[x][3]; // 数组元素个数 x 是变量，因此数组 b 是变长数组
语法：变长数组不可初始化，即以下代码是错误的：
int len = 5;
int a[len] = {
1,2,3,4,5}; // 数组 a 不可初始化
【6】char型指针
char型指针实质上跟别的类型的指针并无本质区别，但由于C语言中的字符串以字符数组的方式存储，而数组在大多数场合又会表现为指针，因此字符串在绝大多数场合就表现为char型指针。
定义：
char *p = "abcd";
【7】多级指针
如果一个指针变量 p1 存储的地址，是另一个普通变量 a 的地址，那么称 p1 为一级指针
如果一个指针变量 p2 存储的地址，是指针变量 p1 的地址，那么称 p2 为二级指针
如果一个指针变量 p3 存储的地址，是指针变量 p2 的地址，那么称 p3 为三级指针
以此类推，p2、p3等指针被称为多级指针
示例：
int a = 100;
int *p1 = &a; // 一级指针，指向普通变量
int **p2 = &p1; // 二级指针，指向一级指针
int ***p3 = &p2; // 三级指针，指向二级指针
【8】指针万能拆解法
任意的指针，不管有多复杂，其定义都由两部分组成。
第1部分：指针所指向的数据类型，可以是任意的类型
第2部分：指针的名字
示例：
char (*p1); // 第2部分：*p1; 第1部分：char;
char *(*p2); // 第2部分：*p2; 第1部分：char *;
char **(*p3); // 第2部分：*p3; 第1部分：char **;
char (*p4)[3]; // 第2部分：*p4; 第1部分：char [3];
char (*p5)(int, float); // 第2部分：*p5; 第1部分：char (int, float);
注解：
上述示例中，p1、p2、p3、p4、p5本质上并无区别，它们均是指针
上述示例中，p1、p2、p3、p4、p5唯一的不同，是它们所指向的数据类型不同
第1部分的声明语句，如果由多个单词组成，C语言规定需要将其拆散写到第2部分的两边
【9】void型指针
概念：无法明确指针所指向的数据类型时，可以将指针定义为 void 型指针
要点： void 型指针无法直接索引目标，必须将其转换为一种具体类型的指针方可索引目标
void 型指针无法进行加减法运算
void关键字的三个作用：
修饰指针，表示指针指向一个类型未知的数据。 修饰函数参数列表，表示函数不接收任何参数。（预习）int main(void)
修饰函数返回类型，表示函数不返回任何数据。（预习）void func(int)
示例：
// 指针 p 指向一块 4 字节的内存，且这4字节数据类型未确定
void *p = malloc(4);
// 1，将这 4 字节内存用来存储 int 型数据
*(int *)p = 100;
printf("%d\n", *(int *)p);
// 2，将这 4 字节内存用来存储 float 型数据
*(float *)p = 3.14;
printf("%f\n", *(float *)p);
【10】const 型指针
const型指针有两种形式：①常指针 ②常目标指针
常指针：const修饰指针本身，表示指针变量本身无法修改。
常目标指针：const修饰指针的目标，表示无法通过该指针修改其目标。 常指针在实际应用中不常见。 常目标指针在实际应用中广泛可见，用来限制指针的读写权限
示例：
int a = 100;
int b = 200;
// 第1中形式，const修饰p1本身，导致p1本身无法修改
int * const p1 = &a;
// 第2中形式，const修饰p2的目标，导致无法通过p2修改a
int const *p2 = &a;
const int *p2 = &a;
【11】函数指针巧用之处
概念：指向函数的指针，称为函数指针。
特点：函数指针跟普通指针本质上并无区别，只是在取址和索引时，取址符和星号均可省略
示例：
void f (int); // 函数 f 的类型是： void (int)
void (*p)(int); // 指针 p 专门用于指向类型为 void (int) 的函数
p = &f; // p 指向 f（取址符&可以省略）
p = f; // p 指向 f
// 以下三个式子是等价的：
f (666); // 直接调用函数 f
(*p)(666); // 通过索引指针 p 的目标，间接调用函数 f
p (666); // 函数指针在索引其目标时，星号可以省略
要点： 函数指针是一类专门用来指向某种类型函数的指针。 函数的类型不同，所需要的函数指针也不同。
函数的类型，与普通变量的类型判定一致，即去除声明语句中的标识符之后所剩的语句。
【12】面试题
（字节序）
【1】编写一个程序，测试当前平台的字节序。
解析： 此题有多种解法，在本次课中，我们可以使用指针来操作某个特定的字节。
参考代码
#include <stdio.h>
int main(void)
{
// 定义一个4字节的整型数据
int a = 0x12345678;
// 定义一个char型指针指向最低地址
char *p = &a;
// 将最低字节数据打印出来
// 如果是0x78，那就代表最低地址存储了低有效位，是小端序
// 如果是0x12，那就代表最低地址存储了高有效位，是大端序
printf("%#x\n", *p);
}
（数组下标运算、指针运算、内存操作）
【2】分析以下代码的输出结果。
#include <stdio.h>
int main(void)
{
long a[4] = {
1, 2, 3, 4};
long *p1=(long *)(&a+1);
long *p2=(long *)((long)a+1);
printf("%lx\n", p1[-1]);
printf("%lx\n", *p2);
return 0;
}
解析：
首先，&a是整个数组的地址，因此&a+1实际上是向后偏移了16个字节，因此 p1 指向了数组边界。然后输出 p1[-1] 等价于
*(p1-1)，因为 p1 是 long 型指针，因此 p1-1 就向前偏移 sizeof(long) 个字节，也就是指向了 a[3]。其次，(long)a+1 是一个纯整数运算（因为a被强转为long了），因此 p2 就指向了long型数据 a[0] 的第二个字节，最后打印
*p2 时，由于 p2 是一个 long 型指针，系统会从 a[0] 的第二个字节开始，取出 sizeof(long) 个字节出来作为 long 型数据来解释，因此最后输出的结果是 a[0] 的高位三字节和 a[1] 低位一字节的数据。
（复杂声明、多维数组操作）
【3】声明一个二维 int 型数组 a，再声明另一个一维数组指针数组 b，使该数组 b 的每一个指针分别指向二维数组 a
中的每一个元素(即每一个一维数组)，然后利用数组 b 计算数组 a 的和。
解析
本题主要考察的是基本概念的理解：“指针数组”指的是装了很多指针的数组，
“数组指针”指的是指向数组的指针，“数组指针数组”指的是装了很多数组指针的数组。
参考代码
#include <stdio.h>
int main(void)
{
int a[2][3] = {
{
1, 2, 3}, {
4, 5, 6}};
int (*b[2])[3];
b[0] = &a[0];
b[1] = &a[1];
int i, j, sum=0;
for(i=0; i<2; ++i)
{
for(j=0; j<3; ++j)
{
sum += (*b[i])[j];
}
}
printf("sum: %d\n", sum);
return 0;
}
（数组操作）
【4】编写一个程序，求一个有N个元素的整型数组中子数组之和的最大值，子数组指的是一个数组中连续的若干个相邻的元素。 例如：
int a[7] = {-2, 5, -1, 6, -4, -8, 6}; 则子数组之和的最大值是 5+(-1)+6，即答案是 10。
解析： 本题是一道笔试题，考的是算法。因此不宜使用三重循环的暴力破解法。 参考代码：
#include <stdio.h>
int main(void)
{
int a[100];
int len = 0;
printf("请输入系列整数，以#结束\n");
while(scanf("%d", &a[len]) != 0)
len++;
int max=a[0], sum=0;
int i;
for(i=0; i<len; i++)
{
sum += a[i];
if(sum > max)
max = sum;
else if(sum < 0)
sum = 0;
}
printf("最大子数组之和: %d\n", max);
return 0;
}
（变长数组：将二维数组a复制到二维数组b）
【5】编写一个函数，它接收两个 m×n 的整型二维数组 a 和 b，
函数的功能是将数组 a 中的数据复制到数组 b 中。
参考代码：
#include <stdio.h>
#include <stdlib.h> // enable the function rand()
// 将数组source各个元素的值，赋给数组target
void assign(int row, int col,
double target[row][col], double source[row][col])
{
int i, j;
for(i=row; i>0; i--)
{
for(j=col; j>0; j--)
{
target[i-1][j-1] = source[i-1][j-1];
}
}
}
void show(int row, int col,
double target[row][col], double source[row][col])
{
int i, j;
printf("源数据:\n");
for(i=row; i>0; i--)
{
for(j=col; j>0; j--)
{
printf("%f\t", source[i-1][j-1]);
}
printf("\n");
}
printf("目标数据:\n");
for(i=row; i>0; i--)
{
for(j=col; j>0; j--)
{
printf("%f\t", target[i-1][j-1]);
}
printf("\n");
}
}
int main(void)
{
int i, j;
int row, col;
printf("请输入二维数组的行数和列数：\n");
scanf("%d%d", &row, &col);
double source[row][col];
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
{
// 往源数组中写入随机数据
source[i][j] = (double)rand() / (double)rand();
}
}
double target[row][col];
assign(row, col, target, source);
show(row, col, target, source);
return 0;
}
（字符数组:去除重复字符）
【6】编写一个程序，去掉给定字符串中重复的字符。 例如：
输入：google 输出：gole
参考代码：
#include <stdio.h>
#include <string.h>
void strip(char *str)
{
if(str == NULL)
return;
int i, j;
char *p = str;
// 将所有重复的字符标记为-1
for(i=1; str[i] != '\0'; i++)
{
for(j=0; j<i; j++)
{
if(p[j] == str[i])
{
str[i] = -1;
break;
}
}
}
// 找到第一个-1的位置 redun
// 找到紧随 redun 之后的正常字符的位置 common
int redun = 0, common = 0;
for(i=1; str[i] != '\0'; i++)
{
if(str[i] != REDUNDANT)
continue;
redun = i;
while(str[i] == REDUNDANT)
i++;
common = i;
break;
}
// 若没有重复的字符，则返回
if(redun == 0)
return;
// 将所有正常字符往前移
while(str[common] != '\0')
{
if(str[common] == -1)
{
common++;
continue;
}
str[redun++] = str[common];
str[common++] = -1;
}
str[redun] = '\0';
}
int main(void)
{
// 输入待处理字符串
char buf[64];
fgets(buf, 64, stdin);
strip(buf);
printf("%s", buf);
return 0;
}
