C语言编程：深入理解指针-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42061048/article/details/80083707

这篇博客详细探讨了C语言中的指针概念，包括取地址运算符&，指针变量，指针作为参数传递，以及指针与数组、const的关系。讲解了指针的运算，如加减运算、指针比较，并介绍了动态内存分配的使用和注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第8周：指针

标签（空格分隔）： C

8.1.1 指针：取地址运算

运算符&

scanf("%d",&i);里的&
获得变量的地址，它的操作数必须是变量
- int i; printf("%x", &i);
地址的大小是否与int相同取决于编译器
- int i; printf("%p", &i);

&不能取的地址

&不能对没有地址的大小取地址
- &(a+b)?
- &(a++)?
- &(++a)?
试试这些&
- 变量的地址
- 相邻的变量的地址
- &的结果的sizeof
- 数组的地址
- 数组单元的地址
- 相邻的数组单元的地址

8.1.2 指针：指针

指针

就是保存地址的变量
- int i;
- int* p = &i;
- int* p,q;
- int *p,q;

指针变量

变量的值是内存的地址
- 普通变量的值是实际的值
- 指针变量的值是具有实际值的变量的地址

作为参数的指针

void f(int *p)
在被调用的时候得到了某个变量的地址：
- int i = 0; f(&i);
在函数里面可以通过这个指针访问外面的这个i

访问那个地址上的变量*

*是一个单目运算符，用来访问指针的值所表示的地址上的变量
可以做右值也可以做左值
- int k = *p;
- *p = k+1;

左值之所以叫左值

是因为出现在赋值号左边的不是变量，而是值，是表达式计算的结果：
- a[0] = 2;
- *p = 3;
是特殊的值，所以叫做左值

指针的运算符&*

互相反作用
- *&yptr -> *(&yptr) -> *(yptr的地址) -> 得到那个地址上的变量 -> yptr
- &*yptr -> &(*yptr) -> &(y) -> 得到y的地址，也就是yptr -> yptr

8.1.3 指针：指针的使用

指针应用场景一

变换两个变量的值

void swap(int *pa, int *pb)
{
	int t = *pa;
	*pa = *pb;
	*pb = t;
}

指针应用场景二

函数返回多个值，某些值就只能通过指针返回
- 传入的参数实际上是需要保存带回的结果的变量

指针应用场景二b

函数返回运算的状态，结果通过指针返回
常用的套路是让函数返回特殊的不属于有效范围内的值来表示出错：
- -1或0（在文件操作中会看到大量的例子）
但是当任何数值都是有效的可能结果时，就得分开返回了

指针最常见的错误

定义了指针变量，还没有指向任何变量，就开始使用指针

8.1.4 指针：指针与数组

传入函数的数组成了什么？

函数参数表中的数组实际上是指针
- sizeof（a） == sizeof(*int)
- 但是可以用数组的运算符[]进行运算

数组参数

以下四种函数原型是等价的：
- int sum(int * ar, int n);
- int sum(int* , int);
- int sum(int ar[], int n);
- int sum(int[], int);

数组变量是特殊的指针

数组变量本身表达地址，所以
- int a[10]; int *p=a; //无需用&取地址
- 但是数组的单元表达的是变量，需要用&取地址
- a == &a[0]
[]运算符可以对数组做，也可以对指针做：
- p[0] <==> a[0]
*运算符可以对指针做，也可以对数组做：
- *a = 25；
数组变量是const的指针，所以不能被赋值
- int a[] <==> int * const a=…

8.1.5 指针：指针与const

指针是const

表示一旦得到了某个变量的地址，不能再指向其他变量
- int *const q = &i; //q 是 const
- *q = 26; //OK
- q++; //ERROR

所指是const

表示不能通过这个指针去修改那个变量（并不能使得那个变量成为const）
- const int *p = &i;
- *p = 26; //ERROR! (*p)是const
- i = 26； //OK
- p = &j; //OK
判断哪个被const的标志是const在*的前面还是后面

转换

总是可以把一个非const的值转换成const的

void f(const int *x)
int a =15;
f(&a); //OK
const int b = a;

f(&b); //OK
b = a + 1; //ERROR

当要传递的参数的类型比地址大的时候，这是常有的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改

const 数组

const int a[] = {1,2,3,4,5,6,};
数组变量已经是const的指针了，这里的const表明数组的每个单元都是const int
所以必须通过初始化进行赋值

保护数组值

因为把数组传入函数时传递的是地址，所以那个函数内部可以修改数组的值
为了保护数组不被破坏，可以设置参数为const
- int sum(const int a[], int length)

8.2.1 指针运算：指针运算

1+1 = 2？

给一个指针加 1 表示要让指针指向下一个变量
- int a[10];
- int* p = a;
- *(p+1) -> a[1]
如果指针不是指向一篇连续分配的空间，如数组，则这种运算没有意义

#include <stdio.h>

int main(void)
{
	char ac[] = {0,1,2,3,4,5,};
	char *p = ac;
	printf("p =%p\n", p);
	printf("p+1=%p\n", p+1);
//	*p -> ac[0];
//	*(p+1) -> ac[1];
//*(p+n) = ac[n]
	printf("*(p+1)=%p\n", *(p+1));

	int ai[] = {0,1,2,3,4,5,};
	int *q = ai;
	printf("q =%p\n", q);
	printf("q+1=%p\n", q+1);
	printf("*(q+1)=%p\n", *(q+1));
}
//sizeof(int) = 4,sizeof(char) = 1
p =000000000062FE30
p+1=000000000062FE31
*(p+1)=0000000000000001
q =000000000062FE10
q+1=000000000062FE14
*(q+1)=0000000000000001

指针计算

这些算术运算可以对指针做：
- 给指针加、减一个整数（+，+=，-，-=）
- 递增递减（++/–）
- 两个指针相减

*p++

取出p所指的那个数据来，完事之后顺便把p移到下一个位置去
*的优先级虽然高，但是没有++高
常用于数组类的连续空间操作
在某些CPU上，这可以直接被翻译成一条汇编指令

指针比较

<, <=, ==, >, >=, != 都可以对指针做
比较它们在内存中的地址
数组中的单元的地址看到是线性递增的

0地址

当然你的内存中有0地址，但是0地址通常是个不能随便盘碰的地址
所以你的指针中不应该具有0值
因此可以用0地址来表示特殊的事情：
- 返回的指针是无效的
- 指针没有被真正初始化（先初始化为0）
NULL是一个预定定义的符号，表示0地址
- 有的编译器不愿意你用0来表示0地址

指针的类型

无论指向什么类型，所有的指针的大小都是一样的，因为都是地址
但是指向不同类型的指针是不能直接互相赋值的
这是为了避免用错指针

指针的类型转换

void* 表示不知道指向什么东西的指针
- 计算时与char*相同（但不相通）
指针也可以转换类型
- int *p = &i; void *q = (void *) p;
这并没有改变p所指的变量的类型，而是让后人用不同的眼光通过p看它所指的变量
- 用q来看，不再认为是int,认为就是个void

用指针来做什么

需要传入较大的数据时用作参数
传入数组后对数组做操作
函数返回不止一个结果
- 需要用函数来修改不止一个变量
动态申请的内存

8.2.2 指针运算：动态内存分配**

输入数据

如果输入数据，先告诉你个数，要记录每个数据
C99可以用变量做数组定义的大小，C99之前呢？
int *a = (int )malloc(nsizeof(int));

malloc

#include <stdlib.h>
void* malloc*size_t size);

向malloc申请的空间的大小是以字节为单位的
返回的结果是void* ，需要类型转换为自己需要的类型
- (int*)malloc(n*sizeof(int))

没空间了？

如果申请失败则返回0，或者叫做NULL
你的系统能给你多大的空间？

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	void *p;
	int cnt = 0;
	while ((p=malloc(100*1024*1024))) {
		cnt++; 
	}
	printf("分配了%d00MB的空间\n", cnt) ;

	return 0;	
 } 

分配了29100MB的空间