概覽

指針是C語言的精髓，但是很多初學者往往對於指針的概念並不深刻，以至於學完之後隨著時間的推移越來越模糊，感覺指針難以掌握，本文通過簡單的例子試圖將指針解釋清楚，今天的重點有幾個方面：

什麼是指針 數組和指針 函數指針

什麼是指針

存放變量地址的變量我們稱之為“指針變量”,簡單的說變量p中存儲的是變量a的地址,那麼p就可以稱為是指針變量,或者說p指向a。當我們訪問a變量的時候其實是程序先根據a取得a對應的地址，再到這個地址對應的存儲空間中拿到a的值，這種方式我們稱之為“直接引用”；而當我們通過p取得a的時候首先要先根據p轉換成p對應的存儲地址，再根據這個地址到其對應的存儲空間中拿到存儲內容，它的內容其實就是a的地址，然後根據這個地址到對應的存儲空間中取得對應的內容，這個內容就是a的值，這種通過p找到a對應地址再取值的方式成為“間接引用”。這裡以表格形式列出a和p的存儲以幫助大家理解上面說的內容：

接下來，看一下指針的賦值

//
// main.c
// Point
//
// Created by Kenshin Cui on 14-7-05.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
  
  int a=1;
  int *p;
  p=&a; //也可以直接給指針變量賦值：int *p=&a;
  printf("address(a)=%x,address(p)=%x\n",&a,p); //結果：address(a)=5fbff81c,address(p)=5fbff81c
  printf("a=%d,p=%d\n",a,*p); //結果：a=1,p=1
  *p=2;
  printf("a=%d,*p=%d\n",a,*p); //結果：a=2,p=2
  
  int b=8;
  char c= 1;
  int *q=&c;
  printf("address(b)=%x,address(c)=%x\n",&b,&c);//結果：
  printf("c=%d,q=%d\n", c, *q); //結果：c=1,q=2049，為什麼q的值不是1呢？
  
  return 0;
}

需要說明兩點：

a.int *p;中的*只是表示p變量是一個指針變量；而打印*p的時候，*p中的*是操作符，表示p指針指向的變量的存儲空間（當前存儲就是1），同時我們也看到了*p==a；修改了*p也就是修改了p指向的存儲空間的內容，也就修改了a，所以第二次打印a=2;

b.指針所指向的類型必須和定義指針時聲明的類型相同；上面指針q定義成了int型而指向了char型，結果輸出*q打印出了2049，具體原因見下圖（假設在16位編譯器下，指針長度為2字節）

由於局部變量是存儲在棧裡面的，所以先存儲b再存儲a、p，當打印*p的時候，其實就是以p指向的地址對應的空間開始取兩個字節的數據（因為定義p的時候它指向的是int型，在16位編譯器下int類型的長度為2），剛好定義的b和c空間連續，所以就取到b的其中一個字節，最後*p二進制存儲為“0000100000000001”（見上圖黃色背景內容），十進制表示就是2049；

c.指針變量占用的空間和它所指向的變量類型無關，只跟編譯器位數有關（准確的說只跟尋址方式有關）；

數組和指針

由於數組的存儲是連續的，數組名就是數組的地址，這樣一來數組和指針就有著很微妙的關系，先看以下例子：

//
// main.c
// Point
//
// Created by Kenshin Cui on 14-7-05.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

void changeValue(int a[]){
  a[0]=2;
}
void changeValue2(int *p){
  p[0]=3;
}

int main(int argc, const char * argv[]) {
  int a[]={1,2,3};
  int *p=&a[0]; //等價於：*p=a;
  
  printf("len=%lu\n",sizeof(int));//取得int長度為2
  
  //指針加1代表地址向後挪動所指向類型的長度位（這裡類型是int，長度為2）
  //也就是說p指向a[0],p+1指向a[1]，以此類推，所以我們通過指針也可以取出數組元素
  for(int i=0;i<3;++i){
    //printf("a[%d]=%d\n",i,a[i]);
    printf("a[%d]=%d\n",i,*(p+i));//由於a就代表數組的地址，其實這裡還可以寫成*(a+i),但是注意這裡*(p+i)可以寫成*(p++),但是*(a+i)不能寫成*(a++),因為數組名是常量
  }
  /*輸出結果：
   a[0]=1
   a[1]=2
   a[2]=3
   */
   
  
  changeValue(p); //等價於：changeValue(a)
  for(int i=0;i<3;++i){
    printf("a[%d]=%d\n",i,a[i]);
  }
  /*輸出結果：
   a[0]=2
   a[1]=2
   a[2]=3
   */
  
  changeValue2(a); //等價於：changeValue2(p)
  for(int i=0;i<3;++i){
    printf("a[%d]=%d\n",i,a[i]);
  }
  /*輸出結果：
   a[0]=3
   a[1]=2
   a[2]=3
   */
  
  return 0;
}

從上面的例子我們可以得出如下結論：

數組名a==&a[0]==*p； 如果p指向一個數組，那麼p+1指向數組的下一個元素，同時注意p+1移動的長度並不固定，具體需要根據p指向的數據類型而定； 指針可以寫成p++形式，但是數組名不可以，因為數組名是常量 不管函數的形參為數組還是指針，實參都可以使用數組名或指針；擴展--字符串和指針

由於在C語言中字符串就是字符數組，下面不妨看一下字符串和數組的關系：

//
// main.c
// Point
//
// Created by Kenshin on 14-7-05.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
  char a[]="Kenshin";
  printf("%x,%s\n",a,a);//結果：5fbff820,Kenshin，同一個變量a是輸出字符串還是輸出地址，根據格式參數而定
  printf(a); //結果：Kenshin
  printf("\n");
  
  char b[]="Kenshin";
  char *p=b;
  printf("b=%s,p=%s\n",b,p);//結果：b=Kenshin,p=Kenshin
  
  //指針存儲的是地址，而數組名存儲的也是地址，既然字符數組可以表示字符串，那麼指向字符的指針同樣也可以，如下方式可以更簡單的定義一個字符串
  char *c="Kenshin"; //等價於char c[]="Kenshin";
  printf("c=%s\n",c); //結果：c=Kenshin
  
  return 0;
}

以上代碼中注釋基本已經很清楚了，這裡需要指出是為什麼printf(a)能夠直接輸出字符串呢？

我們看一下printf()的定義:int printf(const char * __restrict, ...) __printflike(1, 2);

其實printf的參數要求是指向字符類型的指針，而結合上面的例子和我們之前說的，如果函數形參是指針類型那麼可以傳入函數名，因此也就能正確輸出字符串的內容了。類似的還有上一篇文章中說的strcat()、strcpy()等函數均是如此。

函數指針

在弄清函數指針的問題之前，我們不妨先來看一下返回指針類型數據的函數，畢竟指針類型也是C語言的數據類型，下面以一個字符串轉換為大寫字符的程序為例，在這個例子中不僅可以看到返回值為指針類型的函數同時還可以看到前面說到的指針移動操作：

//
// main.c
// Point
//
// Created by Kenshin Cui on 14-06-28.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

char * toUpper(char *a){
  char *b=a; //保留最初地址，因為後面的循環會改變字符串最初地址
  int len='a'-'A'; //大小寫ASCII碼差值相等
  while (*a!='\0') { //字符是否結束
    if(*a>'a'&&*a<'z'){//如果是小寫字符
      *(a++) -= len; //*a表示數組對應的字符（-32變為小寫），a++代表移動到下一個字符
    }
  }
    return b;
}

int main(int argc, const char * argv[]) {
  char a[]="hello";
  char *p=toUpper(a);
  printf("%s\n",p); //結果：HELLO
  return 0;
}

大家都是知道函數只能有一個返回值，如果需要返回多個值，怎麼辦，其實很簡單，只要將指針作為函數參數傳遞就可以了，在下面的例子中我們再次看到指針作為參數進行傳遞。

//
// main.c
// Point
//
// Created by Kenshin Cui on 14-6-28.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int operate(int a,int b,int *c){
  *c=a-b;
  return a+b;
}

int main(int argc, const char * argv[]) {
  int a=1,b=2,c,d;
  d=operate(a, b, &c);
  printf("a+b=%d,a-b=%d\n",d,c);//結果：a+b=3,a-b=-1
  return 0;
}

函數也是在內存中存儲的，當然函數也有一個起始地址（事實上函數名就是函數的起始地址），這裡同樣需要弄清函數指針的關系。函數指針定義的形式：返回值類型 (*指針變量名)(形參1，形參2)，拿到函數指針其實我們就相當於拿到了這個函數，函數的操作都可以通過指針來完成，而且通過前面的例子可以看到指針作為C語言的數據類型，可以作為參數、作為返回值，那麼當然函數指針同樣可以作為函數的參數和返回值：

//
// main.c
// Point
//
// Created by Kenshin Cui on 14-6-28.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//

#include <stdio.h>

int sum(int a,int b){
  return a+b;
}

int sub(int a,int b){
  return a-b;
}

//函數指針作為參數進行傳遞
int operate(int a,int b,int (*p)(int,int)){
  return p(a,b);
}

int main(int argc, const char * argv[]) {
  int a=1,b=2;
  int (*p)(int ,int)=sum;//函數名就是函數首地址,等價於：int (*p)(int,int);p=sum;
  int c=p(a,b);
  printf("a+b=%d\n",c); //結果：a+b=3
  
  
  //函數作為參數傳遞
  printf("%d\n",operate(a, b, sum)); //結果：3
  printf("%d\n",operate(a, b, sub)); //結果：-1
  
  return 0;
}

函數指針可以作為函數參數進行傳遞，實在太強大了，是不是想起了C#中的委托？記得C#書籍中經常提到委托類似於函數指針，其實說的就是上面的情況。需要注意的是，普通的指針可以寫成p++進行移動，而函數指針寫成p++並沒有意義。