指针

内存和地址

内存其实就是一组有序字节组成的数组，数组中，每个字节大小固定，都是 8bit。对这些连续的字节从 0 开始进行编号，每个字节都有唯一的一个编号，这个编号就是内存地址。示意如下图：

指针变量保存的就是这些编号，也即内存地址。

地址与内容

我们只要知道内存地址，就可以访问这个地址的值，但是这种方法实在笨拙，于是便用变量名来代替地址：

名字与内存之间的关联仅仅只是编译器实现的，采用变量名的方式能够方便的记住地址，但是硬件仍然通过地址访问内存位置。

值和类型

考虑下面的32位值：

‭01100111011011000110111101100010‬

对于这些位的解释可以分为很多种：

类型	值
1个32位数	1735159650
2个16位数	26476和28514
4个字符	glob
浮点数	1.116533e24
机器指令	beg.+110和ble.+102

可见：不能简单地通过检查一个值的位来判断值的类型，而应该根据它的使用方式来判断。

使用指针的优势

在C语言中，指针的使用非常广泛，因为使用指针往往可以生成更高效、更紧凑的代码。总的来说，使用指针有如下好处：

• 指针的使用使得不同区域的代码可以轻易的共享内存数据，这样可以使程序更为快速高效。
• C语言中一些复杂的数据结构往往需要使用指针来构建，如链表、二叉树等。
• C语言是传值调用，而有些操作传值调用是无法完成的，如通过被调函数修改调用函数的对象，但是这种操作可以由指针来完成，而且并不违背传值调用。

取变量地址间接访问

对于一个操作数取地址使用单目操作符&。

通过指针访问它所指向的地址的过程称为间接访问或解引用指针，执行间接访问的操作符是单目操作符*。

声明一个指针

未初始化和非法指针

声明一个指针变量并不会自动分配任何内存。在对指针进行间接访问之前，指针必须进行初始化：

• 使它指向现有的内存
• 给它动态分配内存

指针的初始化实际上就是给指针一个合法的地址，让程序能够清楚地知道指针指向哪儿：

/* 方法1：使指针指向现有的内存 */
int x = 1;
int *p = &x;　　// 指针 p 被初始化，指向变量 x ，其中取地址符 & 用于产生操作数内存地址

/* 方法2：动态分配内存给指针 */
int *p;
p = (int *)malloc(sizeof(int) * 10);　　　　// malloc 函数用于动态分配内存
free(p);　　　　// free 函数用于释放一块已经分配的内存，常与 malloc 函数一起使用

果一个指针没有被初始化，那么程序就不知道它指向哪里。它可能指向一个非法地址，这时，程序会报错，在 Linux 上，错误类型是 Segmentation fault（core dumped）提醒我们段违例或内存错误。它也可能指向一个合法地址，实际上，这种情况更严重，你的程序或许能正常运行，但是这个没有被初始化的指针所指向的那个位置的值将会被修改，而你并无意去修改它。

NULL指针

NULL 指针是一个特殊的指针变量，表示不指向任何东西。可以通过给一个指针赋一个零值来生成一个 NULL 指针。

对一个NULL指针解引用操作是非法的，在对指针解引用之前必须确保它并非是NULL指针。

指针的运算

算术运算

C 指针的算术运算只限于两种形式：指针 +/- 整数 ，指针 - 指针。

指针 +/- 整数

可以对指针变量 p 进行 p++、p--、p + i 等操作，所得结果也是一个指针，只是指针所指向的内存地址相比于 p 所指的内存地址前进或者后退了 i 个操作数。

指针 - 指针

只有当两个指针都指向同一个数组中的元素时，才允许从一个指针减去另一个指针。

两个指针相减的结果的类型是 ptrdiff_t，它是一种有符号整数类型。

减法运算的值是两个指针在内存中的距离（以数组元素的长度为单位，而不是以字节为单位），因为减法运算的结果将除以数组元素类型的长度。

关系运算

使用操作符<，<=，>，>=对两个指针比较的前提是两个指针指向同一个数组中的元素，比较的结果是哪个指针指向数组更前或者更后的元素。

标准没有定义两个任意指针之间的比较会发生什么。

任意两个指针之间可以使用操作符!=、==进行比较，判断它们是不是指向同一个地址。

指针表达式

假设：

char ch = 'a';
char* cp = &ch;

那么：

表达式	含义
*cp	作为左值，表示cp指向的地址，也就是变量ch的地址；作为右值，表示cp所指向地址存放的内容，也就是'a'。
*cp + 1	作为右值，（*cp + 1）表示存放的内容加1，就是字符'a'+1，得到字符'b'；作为左值，*cp作为左值的意思是cp指向的那个地址本身，由于*cp + 1 这个表达式的最终结果的存储位置并未清晰定义，所以它不是一个合法的左值。
*（cp + 1）	作为右值，访问的是cp指向的位置的下一个位置的值；作为左值的话，就是cp+1 这个指针对应的位置本身。
++cp	表达式增加了指针变量cp的值。表达式的结果是增值后的指针的一份拷贝，因为前缀++先增加它的操作数的值再返回这个结果。所以作为右值而言， 它是ch的地址值加1的地址值。同样由于该位置未清晰定义，故而不能作为左值。
cp++	作为右值使用的话，它表示cp本身的值，也就是ch的地址值；如果cp++作为左值，会对cp进行加1操作后在被赋值，由于cp++代表的地址未有清晰的定义，所以不能作为左值。
*++cp	相当于*（++cp）,作为右值，cp作为指针变量的值加1后，也就是ch的地址值加1，得到一个新的地址，加上间接访问符之后，便是取该地址对应的内存中的内容；作为左值，显然是cp +1指向的那个地址本身，也即是ch的地址加1后的那个新地址本身。
*cp++	相当于*(cp++)，作为右值；是取cp指向的地址（即ch代表的地址&ch）的内容。这里也就是字符'a'；作为左值，这个表达式就表示cp指向的地址本身，也即是ch的地址。
++*cp	相当于++（*cp），作为右值的，*cp的意思是去cp指向的地址的值，这里为'a'，然后执行++操作，也就是加1，那么表达式的值为字符'b'；*cp作为左值的意思是cp指向的那个地址本身，也即是ch代表的地址，再进行++操作，也就是地址加1，得到的新地址未清晰定义，所以不能作为左值。
（*cp）++	作为右值，就是先取cp指向的地址的值，然后++，这样得到的就是'b'，作为左值，显然是非法的，因为最后执行的是++操作。或者说，*cp作为左值，代表cp指向的地址本身，再进行++，得到的是一个未清晰定义的地址，不能作为左值。
++*++cp	等价形式++（*（++cp））,由于最后进行的是++操作，所以不能作为左值；作为右值的情况，先进行++cp操作，是cp的地址加1得到的一个新地址（&ch + 1），之后进行间接访问操作，取新地址对应的内存存储的的值，再次进行++，是对这个新地址对应的内存中的值加1。
++*cp++	等价形式++（*（cp++）），同样，不能作为左值使用，因为最后操作的是++；作为右值的话，cp++中使用的是后缀++，故参与表达式运算的是cp的一份拷贝，之后再进行cp加1操作，*（cp++）取cp指向的地址的内容，即'a'，之后对'a'加1得到'b'。

指针的高级声明

指针的指针

int i;
int *pi = &i;
int **ppi = π

数组指针

数组指针是一个指针，它指向一个数组。

int (*p)[10];        // 声明一个数组指针 p ，该指针指向一个数组，这个数组包含10个整型数

函数指针

int (*f)();			// f是函数指针，指向的函数返回一个int类型
int (*f[])();		// f是一个数组，数组元素的类型是函数指针，它所指向的函数返回一个int类型
int *(*g[])(int,float)	// g是一个数组，数组的元素是函数指针，它所指向的函数包含int、float参数，返回int*

声明一个函数指针并不意味着可以马上使用，和其它类型的指针一样，对函数指针执行间接访问之前必须把它初始化为指向某个函数。

例如：

int (*pf)(int) = &f;

&操作符是可选的，因为函数名被使用时总是由编译器把它转换成函数指针。

&只是显示的地说明了编译器隐式执行的任务。

函数调用的方式：

int ans;
ans = f(1);
ans = (*pf)(1); //把函数指针解引用为函数名，这个转换起始并非真正需要，编译器还是会将函数名转换成函数指针
ans = pf(1);

函数指针应用

回调函数

用户把一个函数指针作为参数传递给其它函数，后者将回调用户传递进来的函数，这种技巧称为回调函数。

当我们在在链表中查找一个数时，我们一般会这样写：

Node *search_list( Node *node, int const value )
{
    while ( NULL != node ){
        if ( node->value == value ){
            break;
        }
        node = node->link;
    }

    return node;
}

这样就限制我们只能在查找的数必须是int类型，当变为其他类型时我们就无法用这个函数，但是重新写一个函数，重复代码又太多。

回调实现：

int compare_int( void const *a, void const *b )
{
    if ( *( int * )a == *( int * )b ){
        return 0;
    }

    return 1;
}

Node *search_list(Node *node, void const *value, 
    int (*compare)(void const *, void const *))  //函数指针
{
    while(node != NULL){
        if(compare(&node->value, value) == 0)  //相等
            break;
        node = node->link;
    }
    return node;
}

这样利用回调函数就可以解决如上问题。我们把一个函数指针（ int (*compare)(void const *, void const*) ）作为参数传递给查找函数，查找函数将“回调”比较函数。当我们需要执行不同类型的比较时我们合理调用该函数。

转移表

假设有程序：

switch (oper)
{
case ADD:	
	result = add(op1, op2);
	break;
case SUB:
	result = sub(op1, op2);
	break;
case MUL:
	result = mul(op1, op2);
	break;
case DIV:
	result = div(op1, op2);
	break;
......
}

switch语句很长，所以，在这里用转移表来使问题得以简化。

声明并初始化一个函数指针数组:

double add(double, double);
double sub(double, double);
double mul(double, double);
double div(double, double);
......

// 声明一个函数指针数组
double (*oper_func[])(double, double) = {
	add, sub, mul, div,......
};

// 函数调用
result = oper_func[oper](op1, op2);

这样就可以将具体操作和选择操作的代码分开。

命令行参数

int main(int argc,char *argv[])
int main(int argc,char **argv)

argc : 命令行传入参数的总个数 
argv : *argv[]是一个指针数组，里面存放的指针指向所有的命令行参数，argv[0]指向程序的名称，argv[1]指向在执行程序名后的第一个字符串，argv[2]指向第二个。

字符串常量

字符串常量的本质类型是指向字符的指针。

"xyz"+1   // 结果是一个指针，指向'y'
*"xyz"    // 结果是'x'
"xyz"[2]  // 结果是'z'