第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(n*sizeof(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的空间

free()

• 把申请得来的空间还给“系统”
• 申请过的空间，最终都应该要还
• 只能换申请来的空间的首地址

常见问题

• 申请了没free-->长时间运行内存逐渐下降
• free过了再free
• 地址变过了，直接去free