是啊，不可避免的，我們要學習指針了。關于指針的概念，我們已經在第一章節 理解程序中的數據 課題中大概的介紹過了，我想它并不是一個很難的概念，如果對指針沒有任何一點概念的朋友可以試著百度一下，再看一下我們以前的章節。
之所以把指針放到現在來講，一方面是因為，到現在我們所學的知識，可以允許我把一個完整的指針及其相關的知識展現給大家而不需將一個知識點打亂到各個別的章節中；再一方面就是我們接下來的要學習的繼承、多態等特性剛好需要這方面的的知識，省的我們再回頭復習，當然，主要原因還是我沒有信心能將這個專題寫好。
是的，我們在管理內存，管理一些數據結構等等，很多情況都要使用指針，我們這個專題，就專門來討論下指針的問題。
讓我們再來回顧下，指針的一些概念。
一、 什么是指針（指針與變量）。
很多的教科書上說，指針就是一個保存別的變量地址的一個變量，直白點說，指針就是地址。關于什么是變量、什么是地址、什么是數據類型的問題，我想大家應該都明白的，這里我就節省一些篇幅。
好，我們看一下指針的定義格式：
數據類型 *指針變量名; // 單純的使用指針變量名就是操作地址，給變量名帶上*就是取內容。
好，既然指針時用來保存別的變量的地址的，那我們可以很容易的給一個指針變量賦值，以及對一個指針變量進行操作（見代碼：Exp01）:
#include "stdafx.h"
#include <stdio.h>
#include <string.h>
int main(int argc, char* argv[])
{
int nNum = 0;
int *pnNum = NULL;
pnNum = &nNum; // 將nNum的地址保存到pnNum變量中;
scanf("%d", &nNum); // 輸入一個數值
printf("nNum變量的地址: 0x%08X\r\n", &nNum); // 輸出nNum變量的地址
printf("nNum變量的內容: %d\r\n", nNum); // 輸出輸入的變量的內容
printf("pnNum的地址: 0x%08X\r\n", &pnNum); // 輸出指針變量pnNum的地址
printf("pnNum的內容: 0x%08X\r\n", pnNum); // 輸出指針變量pnNum的內容
printf("pnNum內容的內容: %d\r\n", *pnNum); // 輸出指針變量pnNum內容的內容
return 0;
}
好，貼一下運行結果，讓我們仔細比較這兩個變量之間的聯系。
看明白了么？是不是可以理解成pnNum指向了nNum變量呢?由此，我們可以說，pnNum是nNum的指針。
如果大家真的明白了他們的關系，大家不妨試著寫寫nNum指針的指針的指針……
當然，如果內存學的夠好的朋友可以寫一下這兩個變量在棧的排列方式……
二、 指針與數組
忘記在哪本書中說的: 指針和數組是近親。現在越來越發現，確實是這個樣子的，下面讓我來帶著大家領略下它們的風采。
1. 數組的基本用法
關于數組，我想大家應該太不陌生了，我們第一節課就講述了數組的用法。
在這里，我們為了節省篇幅，我僅簡單扼要的回顧一下數組相關的知識點:
1、 數組是用來存放相同數據類型的數據集合
2、 數組名就是這一數據集合的首地址（是常量）。
3、 數組的下標從0開始，數組中的數據是按照數組的下標順序依次存放。
如下面的程序：
#include <windows.h>
int main()
{
char szaddrName[] = "52pojie.cn";
char *pszTitle = "Null";
MessageBoxA(NULL, szaddrName , pszTitle, MB_OK);
return 0;
}
OK，我們看下他們的存放方式有什么區別：
哈哈，是不是一樣呢？
2. 數組和指針的互操作
char g_szaddrName[] = "52pojie.cn";
char *g_pszTitle = "Null";
// 用指針操作數組
void TestPoint()
{
char *pszPoint = g_szaddrName;
while (*pszPoint)
{
printf("%c", *pszPoint++);
}
printf("\r\n");
}
// 用數組操作指針
void TestArr()
{
char *pszPoint = g_szaddrName;
int nLength = strlen(pszPoint);
for (int i = 0; i < nLength; i++)
{
printf("%c", pszPoint[i]);
}
printf("\r\n");
}
3. 二維數組的基本用法
OK,明白了這些，我們舉一個簡單走迷宮的例子來說明二維數組的存儲和使用（具體代碼見Exp03）：
我們先定義一個地圖：
/************************************************************************/
// 迷宮地圖數據
// 0表示墻
// 1表示可以行走的路
// 2表示已經走過的路
// 3表示返回的路
/************************************************************************/
int g_MazeMapData[13][13] = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1},
{0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0},
{0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0},
{0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0},
{0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0},
{0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0},
{0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0},
{0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0},
{0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
{0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0},
{0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0},
{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
有了地圖，我們需要一些標記，用來確定如：入口點坐標，出口在哪里，指定的坐標經過沒有等等問題：
#define IN_POS_X 1 // 入口點X坐標
#define IN_POS_Y 12 // 入口點Y坐標
#define OUT_POS_X 12 // 出口點X坐標
#define OUT_POS_Y 1 // 出口點Y坐標
#define UNKNOWN 1 // 從來沒走過的路
#define PASS 2 // 經過的標記
#define BACK 3 // 返回的標記
#define GO 0 // 前進
#define COMEBACK 1 // 后退
接下來，我們需要考慮下，實現走路的方式：
/************************************************************************/
// 按照 上、右、下、左的順序尋路
// 參數含義:
// nFlag: GO 表示前進，COMEBACK表示返回
// 返 回 值:
// 1 : 向上走，2: 向右走, 3: 向下走, 4: 向左走, 0:異常（出地圖了，不移動）
/************************************************************************/
int MoveTo(int nFlag)
{
if(nFlag == 0)
{
// 上
if (g_MazeMapData[g_nCurPosX][g_nCurPosY-1] == UNKNOWN)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = PASS;
g_nCurPosY--;
return 1;
}
// 右
if (g_MazeMapData[g_nCurPosX+1][g_nCurPosY] == UNKNOWN)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = PASS;
g_nCurPosX++;
return 2;
}
// 下
if (g_MazeMapData[g_nCurPosX][g_nCurPosY+1] == UNKNOWN)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = PASS;
g_nCurPosY++;
return 3;
}
// 左
if (g_MazeMapData[g_nCurPosX-1][g_nCurPosY] == UNKNOWN)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = PASS;
g_nCurPosX--;
return 4;
}
}
else
{
// 上
if (g_MazeMapData[g_nCurPosX][g_nCurPosY-1] == PASS)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = BACK;
g_nCurPosY--;
return 1;
}
// 右
if (g_MazeMapData[g_nCurPosX+1][g_nCurPosY] == PASS)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = BACK;
g_nCurPosX++;
return 2;
}
// 下
if (g_MazeMapData[g_nCurPosX][g_nCurPosY+1] == PASS)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = BACK;
g_nCurPosY++;
return 3;
}
// 左
if (g_MazeMapData[g_nCurPosX-1][g_nCurPosY] == PASS)
{
g_MazeMapData[g_nCurPosX][g_nCurPosY] = BACK;
g_nCurPosX--;
return 4;
}
}
return 0;
}
最后，我們只需要一個函數，來確定是否到達出口，或者判斷下有沒有出口并給出相應提示：
/************************************************************************/
// 開始走迷宮
// 如果找到出口了，返回1，否則返回0
// 如果程序異常中斷了，返回-1
/************************************************************************/
int Start()
{
while (1)
{
// 開始走路
if (MoveTo(GO) == 0)
{
MoveTo(COMEBACK);
}
for(int i=0; i<=OUT_POS_X; i++)
{
for(int j = 0; j <= IN_POS_Y; j++)
{
printf("%d ", g_MazeMapData[i][j]);
}
printf("\r\n");
}
Sleep(500);
system("cls");
// 如果當前的坐標是出口坐標表示找到出口了
if (g_nCurPosX == OUT_POS_X && g_nCurPosY == OUT_POS_Y)
{
return 1;
}
// 如果又退回入口位置了，表示沒有找到出口
if (g_nCurPosX == IN_POS_X && g_nCurPosY == IN_POS_Y)
{
return 0;
}
}
return -1;
}
我相信，通過這個程序，足夠讓大家理解并掌握二維數組及多維數組的用法了。下面，我們來考慮一些具體的問題。
4. 數組的尋址方式
相信好多朋友同我一樣，很抽象的將二維數組在內存中的模樣就想像成二維的平面了，三維數組就想想成立方體……，卻忽略掉它們其實都是線性存儲的。
這樣，無論是我們在以后的編碼過程中還是在逆向分析中確定當前操作的是哪個元素就尤為重要的。（比如通過單循環來遍歷一個二維數組等等）。
其實，如果真要說起它的尋址方式，還真的挺容易的，不信，聽我慢慢道來：
a) 一維數組的尋址
比如，已知在自己身前10米處有一柵門，門后面有一排邊長為1米的正方形箱子，求第四個箱子離自己有多遠，哈哈，簡單吧:相信很多朋友脫口就能說出來是：10+1*4 = 14米
那再問，一個數組：int ary[10] = {0}; //已知 ary的地址是:0x12ff68,求ary[3]的地址是多少？。
0x12ff68+sizeof(int)*3 = 0x12ff68+0x0C = 0x12ff74
b) 二維維數組的尋址
問: 有十個箱子，沒個箱子中放十個蘋果，求第七個箱子中第三個蘋果是這些箱子中的第幾個蘋果。
這個問題是不是就相當于有A[10][10]， 求A[6][2]是第幾個元素。即：6*10+3 = 63
由此推理，我們可以推演一下它的尋址公式：
如：有數組：type ary[x][y]; 則ary[x][z]的地址是：
Ary[x]addr = ary addr + sizeof(type[y])*x = ary addr + sizeof(type)*x*y
Ary[x][z]addr = ary[x]addr + sizeof(type)*z
由此，將公式優化一下：
Ary[x][z]addr = ary addr + sizeof(type)*y*x + sizeof(type)*z;
= ary addr + sizeof(type)*(x*y+z);
因此，二維數據的尋址公式就是：Ary[x][z]addr = ary addr + sizeof(type)*(x*y+z);
此公式中x*y+z就是求第幾個元素的公式。
舉個例子實驗一下：
如：int ary[3][4] = {0};已知數組首地址是：0x12ff68,求ary[1][2]是第幾個元素，并求出其在內存的地址。
套公式：
1、1*4+2 = 6 ，所以是第六個元素。
2、0x12ff68+sizeof(int)*(1*4+2) = 0x12ff68+ 4 * 6 = 0x12ff68 + 0x18 = 0x12ff80，地址是：0x12ff80
5. 淺談指針數組
只簡單說明下用法，詳細信息大家自己摸索，下滿舉個應用的例子，一堆字符串的排序：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/************************************************************************/
// 按照字符順序排序
/************************************************************************/
int SortTaxis(char *szNameBuf[], int nCount)
{
int x = 0, y = 0;
char *szTmpBuf = NULL;
if (szNameBuf == NULL)
{
return 0;
}
if (nCount <= 0)
{
return 0;
}
for (x = 0; x < nCount-1; x++)
{
for (y = x+1; y < nCount; y++)
{
if (strcmp(szNameBuf[x], szNameBuf[y]) > 0)
{
szTmpBuf = szNameBuf[x];
szNameBuf[x] = szNameBuf[y];
szNameBuf[y] = szTmpBuf;
}
}
}
return 0;
}
int main()
{
int i = 0;
char *szNameBuf[] = {
"Kalkwasser",
"John Parsons",
"Nathan Bryce",
"Edward",
"John Mackintosh",
"Henry Ford",
"William Sanders",
"Nathaniel",
"George",
"Tom Rees",
"Clementia",
"Mary Jones",
"Natasha",
"DrMudd",
"Charlie Chaplin",
"Julius Caesar",
"Krakatoa",
"James Brady",
"John Paul II",
"Freud",
"Tom Rees",
"pineapple lily",
"Antony"};
SortTaxis(szNameBuf, 23);
for (i = 0; i < 23; i++)
{
puts(szNameBuf[i]);
}
return 0;
}
簡單的評論下，這樣寫的代碼簡單精簡，效率高，因為它交換的是指針，用的是指針數組，與二維數組相比，它節省空間……
三、 指針與函數
1. 用指針作為函數的參數
我想，不論是指針作為參數還是引用作為參數，都有值得讓我們來調試它一下，弄清楚其原理，由于這些比較簡單，所以具體的調試過程留給大家，希望大家也能得到與我一樣的結論：傳遞的是地址，存在一份地址的拷貝。
具體使用指針作為參數的參考代碼可以見上面指針數組的函數：
int SortTaxis(char *szNameBuf[], int nCount)
2. 用指針作為函數的返回類型
返回一個指針類型是可行的，但是我相信初學者一定像我一樣，都會犯一個同樣的錯誤：返回局部變量的地址，如下代碼：
char * stringcat(char *pszStr1, char *pszStr2)
{
if (!pszStr1 || !pszStr2)
{
return NULL;
}
char pszResultStr[128] = {0};
strcpy(pszResultStr, pszStr1);
strcat(pszResultStr, pszStr2);
return pszResultStr;
}
這段代碼漏洞很多，我希望我的讀者朋友不會寫出這樣的代碼。
1、 首先它定義的是數組，空間大小可能越界造成棧溢出漏洞。
2、 它返回的是一個棧地址，容易被覆蓋。
我希望大家能調試一下這段代碼（Exp05）就想我以前調試分析別的代碼一樣，大家自己分析下，問題出在哪里。
3. 使用函數指針
經過上面的一翻學習，我相信，大家已經很清楚的明白，我們的指針不僅能夠指向棧數據區，而且還可以指向堆數據區乃至全局數據區，當然，我相信大家也肯定能夠理解指針也可以指向代碼區，因為我們早在學習函數的專題中，用數組存放我們代碼的機器碼并執行過它，數組名不就是數組的首地址么，函數名不也是地址么，地址不就是指針么。
好，不多廢話，看代碼（Exp06）：
int sum(int nNum1, int nNum2)
{
return nNum1 + nNum2;
}
int main()
{
int nSum = sum(1, 2);
printf("%d\r\n", nSum);
return 0;
}
想必，這個是我寫過的最簡單的函數了，不用加注釋，大家肯定能猜出來這段代碼的含義（如果真的不知道它的功能，那……）。
現在我們需要寫一個指針，讓它指向這個函數，應該怎么寫呢？
回想一下我們以前說過的話，一個函數名，就是一個地址，也就是一個int類型的常量，倘若如果我們直接給一個整型指針賦值一個函數名，編譯器檢查應該是類型報錯，我們先測試一下：
int *pFun = sum; // error C2440: 'initializing' : cannot convert from 'int (__cdecl *)(int,int)' to 'int *'
很明顯，類型轉換出錯了，按照錯誤提示，我們修改一下：
int (__cdecl *pFun)(int,int) = sum; // 哈哈，編譯通過。
我們知道，__cdecl是C調用方式（可以省略的.），OK,我們現在測試一下，這個函數指針能不能用：
int (*pFun)(int,int) = sum;
nSum = pFun(3, 8);
printf("%d\r\n", nSum);
OK，大功告成。
四、 指針的擴展用法
1. 函數指針類型的定義
我想，像上面這樣定義一個指針，一定非常的麻煩的，如果我們在牽扯到一些數據類型轉換，那更是讓人頭疼。比如下面的代碼：
int (WINAPI * call)(HWND,LPSTR,LPSTR,UINT);
HMODULE hDll=LoadLibrary("user32.dll");
call=(int(WINAPI * )(HWND,LPSTR,LPSTR,UINT))GetProcAddress(hDll,"MessageBoxA");
FreeLibrary(hDll);
(*call)(NULL,"HI,I AM FROM USER32.DLL","TEST",MB_OK);
當然，這還是簡單的，還有更復雜足以讓我們頭暈的代碼，就不以此列舉了。這就迫使我們定義一個相關的數據類型，這樣以后只要像定義一個變量那樣使用就可以了，比如上面的代碼可以變成：
typedef int (WINAPI * call)(HWND,LPSTR,LPSTR,UINT);
call mycall; //定義一個函數指針變量
HMODULE hDll=LoadLibrary("user32.dll");
mycall=(call)GetProcAddress(hDll,"MessageBoxA");
FreeLibrary(hDll);
(*mycall)(NULL,"HI,I AM FROM USER32.DLL","TEST",MB_OK);
這樣就讓人好理解，同樣也精簡了代碼。
我相信，對于typedef這個關鍵字，我們一定不陌生，因為在本系列的第一小節中，我們已經提到過它了。它的基本用法格式是： typedef 舊數據類型 新數據類型
通過上面的編譯錯誤：'int (__cdecl *)(int,int)' to 'int *' 我們可以知道，int (__cdecl *)(int,int)本來就是數據類型。而 int (__cdecl *PFUN_TYPE)(int,int) 中的PFUN_TYPE就是新的數據類型。
這樣，我們最開始的代碼就又可以寫成：
typedef int (*PFUN_TYPE)(int,int);
PFUN_TYPE pFun;
pFun = sum;
int nSum = pFun(3, 8);
printf("%d\r\n", nSum);
2. 成員函數指針的使用
從進入C++的課程以來，我們講述了類中成員函數的調用方式，它們比起普通的函數多了一個傳遞this指針的過程，因此，我們剛才說的定義函數指針的方法對于成員函數而言是無效的。其解決方法也自然的就變成了怎么傳遞一個this指針呢？
回想一下，我們在類外定義成員函數的代碼，比如：
bool CExample::SetNum(int nFirst, int nSec)
{
m_nFirstNum = nFirst;
m_nSecNum = nSec ;
return true;
}
對，它限定了作用域，所以它表示它仍然是類內的一個函數，那我們的函數指針也仿造它來寫一個。
typedef void (Person::*PBASEFUN_TYPE)(); // 這里的*是為了與靜態成員函數區分
好，我們編寫如下代碼（見Exp06）：
class Person;
typedef void (*PFUN_TYPE)();
typedef void (Person::*PBASEFUN_TYPE)();
class Person
{
public:
PBASEFUN_TYPE *m_pFunPoint;
Person()
{
m_pFunPoint = (PBASEFUN_TYPE*)new PFUN_TYPE[2];
m_pFunPoint[0] = (PBASEFUN_TYPE)sayHello;
m_pFunPoint[1] = (PBASEFUN_TYPE)sayGoodbye;
}
void sayHello()
{
printf("person::Hello\r\n");
}
void sayGoodbye()
{
printf("person::Goodbye\r\n");
}
};
這樣，我們就簡單的實現了一個成員函數的指針數組，算是為我們學習類的多態性中虛函數大點兒基礎，相信大家應該能看明白吧。
調用測試一下：
Person thePer;
(thePer.*thePer.m_pFunPoint[0])();
五、 幾點注意事項
1、 一定要注意函數指針指向內容的釋放以免防止內存泄露。
2、 注意及時將不用的指針賦值為NULL，以避免野指針的問題。
六、 小結
指針為我們的編程提供了諸多的技巧，簡化了我們的代碼。當然，于此同時，它也有反面的作用：當今軟件中的內存錯誤及不穩定，90%以上是由于指針操作失誤而導致的，這足以見得指針的破壞力。
因此，有效、合理、安全的使用指針是每個C程序員必備的基本素質。