1、取地址运算：&运算符取得变量的地址
scanf("%d",&i); //里的&——获得变量的地址，它的操作数必须是变量。
int i; printf("%x",&i); //%x 是以十六进制形式输出指针的值（即内存地址） printf("%p",&i); //%p 是输出指针的值（即内存地址） //64位下结果不一样。一般用%p。
地址的大小是否与int相同取决于编译器。
&不能对没有地址的东西取地址
&(a+b) ? &(a++)? &(++a)?
2、指针：指针变量就是记录地址(或保存地址)的变量
int i; int* p=&i;
int* p,q; //p是指针变量，q不是
int *p,q; //p是指针变量，q不是。
变量的值是内存的地址
（1）普通变量的值是实际的值。
（2）指针变量的值是具有实际值的变量的地址
作为参数的指针
（1）在被调用的时候得到了某个变量的地址；
（2）在函数里面可以通过这个指针访问外面的这个i;
void f(int *p);
int i=0； f(&i);
访问那个地址上的变量*
（1）* 是一个单目运算符，用来访问指针的值所表示的地址上的变量。
（2）可以做右值也可以做左值
int k=*p; *p=k+1;
*左值之所以叫左值
（1）是因为出现在赋值号左边 的不是变量，而是值，是表达式计算的结果。
a[0]=2;
*p=3;
（2）是特殊的值，所以叫做左值。
指针的运算符&*
——互相反作用
（1）*&yptr ——> *(&yptr) ——> *(yptr的地址） ——> 得到那个地址上的变量 ——> yptr
（2）&*yptr ——> &(*yptr) ——> &(y) ——>得到y的地址，也就是yptr ——> yptr
传入地址
（1）为什么
int i; scanf("%d",i);
（2）编译没有报错？
3、指针的使用：指针有什么用呢？
——交换两个变量的值
void swap(int *pa, int *pb) { int t=*pa; *pa=*pb; *pb=t; }
——函数返回多个值，某些值就只能通过指针返回
传入的参数实际上是需要保存带回的结果的变量。
——函数返回运算的状态，结果通过指针返回
（1）常用的套路是让函数返回特殊的不属于有效范围内的值来表示出错：
-1或0（在文件操作会看到大量的例子）。
（2）但是当任何数值都是有效的可能结果时，就得分开返回了
后续的语言（C++,Java）采用了异常机制来解决这个问题。
4、指针与数组：为什么数组传进函数后的sizeof不对了？
指针最常见的错误
定义了指针变量，还没有指向任何变量，就开始使用指针
传入函数的数组成了什么？
（1）函数参数表中的数组实际上是指针。
sizeof(a)=sizeof(int*)
但是可以用数组的运算符[]进行运算。
int isPrime(int x , int konwPrimes[] , int numberOfKnowPrimes) { int ret=1; int i; for(i =0 ; i< numberOfKnowPrimes; i++){ if(x % konwPrimes[i] == 0 ){ ret =0; break; } } return ret; }
数组参数
以下四种函数原型是等价的：
int sum(int *ar, int n);
int sum(int *,int);
int sum (int ar[] ,int n);
int sum (int [], int);
数组变量是特殊的指针
（1）数组变量本身表达地址，所以
int a[10]; int *p=a; //无需用&取地址
a== &a[0]; //但是数组的单元表达的是变量，需要用&取地址。
（2）[]运算符可以对数组做，也可以对指针做：
p[0] <==> a[0]
（3）* 运算符可以对指针做，也可以对数组做：
*a=25;
（4）数组变量是const的指针，所以不能被赋值
int a[] <==> int *const a=....
5、指针与const：指针本身和所指的变量都可能是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在 * 的前面还是后面。
转换
（1）总是可以把一个非const的值转换成const的
void f(const int* x); int a=15; f(&a); //OK const int b = a; f(&b); //OK b = a+1; //ERROR!
（2）当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。
const数组
const int a[]={1,2,3,4,5,6};
（1）数组变量已经是const的指针了，这里的const表明数组的每个单元都是const int。
（2）所以必须通过初始化进行赋值。
保护数组值
（1）因为把数组传入函数时传递的是地址，所以那个函数内部可以修改数组的值。
（2）为了保护数组不被函数破坏，可以设置参数为const
int sum( const int a[], int length);
6、指针运算
（1）给指针加1 表示要让指针指向下一个变量
int a[10]; int *p=a; *(p+1) ——> a[1]
（2）如果指针不是指向一片连续分配的空间，如数组，则这种运算没有意义。
指针计算
——这些算术运算可以对指针做：
（1）给指针加、减一个整数（+，+=，-，-=）
（2）递增递减（++/--）
（3）两个指针相减
*p++
（1）取出p所指的那个数据来，完事之后顺便把p移到下一个位置去。
（2）* 优先级虽然高，但是没有++高
（3）常用于数组类的连续空间操作
（4）在某些CPU上，这可以直接被翻译成一条汇编指令
指针比较
（1）<，<=，==，>，>=，!=都可以对指针做
（2）比较它们在内存中的地址
（3）数组中的单元的地址肯定是线性递增的
0地址
（1）当然你的内存中有0地址，但是0地址通常是个不能随便碰的地址
（2）所以你的指针不应该具有0值
（3）因此可以用0地址来表示特殊的事情：
——返回的指针是无效的；
——指针没有被真正初始化（先初始化为0）。
（4）NULL是一个预定定义的符号，表示0地址
——有的编译器不愿意你用0来表示0地址。
指针的类型
（1）无论指向什么类型，所有的指针的大小都是一样的，因为都是地址
（2）但是指向不同类型的指针是不能互相赋值的
（3）只是为了避免用错指针
指针的类型转换
（1）void *表示不知道指向什么东西的指针
——计算时与char* 相同（但不相通）
（2）指针也可以转换类型
int *p = &i; void *q=(void*)p;
（3）这并没有改变p所指的变量的类型，而是让后人用不同的眼光通过p看它所指的变量
——我不再当你是int啦，我认为你就是个void
用指针来做什么
（1）需要传入较大的数据时用作参数
（2）传入数组后对数组做操作
（3）函数返回不止一个结果
——需要用函数来修改不止一个变量。
（4）动态申请的内存...
7、动态内存分配
输入数据
（1）如果输入数据时，先告诉你个数，然后再输入，要记录每个数据
（2）C99可以用变量做数组定义的大小，C99之前呢
int *a = (int*) malloc (n*sizeof(int));
malloc
#include<stdlib.h> void* malloc(size_t size);
（1）向malloc申请的空间的大小是以字节为单位的
（2）返回的结果是void*，需要类型转换为自己需要的类型
（int*）malloc(n*sizeof(int))
没空间了？
（1）如果申请失败则返回0，或者叫做NULL
（2）你的系统能给你多大的空间？
free()
（1）把申请得来空间还给“系统”
（2）申请过的空间，最终都应该要还
（3）只能还申请来的空间的首地址
（4）free(0)?
常见问题
（1）申请了没free——>长时间运行内存逐渐下降
（2）free过来再free
（3）地址变过了，直接去free
8、函数间传递指针
好的模式
（1）如果程序中要用到动态分配的内存，并且会在函数之间传递，不要让函数申请内存后返回给调用者
（2）因为十有八九调用者会忘了free，或找不到合适的时机来free
（3）好的模式是让调用者自己申请，传地址进函数，函数再返回这个地址出来
除非函数的作用就是分配空间，否则不要在函数中malloc然后传出去用
函数返回指针
——返回指针没问题，关键是谁的地址？
（1）本地变量（包括参数）？函数离开后这些变量就不存在了，指针所指的是不能用的内存
（2）传入的指针？没问题
（3）动态申请的内存？没问题
（4）全局变量——>以后说
函数返回数组
和返回指针是一样的
（1）如果一个函数的返回类型是数组，那么它实际返回的也是数组的地址
（2）如果这个数组时这个函数的变量，那么回到调用函数那里，这个数组就不存在了
（3）所以只能返回
——传入的参数：实际就是在调用者那里
——全局变量或动态分配的内存