指针

取地址运算

1 . 运算符 &

• scanf(“%d”, &i);⾥的&
• 获得变量的地址，它的操作数必须是变量，int i; printf(“%x”,&i);
• 地址的⼤⼩是否与int相同取决于编译器，int i; printf(“%p”,&i);

2. &不能取的地址

&不能对没有地址的东⻄取地址

&(a+b)?

&(a++)?

&(++a)?

3. 试试这些&

变量的地址

相邻的变量的地址

&的结果的sizeof

数组的地址

数组单元的地址

相邻的数组单元的地址

指针

1. scanf

如果能够将取得的变量的地址传递给⼀个函数， 能否通过这个地址在那个函数内访问这个变量？

• scanf(“%d”, &i);

scanf()的原型应该是怎样的？我们需要⼀个参数 能保存别的变量的地址，如何表达能够保存地址 的变量？

2. 指针

就是保存地址的变量

int i;

int* p = &i;

int* p,q;

int *p,q;

3. 指针变量

• 变量的值是内存的地址

1. 普通变量的值是实际的值
2. 指针变量的值是具有实际值的变量的地址

4. 作为参数的指针

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

5. 访问那个地址上的变量*

• *是⼀个单⺫运算符，⽤来访问指针的值所表⽰的地 址上的变量
• 可以做右值也可以做左值int k = *p;*p = k+1;

6. ＊左值之所以叫左值

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

7. 指针的运算符&*

互相反作⽤

*&yptr -> * (&yptr) -> * (yptr的地 址)-> 得到那个地址上的变量 -> yptr

&*yptr -> &(*yptr) -> &(y) -> 得到y的地 址，也就是yptr -> yptr

8. 传⼊地址

• 为什么 ？ int i; scanf(“%d”, i);
• 编译没有报错？

9.  指针应⽤场景⼀

交换两个变量的值

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

10. 指针应⽤场景⼆

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

11. 指针应⽤场景⼆b

• 函数返回运算的状态，结果通过指针返回
• 常⽤的套路是让函数返回特殊的不属于有效范围内的 值来表⽰出错：-1或0（在⽂件操作会看到⼤量的例⼦）
• 但是当任何数值都是有效的可能结果时，就得分开返 回了,后续的语⾔（C++,Java）采⽤了异常机制来解决这 个问题

12. 指针最常⻅的错误

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

13. 9.1-3 指针与数组

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

• 函数参数表中的数组实际上是指针

1. sizeof(a) == sizeof(int*)
2. 但是可以⽤数组的运算符[]进⾏运算

14. 数组参数

以下四种函数原型是等价的：

int sum(int *ar, int n);

int sum(int *, int);

int sum(int ar[], int n);

int sum(int [], int);

15.数组变量是特殊的指针

• 数组变量本⾝表达地址，所以

1. int a[10]; int*p=a; // ⽆需⽤&取地址
2. 但是数组的单元表达的是变量，需要⽤&取地址
3. a == &a[0]

• []运算符可以对数组做，也可以对指针做：

1. p[0] <==> a[0]

• *运算符可以对指针做，也可以对数组做：

1. *a = 25;

• 数组变量是const的指针，所以不能被赋值

1. int a[] <==> int * const a=….

＊9.1-4 指针与const

1.指针与const

2. 指针是const

• 表⽰⼀旦得到了某个变量的地址，不能再指向 其他变量

1. int * const q = &i; // q 是 const
2. *q = 26; // OK
3. q++; // ERROR

3. 所指是const

• 表⽰不能通过这个指针去修改那个变量（并不 能使得那个变量成为const）

1. const int *p = &i;
2. *p = 26; // ERROR! (*p) 是 const
3. i = 26; //OK
4. p = &j; //OK

4. 这些是啥意思？

int i;

const int* p1 = &i;

int const* p2 = &i;

int *const p3 = &i;

判断哪个被const了的标志是const在*的前⾯还是后⾯

5. 转换

• 总是可以把⼀个⾮const的值转换成const的

void f(const int* x);

int a = 15; f(&a);// ok

const int b = a;

f(&b); // ok

b = a + 1; // Error!

• 当要传递的参数的类型⽐地址⼤的时候，这是常⽤的⼿ 段：既能⽤⽐较少的字节数传递值给参数，⼜能避免函 数对外⾯的变量的修改

6. const数组

const int a[] = {1,2,3,4,5,6,};

数组变量已经是const的指针了，这⾥的const 表明数组的每个单元都是const int

所以必须通过初始化进⾏赋值

7. 保护数组值

因为把数组传⼊函数时传递的是地址，所以那个函数 内部可以修改数组的值

为了保护数组不被函数破坏，可以设置参数为const

• int sum(const int a[], int length);

指针是可计算的

1. 1+1=2?

• 给⼀个指针加1表⽰要让指针指向下⼀个 变量

1. int a[10];
2. int *p = a;
3. *(p+1) —> a[1]

• 如果指针不是指向⼀⽚连续分配的空间， 如数组，则这种运算没有意义

2. 指针计算

• 这些算术运算可以对指针做：

1. 给指针加、减⼀个整数(+, +=, -, -=)
2. 递增递减(++/—)
3. 两个指针相减

3. *p++

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

4. 指针⽐较

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

5. 0地址

• 当然你的内存中有0地址，但是0地址通常是 个不能随便碰的地址
• 所以你的指针不应该具有0值
• 因此可以⽤0地址来表⽰特殊的事情：

1. 返回的指针是⽆效的
2. 指针没有被真正初始化（先初始化为0）

• NULL是⼀个预定定义的符号，表⽰0地址

1. 有的编译器不愿意你⽤0来表⽰0地址

6. 指针的类型

• ⽆论指向什么类型，所有的指针的⼤⼩都 是⼀样的，因为都是地址
• 但是指向不同类型的指针是不能直接互相 赋值的
• 这是为了避免⽤错指针

7. 指针的类型转换

• void* 表⽰不知道指向什么东⻄的指针

1. 计算时与char*相同（但不相通）

• 指针也可以转换类型

1. int *p = &i; void*q = (void*)p;

• 这并没有改变p所指的变量的类型，⽽是让 后⼈⽤不同的眼光通过p看它所指的变量

1. 我不再当你是int啦，我认为你就是个void!

8. ⽤指针来做什么

• 需要传⼊较⼤的数据时⽤作参数
• 传⼊数组后对数组做操作
• 函数返回不⽌⼀个结果

1. 需要⽤函数来修改不⽌⼀个变量

• 动态申请的内存...

动态内存分配

1.输⼊数据

• 如果输⼊数据时，先告诉你个数，然后再输⼊，要记 录每个数据
• C99可以⽤变量做数组定义的⼤⼩，C99之前呢？
• int *a = (int*)malloc(n*sizeof(int));

2. malloc

• #include void* malloc(size_t size);
• 向malloc申请的空间的⼤⼩是以字节为单位 的
• 返回的结果是void*，需要类型转换为⾃⼰ 需要的类型

1. (int*)malloc(n*sizeof(int))

3.没空间了？

如果申请失败则返回0，或者叫做NULL 

你的系统能给你多⼤的空间？

4. free()

• 把申请得来的空间还给“系统”
• 申请过的空间，最终都应该要还

1. 混出来的，迟早都是要还的

• 只能还申请来的空间的⾸地址 • free(0)？

5. 常⻅问题

• 申请了没free—>⻓时间运⾏内存逐渐下降

1. 新⼿：忘了
2. ⽼⼿：找不到合适的free的时机

• free过了再free
• 地址变过了，直接去free

函数间传递指针

1. 好的模式

如果程序中要⽤到动态分配的内存，并且 会在函数之间传递，不要让函数申请内存 后返回给调⽤者

因为⼗有⼋九调⽤者会忘了free，或找不 到合适的时机来free

好的模式是让调⽤者⾃⼰申请，传地址进 函数，函数再返回这个地址出来

2. 函数返回指针？

• 返回指针没问题，关键是谁的地址？

1. 本地变量（包括参数）？函数离开后这些变量就不 存在了，指针所指的是不能⽤的内存
2. 传⼊的指针？ 没问题
3. 动态申请的内存？ 没问题
4. 全局变量—>以后再解释

函数返回数组？

• 如果⼀个函数的返回类型是数组，那么它实际返回 的也是数组的地址
• 如果这个数组是这个函数的本地变量，那么回到调 ⽤函数那⾥，这个数组就不存在了
• 所以只能返回

1. 传⼊的参数：实际就是在调⽤者那⾥
2. 全局变量或动态分配的内存