数组命名，指针概念

短命女 2022-11-26 06:56 177阅读 0赞

一、研究数组名字。  
例子： int A\[N\] -> 在内存中连续申请N\*4个字节，然后使用变量A间接访问这片内存空间。  
\-> 只需要使用数组名 + 下标方式可以访问到数组中任何一个成员。

1、当数组名作用于sizeof()时，那么数组名代表数组在内存中申请的空间大小。  
int main(int argc,char \*argv\[\])  
\{  
int A\[5\];  
printf("sizeof(A) = %ld\\n",sizeof(A)); //20  
return 0;  
\}

2、当数组名不是作用于sizeof()时，那么数组名代表数组首元素的地址。

A -> 数组名  
A\[0\] -> 数组的首元素  
&A\[0\] -> 数组的首元素的地址

A 等价于 &A\[0\]

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int A\[5\] = \{1,2,3,4,5\};  
  
//1. 因为A是数组名，sizeof(A) 计算整个数组在内存空间中申请的空间大小  
printf("sizeof(A) = %ld\\n",sizeof(A)); //20  
\-------------------------------------------------------------------------  
千万不要这么想： 因为A是数组名，所以A等价于&A\[0\],所以说sizeof(A)等价于sizeof(&A\[0\]),因为地址在64位系统都是8个字节，所以sizeof(&A\[0\])就是8，所以sizeof(A)也等于8。

应该这么想： 因为A是数组名，所以当数组名作用于sizeof()时，A就是代表数组的空间，因为A数组有5个int，所以sizeof(A)=20  
\-------------------------------------------------------------------------

//2. 因为A是数组名，但是没有作用于sizeof()中，所以A就是一个地址  
printf("A = %p\\n",A); //等价于&A\[0\]  
  
//3. 因为A\[0\]是首元素，所以&A\[0\]就是首元素的地址  
printf("&A\[0\] = %p\\n",&A\[0\]); //等价于A  
  
//4. 计算首元素的地址在空间中占多少个字节。  
printf("sizeof(&A\[0\]) = %ld\\n",sizeof(&A\[0\])); //8  
  
return 0;  
\}

二、指针概念。  
1、什么是指针？什么是指针变量？  
指针指的是内存空间上的地址值，例如：0x100 -> 指的就是一个指针。  
指针变量就是指可以存放指针的变量。 -> 值的就是一个变量。

2、既然指针变量可以存放指针的，那么指针变量如何写？  
1）将指针指向目标的内存空间定义出来。  
int a;

2）这个申请下来的空间地址该如何表示？ -> 取址符：&  
&a -> 代表a空间的地址

3）定义对应的指针变量？  
指针变量这种变量的类型不属于基本数据类型，所以需要用户去写清楚。  
int \*p;

指针变量：  
1）. 先写一个\* \*  
2）. 在\*后面写一个指针变量的名字 \*p  
3）. 确定你指向的内容是什么？ int a  
4）. 将第3步结果的变量名去掉 int  
5）. 将第2步的结果写在第4步结果的后面 int \*p

分析结果： int \*p; -> 专门用于存放int类型变量的地址的变量。

数据类型：int \* -> 非基本数据类型  
变量名：p

4）赋值。  
p = &a;

5）解引用  
取址符：& 已知变量a，求地址p p = &a; -> &可以将a变量的地址求出来，然后将地址存放在变量p中。  
解引用：\* 已知地址p，求p指向的内容 x = \*p; -> \*可以将p地址指向的内容求出来，求出来之后，将结果存放在变量x中。

解应用： \*指针变量 -> 得到该指针变量指向的空间上的值。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
int \*p = &a;  
  
printf("a = %d\\n",a); //100  
printf("&a = %p\\n",&a);//0x7ffc8febcbcc  
printf("p = %p\\n",p); //0x7ffc8febcbcc  
printf("\*p = %d\\n",\*p);//100  
  
return 0;  
\}

结论： &与\*是一对逆运算，所以在一些场景中可以相互抵消。  
例如：  
int a = 100;  
int \*p = &a;

所以，解引用p就是\*p 等价于 \*(&a) 等价于 a 等价于 100

拓展：请问&a这个地址是什么类型的？  
实际上就是在问存放这个地址的指针变量的数据类型是什么？ -> int\*

练习1： 完成1，2，3，5题。

3、指针的种类？ -> 区分方法：使用数据类型来区别。

指向目标： int a -> 指针变量： int \*pa -> 类型： int \* -> 这种类型的变量是专门用于存放整型变量的地址。  
指向目标： char b -> 指针变量： char \*pb -> 类型： char \* -> 这种类型的变量是专门用于存放字符类型变量的地址。  
指向目标： char c -> 指针变量： char \*pc -> 类型： char \* -> 这种类型的变量是专门用于存放字符类型变量的地址。

结论1： 决定指针变量类型的是指向目标的数据类型。  
结论2： 不能通过指针变量里面存放的地址值来判断指针变量的类型是否一致。

4、指针变量在内存中占用空间的大小。  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
char b = 'x';  
double c = 3.14;  
  
int \*pa = &a;  
char \*pb = &b;  
double \*pc = &c;  
  
printf("sizeof(a) = %ld\\n",sizeof(a));//4  
printf("sizeof(b) = %ld\\n",sizeof(b));//1  
printf("sizeof(c) = %ld\\n",sizeof(c));//8  
  
printf("sizeof(pa) = %ld\\n",sizeof(pa));//8  
printf("sizeof(pb) = %ld\\n",sizeof(pb));//8  
printf("sizeof(pc) = %ld\\n",sizeof(pc));//8  
  
return 0;  
\}

结论： 指针变量在内存中占用空间的大小都是8个字节。(64位)  
原因： 因为在linux下，无论是什么变量，都会在内存上申请空间，自然而然就会占用地址，而这些地址的长度都是8个字节，所以存放着这些地址的变量(指针变量)申请下来后，就会占8个字节。

三、空指针与野指针。  
1、什么是野指针？  
定义一个指针变量，如果没有进行初始化，系统就会赋值一个随机值给这个指针变量，也就是说，这个指针指向一个未知的区域，该指针变量就是野指针。

2、如何解决野指针问题？  
1）定义指针同时初始化一下。  
例子：  
int a;  
int \*p = &a; //p就不会指向一个未知的区域，就会指向a空间的地址。

2）使用空指针。  
什么是空指针？  
其实空指针就是内存空间上的一个地址，这个地址是0x0  
\#define NULL 0 -> NULL 等价于 0x0 等价于 空指针 -> 指向一片安全区域。

例子：  
int \*p = NULL; -> p现在就是指向安全区域。  
int a;  
p = &a;

3、如果一个指针指向安全区域，这时候解引用这个指针，会怎么样？  
会出现段错误：Segmentation fault (core dumped) -> 就是你访问了NULL，类似于int \*p = NULL, \*p

4、如果出现了段错误，怎么办？  
段错误不是语法错误，所以在gcc编译时，不会提示任何东西，而是在运行时候，如果遇到段错误，程序就会打印Segmentation fault (core dumped)，并且程序会马上结束。

1）运行代码，发现段错误。  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
int \*p = NULL;  
int b = \*p; //段错误  
printf("b = %d\\n",b);  
return 0;  
\}

运行结果：  
Segmentation fault (core dumped)

2）通过printf()打印，找段错误的位置。 (可能需要多次编译)  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
printf("hhhh!\\n");  
int \*p = NULL;  
printf("kkkk!\\n");  
int b = \*p;  
printf("aaaa!\\n");  
printf("b = %d\\n",b);  
printf("bbbb!\\n");  
return 0;  
\}

运行结果：  
hhhh!  
kkkk!  
Segmentation fault (core dumped)

分析：很明显段错误的位置就是在"int b = \*p;"

3）接下来，就在这句话之前，把这句话中含有的变量的值都打印出来。  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
int \*p = NULL; //修改为&a  
printf("p = %p\\n",p); //肯定为NULL  
int b = \*p; //段错误  
printf("b = %d\\n",b);  
return 0;  
\}

练习2：请求出以下程序的结果。

=====================================  
int swap(int x,int y)  
\{  
int t;  
t = x;  
x = y;  
y = t;  
return 0;  
\}

int main(int argc,char \*argv\[\])  
\{  
int a,b;  
scanf("%d %d",&a,&b); //5 3

swap(a,b);  
printf("a = %d,b = %d\\n",a,b);//5 3  
return 0;  
\}

原因：形参的值是由实参直接初始化，但是过程不可逆，形参的值修改了，但是实参不会改变。  
x与y的值确实是可以对换，但是函数swap返回时，在swap函数中申请x与y的空间就会释放，不会影响到a与b的值，所以a与b没有对换。

=====================================  
int a,b;  
int swap()  
\{  
int t;  
t = a;  
a = b;  
b = t;  
return 0;  
\}

int main(int argc,char \*argv\[\])  
\{  
scanf("%d %d",&a,&b); //5 3  
swap();  
printf("a = %d,b = %d\\n",a,b);//3 5  
return 0;  
\}

原因： 由于全局变量在内存中申请空间在data区，这个区域的变量的特性，程序一开始就会申请，到程序结束了才会释放。  
由于全局变量作用域整个.c文件中所有的函数，所以main函数与swap函数操作的用一个a与b，所以swap函数可以调换a与b的值。

=======================================

int swap(int \*x,int \*y)  
\{  
int t;  
t = \*x;  
\*x = \*y;  
\*y = t;  
return 0;  
\}

int main(int argc,char \*argv\[\])  
\{  
int a,b;  
scanf("%d %d",&a,&b); //5 3

swap(&a,&b);  
printf("a = %d,b = %d\\n",a,b);//3 5  
return 0;  
\}