股票交易指針代表什麼意思

1. 股市當中的K線圖都是什麼意思呀

股市當中的K線圖是技術參考指標
它與MACD、VR等指標一樣
具有參考價值
當KD金叉時
發出買入信號
當KD死叉時
發出賣出信號

2. 指針*和&分別是什麼意思

意思是通過它能找到以它為地址的內存單元。

由於通過地址能找到所需的變數單元，可以說，地址指向該變數單元。因此，將地址形象化的稱為「指針」。

在C中將一種專門表示變數指針（位置）的變數叫做指針變數，指針變數專用來存放地址，其值為指針（地址）。

定義指針變數：類型名 *指針變數名；

指針變數實用舉例：

int *p1,*p2; //定義兩個指向p1,p2的整型數據指針變數

p1=&a;

p2=&b; //把變數a和b的值的地址賦給指針變數p1,p2

pritf("*p1=%d,*p2=%d",*p1,*p2)

//以十進制輸出*p1，*p2所指向的地址所代表的的a,b的值

(2)股票交易指針代表什麼意思擴展閱讀

指針和引用的區別

1、首先，引用不可以為空，但指針可以為空。前面也說過了引用是對象的別名，引用為空——對象都不存在，怎麼可能有別名。故定義一個引用的時候，必須初始化。

2、 聲明指針是可以不指向任何對象，也正是因為這個原因，使用指針之前必須做判空操作，而引用就不必。

3、 引用不可以改變指向；但是指針可以改變指向，而指向其它對象。

3. 這些指針表示形式是什麼意思沒見過。請教：

答案是d，p++是先賦值後加，所以f(p++)<=>f(&a[0])
p指向了數組a的首地址，而數組名也代表數組的首地址，當指針p加（減）n運算時，指針p向數組下（上）移到n

4. 指針是什麼意思

指針
在信息工程中指針是一個用來指示一個內存地址的計算機語言的變數或中央處理器(CPU)中寄存器(Register)。指針一般出現在比較近機器語言的語言，如匯編語言或C語言。
面向對象的語言如Java一般避免用指針。指針一般指向一個函數或一個變數。
在使用一個指針時，一個程序既可以直接使用這個指針所儲存的內存地址，又可以使用這個地址里儲存的變數或函數的值。

指針與C語言
大家都認為，c語言之所以強大，以及其自由性，很大部分體現在其靈活的指針運用上。
因此，說指針是c語言的靈魂，一點都不為過。同時，這種說法也讓很多人產生誤解，似乎只有C語言的指針才能算指針。
basic不支持指針，在此不論。其實，pascal語言本身也是支持指針的。
從最初的pascal發展至今的object pascal，可以說在指針運用上，絲毫不會遜色於c語言的指針。

5. 什麼是指針股

也可以叫龍頭股，就是說通過這個股票走向可以看出大盤的走向！指針股是可以帶動人氣的。
問題補充：理解了,像工行,中行這樣的?
對，就是像這些超級大盤股可以帶動整個股市的。

6. 指針怎麼理解

1、指針的概念

指針是一個特殊的變數，它裡面存儲的數值被解釋成為內存里的一個地址。要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針所指向的類型，指針的值或者叫指針所指向的內存區，還有指針本身所佔據的內存區。分別說明。

先聲明幾個指針放著做例子：

int *ptr;

char *ptr;

int **ptr;

int (*ptr)[3];

int *(*ptr)[4];

2、指針的類型

從語法的角度看，只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個指針的類型。這是指針本身所具有的類型。看看下面各個指針的類型：

int *ptr; //指針的類型是int *

char *ptr; //指針的類型是char *

int **ptr; //指針的類型是 int **

int (*ptr)[3]; //指針的類型是 int(*)[3]

int *(*ptr)[4]; //指針的類型是 int *(*)[4]

3、指針所指向的類型

當通過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯器將把那片內存區里的內容當做什麼來看待。從語法上看，只須把指針聲明語句中的指針名字和名字左邊的指針聲明符*去掉，剩下的就是指針所指向的類型。例如：

int *ptr; //指針所指向的類型是int

char *ptr; //指針所指向的的類型是char

int **ptr; //指針所指向的的類型是 int *

int (*ptr)[3]; //指針所指向的的類型是 int()[3]

int *(*ptr)[4]; //指針所指向的的類型是 int *()[4]

在指針的算術運算中，指針所指向的類型有很大的作用。

指針的類型(即指針本身的類型)和指針所指向的類型是兩個概念。當對C越來越熟悉時，會發現，把與指針攪和在一起的「類型」這個概念分成「指針的類型」和「指針所指向的類型」兩個概念，是精通指針的關鍵點之一。

5、指針的值

指針的值是指針本身存儲的數值，這個值將被編譯器當作一個地址，而不是一個一般的數值。在32位程序里，所有類型的指針的值都是一個32位整數，因為32位程序里內存地址全都是32位長。

指針所指向的內存區就是從指針的值所代表的那個內存地址開始，長度為sizeof(指針所指向的類型)的一片內存區。以後，我們說一個指針的值是XX，就相當於說該指針指向了以XX為首地址的一片內存區域；一個指針指向了某塊內存區域，就相當於說該指針的值是這塊內存區域的首地址。

指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在例一中，指針所指向的類型已經有了，但由於指針還未初始化，所以它所指向的內存區是不存在的，或者說是無意義的。

6、指針本身所佔據的內存區

指針本身佔了多大的內存；只要用函數sizeof(指針的類型)測一下就知道了。在32位平台里，指針本身占據了4個位元組的長度。

指針本身占據的內存這個概念在判斷一個指針表達式是否是左值時很有用。

(6)股票交易指針代表什麼意思擴展閱讀：

指針的算術運算

指針可以加上或減去一個整數。指針的這種運算的意義和通常的數值的加減運算的意義是不一樣的。例如：

例一：

char a[20];

int *ptr=a;

...

...

ptr++;

在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變數a。接下來的第3句中，指針ptr被加了1，

編譯器是這樣處理的：它把指針ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由於地址是用位元組做單位的，故ptr所指向的地址由原來的變數a的地址向高地址方向增加了4個位元組。

由於char類型的長度是一個位元組，所以，原來ptr是指向數組a的第0號單元開始的四個位元組，此時指向了數組a中從第4號單元開始的四個位元組。

可以用一個指針和一個循環來遍歷一個數組，看例子：

例二：

這個例子將整型數組中各個單元的值加1。由於每次循環都將指針ptr加1，所以每次循環都能訪問數組的下一個單元。再看例子：

例三：

char a[20];

int *ptr = a;

...

...

ptr += 5;

在這個例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由於地址的單位是位元組，故現在的ptr所指向的地址比起加5後的ptr所指向的地址來說。

向高地址方向移動了20個位元組。在這個例子中，沒加5前的ptr指向數組a的第0號單元開始的四個位元組，加5後，ptr已經指向了數組a的合法范圍之外了。雖然這種情況在應用上會出問題，但在語法上卻是可以的。這也體現出了指針的靈活性。

如果上例中，ptr是被減去5，那麼處理過程大同小異，只不過ptr的值是被減去5乘sizeof(int)，新的ptr指向的地址將比原來的ptr所指向的地址向低地址方向移動了20個位元組。

總結一下，一個指針ptrold加上一個整數n後，結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個位元組。

就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向高地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。一個指針ptrold減去一個整數n後，

結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。

ptrnew的值將比ptrold的值減少了n乘sizeof(ptrold所指向的類型)個位元組，就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向低地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。

7. 什麼是指針，它的作用是什麼

指針科技名詞定義
中文名稱：指針 英文名稱：needle;pointer 定義1：能沿標尺刻度方向相對運動，指示被測量結果值的標記零件。 所屬學科：機械工程（一級學科）；儀器儀表元件（二級學科）；儀器儀表機械元件-示數元件（三級學科） 定義2：一種指示器，其值指示了虛容器起始點相對於支持虛容器的傳送實體的幀參考點的相位偏移。 所屬學科：通信科技（一級學科）；光纖傳輸與接入（二級學科） 本內容由全國科學技術名詞審定委員會審定公布
網路名片
在日常生活中指針是儀器或鍾表上的，用來指示測量的數據的裝置。在信息工程中指針是一個用來指示一個內存地址的計算機語言的變數或中央處理器(CPU)中寄存器。針灸中以手指代替針刺按壓或爪切某些穴位，治病的一種治療方法，常用於突發性病症，如虛脫、中暑、癔病及多種痛症。

目錄

信息學的指針指針
指針與C語言
內存分配表
是一個整數例證（一）
例證（二）
C 按值傳遞概述
編程參數值
*和&運算
另類*和&
雙重指針
指針數組、數組指針和指向函數的指針
指針的作用
指針網
鍾表的指針
指針法操作方法
適用范圍
注意事項
信息學的指針 指針
指針與C語言
內存分配表
是一個整數 例證（一）
例證（二）
C 按值傳遞 概述
編程參數值
*和&運算
另類*和&
雙重指針
指針數組、數組指針和指向函數的指針
指針的作用指針網鍾表的指針指針法
操作方法 適用范圍 注意事項展開

編輯本段信息學的指針
指針
在信息工程中指針是一個用來指示一個內存地址的計算機語言的變數或中央處理器(CPU)中寄存器(Register)。指針一般出現在比較近機器語言的語言，如匯編語言或C語言。面向對象的語言如Java一般避免用指針。指針一般指向一個函數或一個變數。在使用一個指針時，一個程序既可以直接使用這個指針所儲存的內存地址，又可以使用這個地址里儲存的變數或函數的值。
指針與C語言
大家都認為，c語言之所以強大，以及其自由性，很大部分體現在其靈活的指針運用上。因此，說指針是c語言的靈魂，一點都不為過。同時，這種說法也讓很多人產生誤解，似乎只有c語言的指針才能算指針。basic不支持指針，在此不論。其實，pascal語言本身也是支持指針的。從最初的pascal發展至今的object pascal，可以說在指針運用上，絲毫不會遜色於c語言的指針。
編輯本段內存分配表
計算機中的內存都是編址的，就像你家的地址一樣。在程序編譯或者運行的時候，系統（可以不關心具體是什麼，可能是編譯器，也可能是操作系統）開辟了一張表。每遇到一次聲明語句（包括函數的傳入參數的聲明）都會開辟一個內存空間，並在表中增加一行紀錄。記載著一些對應關系。（如圖1所示） 圖1
---------------------------------------------------- Declaration | ID Name Address Length ---------------------------------------------------- int nP; | 1 nP 2000 2B char myChar; | 2 myChar 2002 1B int *myPointer; | 3 myPointer 2003 2B char *myPointer2; | 4 myPointer2 2005 2B ----------------------------------------------------
編輯本段是一個整數
指針，是一個無符號整數（unsigned int），它是一個以當前系統定址范圍為取值范圍的整數。32位系統下定址能力（地址空間）是4G-byte（0~2^32-1）二進製表示長度為32bit（也就是4B）。 int類型也正好如此取值。
例證（一）
例證就是程序1得到的答案和程序2的答案一致。（不同機器可能需要調整一下pT的取值。） ---------------------------------------------------- 程序1 #include <stdio.h> main() { char *pT; char t='h'; pT=&t; putchar(*pT); } ---------------------------------------------------- 程序2 #include <stdio.h> main() { char *pT; char t='h'; pT=(char *)1245048; putchar(*pT); } ---------------------------------------------------- 加上(char *)是因為畢竟int 和char *不是一回事，需要強制轉換，否則會有個警告。因為char *聲明過的類型，一次訪問1個sizeof(char)長度，double *聲明過的類型，一次訪問1個sizeof(double)長度。 在匯編里int 類型和指針就是一回事了。因為不論是整數還是指針，執行自增的時候，都是其值加一。如果上文聲明char *pT;，匯編語言中pT自增之後值為1245049，可是C語言中pT++之後pT值為1245049。如果32 位系統中， s 上文聲明int *pT;，匯編語言中pT 自增之後值為1245049，可是C 語言中pT++之後pT值為1245052。 為什麼DOS下面的Turbo C，和Windows下VC的int類型不一樣長。因為DOS是16位的，Windows是32位的，可以預見，在64位Windows 中編譯，上文聲明int *pT;，pT++之後pT值為1245056。
例證（二）
那麼，復雜的結構怎麼分配空間呢？C語言的結構體（匯編語言對應為Record類型）按順序分配空間。（如圖2所示） 圖2
---------------------------------------------------- int a[20]; ---------------------------------------------------- typedef struct st { double val; char c; struct st *next; } pst; ---------------------------------------------------- pst pT[10]; ---------------------------------------------------- 在32 位系統下，內存裡面做如下分配（單位：H，16 進制）；（如圖3所示） 圖3
---------------------------------------------------- 變數 2000 2001 2002 2003 2004 2005 2006 … 204C 204D 204E 204F 地址 a[0] a[1] … a[19] ---------------------------------------------------- 變數 2050 2051 … 2057 2058 2059 205A 205B 205C 205D 205E 205F 地址 pst.val pst.c pst.next 無效 無效 無效 ---------------------------------------------------- 這就說明了為什麼sizeof(pst)=16而不是8。編譯器把結構體的大小規定為結構體成員中大小最大的那個類型的整數倍。 至於pT的存儲，可以依例推得。總長為160，此不贅述。 有個問題，如果執行pT++，答案是什麼？是自增16，還是160？別忘了，pT 是常量，不能加減。 所以，我們就可以聲明： ---------------------------------------------------- typedef struct BinTree { int value; struct BinTree *LeftChild; struct BinTree *RightChild; } BTree; ---------------------------------------------------- 用一個整數，代表一棵樹的結點。把它賦給某個結點的LeftChild/RightChild 值，就形成了上下級關系。只要無法找到一個路徑，使得A->LC/RC->LC/RC...->LC/RC==A，這就構成了一棵二叉樹。反之就成了圖。
編輯本段C 按值傳遞
概述
C 中函數調用是按值傳遞的，傳入參數在子函數中只是一個初值相等的副本，無法對傳入參數作任何改動。但實際編程中，經常要改動傳入參數的值。這一點我們可以用傳入參數的地址而不是原參數本身，當對傳入參數（地址）取（*）運算時，就可以直接在內存中修改，從而改動原想作為傳入參數的參數值。
編程參數值
---------------------------------------------------- #include <stdio.h> void inc(int *val) { (*val)++; } main() { int a=3; inc(&a); printf("%d" , a); } ---------------------------------------------------- 在執行inc(&a);時，系統在內存分配表裡增加了一行「inc 中的val」，其地址為新地址，值為&a。操作*val，即是在操作a 了。
編輯本段*和&運算
為了（*p）操作是這樣一種運算，返回p 的值作為地址的那個空間的取值。（&p）則是這樣一種運算，返回當時聲明p 時開辟的地址。顯然可以用賦值語句對內存地址賦值。我們假設有這么兩段內存地址空間，他們取值如下：（單位：H，16 進制）（如圖4所示） 圖4
---------------------------------------------------- 地址 0000 ... 2000 2001 2002 2003 2004 ... 3000 3001 3002 3003 ... 取值 ... 01 30 00 00 30 00 03 20 9A ---------------------------------------------------- 假設有這么一段代碼：（假設開辟空間時p 被分配給了3001H、3002H 兩個位置） ---------------------------------------------------- int *p; p=2003; *p=3000H ---------------------------------------------------- **p的值為多少？ **p=*(*(p))=*(*(2003H))=*(3000H)=0300H。 那麼&&p、*(&p)和&(*p)又等於多少？ &&p=&(&(p))=&(3001H)，此時出錯了，3001H 是個常數怎麼可能有地址呢？ *&p=*(&(p))=*(3001H)=2003H，也就是*&p=p。 &*p=&(*(p))=&(3000H)，讀者可能以為&*p=p 此時出錯了，3000H 是個常數怎麼可能有地址呢？
編輯本段另類*和&
兩個地方要注意： 在程序聲明變數的時候的*，只是表明「它是一個整數，這個整數指向某個內存地址，一次訪問sizeof(type)長度」。這點不要和(*)操作符混淆； 在C++程序聲明變數的時候的&，只是表明「它是一個引用，這個引用聲明時不開辟新空間，它在內存分配表加入新的一行，該行內存地址等於和調用時傳入的對應參數內存地址」。 這點不要和(*)聲明符，(&)操作符混淆。 清華大學軟體學院免試研究生面試就有問過這個問題。
編輯本段雙重指針
雙重指針又是怎麼一回事兒呢？綜合2 的BTree 定義，和3 的說法。對於一棵樹，我們通常用它的根節點地址來表示這棵樹。這就是「擒賊先擒王」。找到了樹的根，其每個節點都可以找到。 但是有時候我們需要對樹進行刪除節點，增加節點操作，往往考慮到刪除根節點，增加的節點取代原來的根節點作為新根節點的情況。為了修改根節點這個「整數」，我們需要退一步，使用這個「整數」的內存地址，也就是指向這個「整數」的指針。在聲明時，我們用2 個*號，聲明指向指針的指針。它的意思是「它是一個整數，這個整數指向某個內存地址，一次訪問sizeof(int)長度，其值是一個整數，那個整數值指向某個內存地址，一次訪問sizeof(BTree)長度。」。詳見<數據結構>有關「樹」的程序代碼。
編輯本段指針數組、數組指針和指向函數的指針
指針數組：就是一個由指針組成的數組，那個數組的各個元素都是指針，指向某個內存地址。 數組指針：數組名本身就是一個指針，指向數組的首地址。注意這是一個常數。 指向函數的指針：從二進制角度考慮，數組名是該數組數據段首地址，函數名就是該代碼段的首地址，可以用「int *fun()」。在二進制層面，代碼段和數據段什麼區別？沒什麼區別。 ---------------------------------------------------- #include <stdio.h> void inc(int *val) { (*val)++; } main() { void (*fun)(int *); int a=3; fun=inc; (*fun)(&a); printf("%d" , a); } ----------------------------------------------------
編輯本段指針的作用
指針可以用來有效地表示復雜的數據結構,可以用於函數參數傳遞並達到更加靈活使用函數的目的.使C語言程序的設計具有靈活、實用、高效的特點。
編輯本段指針網
一個專門用於圖書搜索的網站,指針圖書網。自稱全球最大中文圖書檢索網站。
編輯本段鍾表的指針
在日常生活中指針是儀器或鍾表上的，可動的，一般狹長的，往往在一段尖的用來指示測量的數據的裝置。
編輯本段指針法
指針是以手指按壓或爪切某些穴位，代替針刺治病的一種治療方法，具有疏通經絡、行氣活血、調和臟腑功能、開竅醒神、止痛等作用。常用於突發性病症，如虛脫、中暑、癔病及多種痛症。亦可用於一些內傷外感雜病的治療。
操作方法
指針的基本手法可分為揉、捫、切、捏、點5種。 1. 揉法：是用手指的尖端，輕按選下的穴位，作環形平揉的一種方法。揉動時手指的尖端不能離開所接觸的皮膚，手指連同皮膚及皮下組織，以穴位為中心，作一小圓形轉動，不要使手指與皮膚呈摩擦狀態。每次揉一小圓周為1次，每穴位一般以120～180次為標准,約2～3分鍾。次數的多少亦可視病情的輕重而定。常用拇拽和中指作揉法。本法在指針中應用較廣。施術時需要根據病人質強弱和病情輕重施以輕重不同的指力。本法可與捫法配合應用。 2. 捫法：是用手指捫按腧穴或身體一定部位的手法。將手指端深深按壓皮膚及皮下組織深部，同時根據病人體質強弱，施以輕重不同的指力，以感到酸麻脹痛為止。當指端按入時，應逐漸減輕指力，最後停止。每穴一般捫按3分鍾左右。捫法又分為單指法和雙指法2種。 （1）單指法：一般用拇指或中指指端按壓在穴位上。此法常用於胸腹部和四肢部的穴位，如氣海CV （RN）6 ，中脘CV （RN）12，曲池LI11 、足三里ST36等（見圖） （2）雙指法：即兩手指同時捫按兩個穴位。此法常用於頭面、頸項、腹部、背腹部的穴位，如風池GB20 、陽白GB14 、天樞ST25 等穴位。（見圖） 3. 切法：用拇指指甲切按腧穴。操作時可用脫脂棉少許，覆於指甲 ，防止切傷皮膚。指切時用力需要輕而緩慢，特別是壓痛處更應注意，盡量避免切處劇烈疼痛。本法多用於狹窄部位的穴位，如人中GV （DU）26 、迎香LI20 、少商LU11 等（見圖）。 4. 捏法：是用兩個手指對稱捏壓穴位的手法，可用拇、食二指，也可用拇、中二指或拇指與其它各指，在上下方或左

8. 什麼是指針

它裡面存儲的數值被解釋成為內存里的一個地址。要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針

所指向的類型，指針的值或者叫指針所指向的內存區，還有指針本身所佔據的內存區。讓我們分別說明。

先聲明幾個指針放著做例子：

例一：

(1)int *ptr;

(2)char *ptr;

(3)int **ptr;

(4)int (*ptr)[3];

(5)int *(*ptr)[4];

如果看不懂後幾個例子的話，請參閱我前段時間貼出的文章 < <如何理解c和c++的復雜類型聲明>>。

1。 指針的類型。

從語法的角度看，你只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個指針的類型。這是指針本身所具有的類型。讓我們看看例一

中各個指針的類型：

(1)int *ptr; //指針的類型是int *

(2)char *ptr; //指針的類型是char *

(3)int **ptr; //指針的類型是 int **

(4)int (*ptr)[3]; //指針的類型是 int(*)[3]

(5)int *(*ptr)[4]; //指針的類型是 int *(*)[4]

怎麼樣？找出指針的類型的方法是不是很簡單？

2。指針所指向的類型。

當你通過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯器將把那片內存區里的內容當做什麼來看待。

從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符*去掉，剩下的就是指針所指向的類型。例如：

(1)int *ptr; //指針所指向的類型是int

(2)char *ptr; //指針所指向的的類型是char

(3)int **ptr; //指針所指向的的類型是 int *

(4)int (*ptr)[3]; //指針所指向的的類型是 int()[3]

(5)int *(*ptr)[4]; //指針所指向的的類型是 int *()[4]

在指針的算術運算中，指針所指向的類型有很大的作用。

指針的類型(即指針本身的類型)和指針所指向的類型是兩個概念。當你對C越來越熟悉時，你會發現，把與指針攪和在一起的「類型」這個概念

分成「指針的類型」和「指針所指向的類型」兩個概念，是精通指針的關鍵點之一。我看了不少書，發現有些寫得差的書中，就把指針的這兩

個概念攪在一起了，所以看起書來前後矛盾，越看越糊塗。

3。 指針的值，或者叫指針所指向的內存區或地址。

指針的值是指針本身存儲的數值，這個值將被編譯器當作一個地址，而不是一個一般的數值。在32位程序里，所有類型的指針的值都是一個32

位整數，因為32位程序里內存地址全都是32位長。

指針所指向的內存區就是從指針的值所代表的那個內存地址開始，長度為sizeof(指針所指向的類型)的一片內存區。以後，我們說一個指針的

值是XX，就相當於說該指針指向了以XX為首地址的一片內存區域；我們說一個指針指向了某塊內存區域，就相當於說該指針的值是這塊內存區

域的首地址。

指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在例一中，指針所指向的類型已經有了，但由於指針還未初始化，所以它所

指向的內存區是不存在的，或者說是無意義的。

以後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指向的類型是什麼？該指針指向了哪裡？

4。 指針本身所佔據的內存區。

指針本身佔了多大的內存？你只要用函數sizeof(指針的類型)測一下就知道了。在32位平台里，指針本身占據了4個位元組的長度。

指針本身占據的內存這個概念在判斷一個指針表達式是否是左值時很有用。

第二章。指針的算術運算

指針可以加上或減去一個整數。指針的這種運算的意義和通常的數值的加減運算的意義是不一樣的。例如：

例二：

1。 char a[20];

2。 int *ptr=a;

...

...

3。 ptr++;

在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變數a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理

的：它把指針ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由於地址是用位元組做單位的，故ptr所指向的地址由原來的變數a的地

址向高地址方向增加了4個位元組。

由於char類型的長度是一個位元組，所以，原來ptr是指向數組a的第0號單元開始的四個位元組，此時指向了數組a中從第4號單元開始的四個位元組。

我們可以用一個指針和一個循環來遍歷一個數組，看例子：

例三：

int array[20];

int *ptr=array;

...

//此處略去為整型數組賦值的代碼。

...

for(i=0;i <20;i++)

{

(*ptr)++;

ptr++；

}

這個例子將整型數組中各個單元的值加1。由於每次循環都將指針ptr加1，所以每次循環都能訪問數組的下一個單元。再看例子：

例四：

1。 char a[20];

2。 int *ptr=a;

...

...

3。 ptr+=5;

在這個例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由於地址的單

位是位元組，故現在的ptr所指向的地址比起加5後的ptr所指向的地址來說，向高地址方向移動了20個位元組。在這個例子中，沒加5前的ptr指向數

組a的第0號單元開始的四個位元組，加5後，ptr已經指向了數組a的合法范圍之外了。雖然這種情況在應用上會出問題，但在語法上卻是可以的。

這也體現出了指針的靈活性。

如果上例中，ptr是被減去5，那麼處理過程大同小異，只不過ptr的值是被減去5乘sizeof(int)，新的ptr指向的地址將比原來的 ptr所指向的地

址向低地址方向移動了20個位元組。

總結一下，一個指針ptrold加上一個整數n後，結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold

所指向的類型也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個位元組。就是說，ptrnew所指向的內存區將比ptrold

所指向的內存區向高地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。一個指針ptrold減去一個整數n後，結果是一個新的指針ptrnew

，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值減少了n乘sizeof

(ptrold所指向的類型)個位元組，就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向低地址方向移動了n乘 sizeof(ptrold所指向的類

型)個位元組。

第三章。運算符&和*

這里&是取地址運算符，*是...書上叫做「間接運算符」。&a的運算結果是一個指針，指針的類型是a的類型加個*，指針所指向的類型是a的類

型，指針所指向的地址嘛，那就是a的地址。*p的運算結果就五花八門了。總之*p的結果是p所指向的東西，這個東西有這些特點：它的類型是p

指向的類型，它所佔用的地址是p所指向的地址。

例五：

int a=12;

int b;

int *p;

int **ptr;

p=&a;//&a的結果是一個指針，類型是int*，指向的類型是int，指向的地址是a的地址。

*p=24;//*p的結果，在這里它的類型是int，它所佔用的地址是p所指向的地址，顯然，*p就是變數a。

ptr=&p;//&p的結果是個指針，該指針的類型是p的類型加個*，在這里是int**。該指針所指向的類型是p的類型，這里是int*。該指針所指向的

地址就是指針p自己的地址。

*ptr=&b;//*ptr是個指針，&b的結果也是個指針，且這兩個指針的類型和所指向的類型是一樣的，所以?amp;b來給*ptr賦值就是毫無問題的了

。

**ptr=34;//*ptr的結果是ptr所指向的東西，在這里是一個指針，對這個指針再做一次*運算，結果就是一個int類型的變數。

第四章。指針表達式。

一個表達式的最後結果如果是一個指針，那麼這個表達式就叫指針表達式。下面是一些指針表達式的例子：

例六：

int a,b;

int array[10];

int *pa;

pa=&a;//&a是一個指針表達式。

int **ptr=&pa;//&pa也是一個指針表達式。

*ptr=&b;//*ptr和&b都是指針表達式。

pa=array;

pa++;//這也是指針表達式。

例七：

char *arr[20];

char **parr=arr;//如果把arr看作指針的話，arr也是指針表達式

char *str;

str=*parr;//*parr是指針表達式

str=*(parr+1);//*(parr+1)是指針表達式

str=*(parr+2);//*(parr+2)是指針表達式

由於指針表達式的結果是一個指針，所以指針表達式也具有指針所具有的四個要素：指針的類型，指針所指向的類型，指針指向的內存區，指

針自身占據的內存。

好了，當一個指針表達式的結果指針已經明確地具有了指針自身占據的內存的話，這個指針表達式就是一個左值，否則就不是一個左值。 在例

七中，&a不是一個左值，因為它還沒有占據明確的內存。*ptr是一個左值，因為*ptr這個指針已經占據了內存，其實*ptr就是指針 pa，既然pa

已經在內存中有了自己的位置，那麼*ptr當然也有了自己的位置。

第五章。數組和指針的關系

如果對聲明數組的語句不太明白的話，請參閱我前段時間貼出的文章 < <如何理解c和c++的復雜類型聲明>>。 數組的數組名其實可以看作一個

指針。看下例：

例八：

int array[10]=,value;

...

...

value=array[0];//也可寫成：value=*array;

value=array[3];//也可寫成：value=*(array+3);

value=array[4];//也可寫成：value=*(array+4);

上例中，一般而言數組名array代表數組本身，類型是int [10]，但如果把array看做指針的話，它指向數組的第0個單元，類型是int *，所指

向的類型是數組單元的類型即int。因此*array等於0就一點也不奇怪了。同理，array+3是一個指向數組第3個單元的指針，所以* (array+3)等

於3。其它依此類推。

例九：

char *str[3]={

"Hello,this is a sample!",

"Hi,good morning.",

"Hello world"

};

char s[80]；

strcpy(s,str[0]);//也可寫成strcpy(s,*str);

strcpy(s,str[1]);//也可寫成strcpy(s,*(str+1));

strcpy(s,str[2]);//也可寫成strcpy(s,*(str+2));

上例中，str是一個三單元的數組，該數組的每個單元都是一個指針，這些指針各指向一個字元串。把指針數組名str當作一個指針的話，它指

向數組的第0號單元，它的類型是char**，它指向的類型是char *。

*str也是一個指針，它的類型是char*，它所指向的類型是char，它指向的地址是字元串"Hello,this is a sample!"的第一個字元的地址，

即'H'的地址。 str+1也是一個指針，它指向數組的第1號單元，它的類型是char**，它指向的類型是char *。

*(str+1)也是一個指針，它的類型是char*，它所指向的類型是char，它指向"Hi,good morning."的第一個字元'H'，等等。

下面總結一下數組的數組名的問題。聲明了一個數組TYPE array[n]，則數組名稱array就有了兩重含義：第一，它代表整個數組，它的類型是

TYPE [n]；第二，它是一個指針，該指針的類型是TYPE*，該指針指向的類型是TYPE，也就是數組單元的類型，該指針指向的內存區就是數組第

0號單元，該指針自己佔有單獨的內存區，注意它和數組第0號單元占據的內存區是不同的。該指針的值是不能修改的，即類似array++的表達式

是錯誤的。

在不同的表達式中數組名array可以扮演不同的角色。

在表達式sizeof(array)中，數組名array代表數組本身，故這時sizeof函數測出的是整個數組的大小。

在表達式*array中，array扮演的是指針，因此這個表達式的結果就是數組第0號單元的值。sizeof(*array)測出的是數組單元的大小。

表達式array+n（其中n=0，1，2，....。）中，array扮演的是指針，故array+n的結果是一個指針，它的類型是TYPE*，它指向的類型是TYPE，

它指向數組第n號單元。故sizeof(array+n)測出的是指針類型的大小。

例十：

int array[10];

int (*ptr)[10];

ptr=&array;

上例中ptr是一個指針，它的類型是int (*)[10]，他指向的類型是int [10]，我們用整個數組的首地址來初始化它。在語句ptr=&array中，

array代表數組本身。

本節中提到了函數sizeof()，那麼我來問一問，sizeof(指針名稱)測出的究竟是指針自身類型的大小呢還是指針所指向的類型的大小？答案是

前者。例如：

int (*ptr)[10];

則在32位程序中，有：

sizeof(int(*)[10])==4

sizeof(int [10])==40

sizeof(ptr)==4

實際上，sizeof(對象)測出的都是對象自身的類型的大小，而不是別的什麼類型的大小。

第六章。指針和結構類型的關系

可以聲明一個指向結構類型對象的指針。

例十一：

struct MyStruct

{

int a;

int b;

int c;

}

MyStruct ss=;//聲明了結構對象ss，並把ss的三個成員初始化為20，30和40。

MyStruct *ptr=&ss;//聲明了一個指向結構對象ss的指針。它的類型是

MyStruct*,它指向的類型是MyStruct。

int *pstr=(int*)&ss;//聲明了一個指向結構對象ss的指針。但是它的類型和它指向的類型和ptr是不同的。

請問怎樣通過指針ptr來訪問ss的三個成員變數？

答案：

ptr->a;

ptr->b;

ptr->c;

又請問怎樣通過指針pstr來訪問ss的三個成員變數？

答案：

*pstr；//訪問了ss的成員a。

*(pstr+1);//訪問了ss的成員b。

*(pstr+2)//訪問了ss的成員c。

呵呵，雖然我在我的MSVC++6.0上調式過上述代碼，但是要知道，這樣使用pstr來訪問結構成員是不正規的，為了說明為什麼不正規，讓我們看

看怎樣通過指針來訪問數組的各個單元：

例十二：

int array[3]=;

int *pa=array;

通過指針pa訪問數組array的三個單元的方法是：

*pa;//訪問了第0號單元

*(pa+1);//訪問了第1號單元

*(pa+2);//訪問了第2號單元

從格式上看倒是與通過指針訪問結構成員的不正規方法的格式一樣。

所有的C/C++編譯器在排列數組的單元時，總是把各個數組單元存放在連續的存儲區里，單元和單元之間沒有空隙。但在存放結構對象的各個成

員時，在某種編譯環境下，可能會需要字對齊或雙字對齊或者是別的什麼對齊，需要在相鄰兩個成員之間加若干個「填充位元組」，這就導致各

個成員之間可能會有若干個位元組的空隙。

所以，在例十二中，即使*pstr訪問到了結構對象ss的第一個成員變數a，也不能保證*(pstr+1)就一定能訪問到結構成員b。因為成員a和成員b

之間可能會有若干填充位元組，說不定*(pstr+1)就正好訪問到了這些填充位元組呢。這也證明了指針的靈活性。要是你的目的就是想看看各個結構

成員之間到底有沒有填充位元組，嘿，這倒是個不錯的方法。

通過指針訪問結構成員的正確方法應該是象例十二中使用指針ptr的方法。

第七章。指針和函數的關系

可以把一個指針聲明成為一個指向函數的指針。

int fun1(char*,int);

int (*pfun1)(char*,int);

pfun1=fun1;

....

....

int a=(*pfun1)("abcdefg",7);//通過函數指針調用函數。

可以把指針作為函數的形參。在函數調用語句中，可以用指針表達式來作為實參。
例十三：

int fun(char*);

int a;

char str[]="abcdefghijklmn";

a=fun(str);

...

...

int fun(char*s)

{

int num=0;

for(int i=0;i <strlen(s);i++)

{

num+=*s;s++;

}

return num;

}

這個例子中的函數fun統計一個字元串中各個字元的ASCII碼值之和。前面說了，數組的名字也是一個指針。在函數調用中，當把str作為實參傳

遞給形參s後，實際是把str的值傳遞給了s，s所指向的地址就和str所指向的地址一致，但是str和s各自佔用各自的存儲空間。在函數體內對s

進行自加1運算，並不意味著同時對str進行了自加1運算。

第八章。指針類型轉換

當我們初始化一個指針或給一個指針賦值時，賦值號的左邊是一個指針，賦值號的右邊是一個指針表達式。在我們前面所舉的例子中，絕大多

數情況下，指針的類型和指針表達式的類型是一樣的，指針所指向的類型和指針表達式所指向的類型是一樣的。

例十四：

1。 float f=12.3;

2。 float *fptr=&f;

3。 int *p;

在上面的例子中，假如我們想讓指針p指向實數f，應該怎麼搞？是用下面的語句嗎？

p=&f;

不對。因為指針p的類型是int*，它指向的類型是int。表達式&f的結果是一個指針，指針的類型是float*,它指向的類型是 float。兩者不一致

，直接賦值的方法是不行的。至少在我的MSVC++6.0上，對指針的賦值語句要求賦值號兩邊的類型一致，所指向的類型也一致，其它的編譯器上

我沒試過，大家可以試試。為了實現我們的目的，需要進行「強制類型轉換」：

p=(int*)&f;

如果有一個指針p，我們需要把它的類型和所指向的類型改為TYEP*和TYPE，那麼語法格式是：

(TYPE*)p；

這樣強制類型轉換的結果是一個新指針，該新指針的類型是TYPE*，它指向的類型是TYPE，它指向的地址就是原指針指向的地址。而原來的指針

p的一切屬性都沒有被修改。

一個函數如果使用了指針作為形參，那麼在函數調用語句的實參和形參的結合過程中，也會發生指針類型的轉換。

例十五：

void fun(char*);

int a=125,b;

fun((char*)&a);

...

...

void fun(char*s)

{

char c;

c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;

c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;

}

注意這是一個32位程序，故int類型佔了四個位元組，char類型佔一個位元組。函數fun的作用是把一個整數的四個位元組的順序來個顛倒。注意到了

嗎？在函數調用語句中，實?amp;a的結果是一個指針，它的類型是int *，它指向的類型是int。形參這個指針的類型是char*，它指向的類型是

char。這樣，在實參和形參的結合過程中，我們必須進行一次從int*類型到char*類型的轉換。結合這個例子，我們可以這樣來想像編譯器進行

轉換的過程：編譯器先構造一個臨時指針 char*temp，然後執行temp=(char*)&a，最後再把temp的值傳遞給s。所以最後的結果是：s的類型是

char*,它指向的類型是char，它指向的地址就是a的首地址。

我們已經知道，指針的值就是指針指向的地址，在32位程序中，指針的值其實是一個32位整數。那可不可以把一個整數當作指針的值直接賦給

指針呢？就象下面的語句：

unsigned int a;

TYPE *ptr;//TYPE是int，char或結構類型等等類型。

...

...

a=20345686;

ptr=20345686;//我們的目的是要使指針ptr指向地址20345686（十進制）

ptr=a;//我們的目的是要使指針ptr指向地址20345686（十進制）

編譯一下吧。結果發現後面兩條語句全是錯的。那麼我們的目的就不能達到了嗎？不，還有辦法：

unsigned int a;

TYPE *ptr;//TYPE是int，char或結構類型等等類型。

...

...

a=某個數，這個數必須代表一個合法的地址；

ptr=(TYPE*)a；//呵呵，這就可以了。

嚴格說來這里的(TYPE*)和指針類型轉換中的(TYPE*)還不一樣。這里的(TYPE*)的意思是把無符號整數a的值當作一個地址來看待。

上面強調了a的值必須代表一個合法的地址，否則的話，在你使用ptr的時候，就會出現非法操作錯誤。

想想能不能反過來，把指針指向的地址即指針的值當作一個整數取出來。完全可以。下面的例子演示了把一個指針的值當作一個整數取出來，

然後再把這個整數當作一個地址賦給一個指針：

例十六：

int a=123,b;

int *ptr=&a;

char *str;

b=(int)ptr;//把指針ptr的值當作一個整數取出來。

str=(char*)b;//把這個整數的值當作一個地址賦給指針str。

好了，現在我們已經知道了，可以把指針的值當作一個整數取出來，也可以把一個整數值當作地址賦給一個指針。

第九章。指針的安全問題

看下面的例子：

例十七：

char s='a';

int *ptr;

ptr=(int*)&s;

*ptr=1298；

指針ptr是一個int*類型的指針，它指向的類型是int。它指向的地址就是s的首地址。在32位程序中，s佔一個位元組，int類型佔四個位元組。最後

一條語句不但改變了s所佔的一個位元組，還把和s相臨的高地址方向的三個位元組也改變了。這三個位元組是干什麼的？只有編譯程序知道，而寫程

序的人是不太可能知道的。也許這三個位元組里存儲了非常重要的數據，也許這三個位元組里正好是程序的一條代碼，而由於你對指針的馬虎應用

，這三個位元組的值被改變了！這會造成崩潰性的錯誤。讓我們再來看一例：

例十八：

1。 char a;

2。 int *ptr=&a;

...

...

3。 ptr++;

4。 *ptr=115;

該例子完全可以通過編譯，並能執行。但是看到沒有？第3句對指針ptr進行自加1運算後，ptr指向了和整形變數a相鄰的高地址方向的一塊存儲

區。這塊存儲區里是什麼？我們不知道。有可能它是一個非常重要的數據，甚至可能是一條代碼。而第4句竟然往這片存儲區里寫入一個數據！

這是嚴重的錯誤。所以在使用指針時，程序員心裡必須非常清楚：我的指針究竟指向了哪裡。

在用指針訪問數組的時候，也要注意不要超出數組的低端和高端界限，否則也會造成類似的錯誤。

在指針的強制類型轉換：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的類型)大於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的

存儲區時是安全的。如果sizeof(ptr2的類型)小於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是不安全的。至於

為什麼，讀者結合例十七來想一想，應該會明白的。

請寫出以下程序的運行結果：

#include <stdio.h>
int *p;
pp(int a,int *b);
main()
{
int a=1,b=2,c=3;
p=&b;
pp(a+c,&b);
printf("(1)%d%d%dn",a,b,*p);
}
pp(int a,int *b)
{int c=4;
*p=*b+c;
a=*p-c;
printf("(2)%d%d%dn",a,*b,*p);
}
另外,站長團上有產品團購,便宜有保證

9. 什麼是指針

指針是一個特殊的變數，它裡面存儲的數值被解釋成為內存里的一個地址。 要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針所指向的 類型，指針的值或者叫指針所指向的內存區，還有指針本身所佔據的內存區。讓我們分別說明。
先聲明幾個指針放著做例子：
例一：

(1)int*ptr;

(2)char*ptr;

(3)int**ptr;

(4)int(*ptr)[3];

(5)int*(*ptr)[4];

如果看不懂後幾個例子的話，請參閱我前段時間貼出的文章<<如何理解c和c ++的復雜類型聲明>>。

指針的類型
從語法的角度看，你只要把指針聲明語句里的指針名字去掉，剩下的部分就是這個指針的類型。這是指針本身所具有的類型。讓我們看看例一中各個指針的類型：

(1)int*ptr;//指針的類型是int*

(2)char*ptr;//指針的類型是char*

(3)int**ptr;//指針的類型是int**

(4)int(*ptr)[3];//指針的類型是int(*)[3]

(5)int*(*ptr)[4];//指針的類型是int*(*)[4]

怎麼樣？找出指針的類型的方法是不是很簡單？

指針所指向的類型

當你通過指針來訪問指針所指向的內存區時，指針所指向的類型決定了編譯器將把那片內存區里的內容當做什麼來看待。

從語法上看，你只須把指針聲明語句中的指針名字和名字左邊的指針聲明符*去掉，剩下的就是指針所指向的類型。例如：

(1)int*ptr;//指針所指向的類型是int

(2)char*ptr;//指針所指向的的類型是char

(3)int**ptr;//指針所指向的的類型是int*

(4)int(*ptr)[3];//指針所指向的的類型是int()[3]

(5)int*(*ptr)[4];//指針所指向的的類型是int*()[4]

在指針的算術運算中，指針所指向的類型有很大的作用。

指針的類型(即指針本身的類型)和指針所指向的類型是兩個概念。當你對C越來越熟悉時，你會發現，把與指針攪和在一起的"類型"這個概念分成"指針的類型"和"指針所指向的類型"兩個概念，是精通指針的關鍵點之一。我看了不少書，發現有些寫得差的書中，就把指針的這兩個概念攪在一起了，所以看起書來前後矛盾，越看越糊塗。

指針的值，或者叫指針所指向的內存區或地址

指針的值是指針本身存儲的數值，這個值將被編譯器當作一個地址，而不是一個一般的數值。在32位程序里，所有類型的指針的值都是一個32位整數，因為32位程序里內存地址全都是32位長。 指針所指向的內存區就是從指針的值所代表的那個內存地址開始，長度為si zeof(指針所指向的類型)的一片內存區。以後，我們說一個指針的值是XX，就相當於說該指針指向了以XX為首地址的一片內存區域；我們說一個指針指向了某塊內存區域，就相當於說該指針的值是這塊內存區域的首地址。

指針所指向的內存區和指針所指向的類型是兩個完全不同的概念。在例一中，指針所指向的類型已經有了，但由於指針還未初始化，所以它所指向的內存區是不存在的，或者說是無意義的。

以後，每遇到一個指針，都應該問問：這個指針的類型是什麼？指針指的類型是什麼？該指針指向了哪裡？

指針本身所佔據的內存區

指針本身佔了多大的內存？你只要用函數sizeof(指針的類型)測一下就知道了。在32位平台里，指針本身占據了4個位元組的長度。

指針本身占據的內存這個概念在判斷一個指針表達式是否是左值時很有用。

指針的算術運算

指針可以加上或減去一個整數。指針的這種運算的意義和通常的數值的加減運算的意義是不一樣的。例如：

例二：

1、chara[20];

2、int*ptr=a;

...

...

3、ptr++;

在上例中，指針ptr的類型是int*,它指向的類型是int，它被初始化為指向整形變數a。接下來的第3句中，指針ptr被加了1，編譯器是這樣處理的：它把指針ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由於地址是用位元組做單位的，故ptr所指向的地址由原來的變數a的地址向高地址方向增加了4個位元組。

由於char類型的長度是一個位元組，所以，原來ptr是指向數組a的第0號單元開始的四個位元組，此時指向了數組a中從第4號單元開始的四個位元組。

我們可以用一個指針和一個循環來遍歷一個數組，看例子：

例三：

intarray[20];
int*ptr=array;
...
//此處略去為整型數組賦值的代碼。
...
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++；
}

這個例子將整型數組中各個單元的值加1。由於每次循環都將指針ptr加1，所以每次循環都能訪問數組的下一個單元。

再看例子：

例四：

1、chara[20];

2、int*ptr=a;

...

...

3、ptr+=5;

在這個例子中，ptr被加上了5，編譯器是這樣處理的：將指針ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由於地址的單位是位元組，故現在的ptr所指向的地址比起加5後的ptr所指向的地址來說，向高地址方向移動了20個位元組。在這個例子中，沒加5前的ptr指向數組a的第0號單元開始的四個位元組，加5後，ptr已經指向了數組a的合法范圍之外了。雖然這種情況在應用上會出問題，但在語法上卻是可以的。這也體現出了指針的靈活性。

如果上例中，ptr是被減去5，那麼處理過程大同小異，只不過ptr的值是被減去5乘sizeof(int)，新的ptr指向的地址將比原來的ptr所指向的地址向低地址方向移動了20個位元組。

總結一下，一個指針ptrold加上一個整數n後，結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值增加了n乘sizeof(ptrold所指向的類型)個位元組。就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向高地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。

一個指針ptrold減去一個整數n後，結果是一個新的指針ptrnew，ptrnew的類型和ptrold的類型相同，ptrnew所指向的類型和ptrold所指向的類型也相同。ptrnew的值將比ptrold的值減少了n乘sizeof(ptrold所指向的類型)個位元組，就是說，ptrnew所指向的內存區將比ptrold所指向的內存區向低地址方向移動了n乘sizeof(ptrold所指向的類型)個位元組。

運算符&和*

這里&是取地址運算符，*是...書上叫做"間接運算符"。

&a的運算結果是一個指針，指針的類型是a的類型加個*，指針所指向的類型是a的類型，指針所指向的地址嘛，那就是a的地址。

*p的運算結果就五花八門了。總之*p的結果是p所指向的東西，這個東西有這些特點：它的類型是p指向的類型，它所佔用的地址是p所指向的地址。

例五：

inta=12;
intb;
int*p;
int**ptr;
p=&a;
//&a的結果是一個指針，類型是int*，指向的類型是int，指向的地址是a的地址。
*p=24;
//*p的結果，在這里它的類型是int，它所佔用的地址是p所指向的地址，顯然，*p就是變數a。
ptr=&p;
//&p的結果是個指針，該指針的類型是p的類型加個*，在這里是int **。該指針所指向的類型是p的類型，這里是int*。該指針所指向的地址就是指針p自己的地址。
*ptr=&b;
//*ptr是個指針，&b的結果也是個指針，且這兩個指針的類型和所指向的類型是一樣的，所以用&b來給*ptr賦值就是毫無問題的了。
**ptr=34;
//*ptr的結果是ptr所指向的東西，在這里是一個指針，對這個指針再做一次*運算，結果就是一個int類型的變數。

指針表達式

一個表達式的最後結果如果是一個指針，那麼這個表達式就叫指針表式。

下面是一些指針表達式的例子：

例六：

inta,b;
intarray[10];
int*pa;
pa=&a;//&a是一個指針表達式。
int**ptr=&pa;//&pa也是一個指針表達式。
*ptr=&b;//*ptr和&b都是指針表達式。
pa=array;
pa++;//這也是指針表達式。

例七：

char*arr[20];
char**parr=arr;//如果把arr看作指針的話，arr也是指針表達式
char*str;
str=*parr;//*parr是指針表達式
str=*(parr+1);//*(parr+1)是指針表達式
str=*(parr+2);//*(parr+2)是指針表達式

由於指針表達式的結果是一個指針，所以指針表達式也具有指針所具有的四個要素：指針的類型，指針所指向的類型，指針指向的內存區，指針自身占據的內存。

好了，當一個指針表達式的結果指針已經明確地具有了指針自身占據的內存的話，這個指針表達式就是一個左值，否則就不是一個左值。

在例七中，&a不是一個左值，因為它還沒有占據明確的內存。*ptr是一個左值，因為*ptr這個指針已經占據了內存，其實*ptr就是指針pa，既然pa已經在內存中有了自己的位置，那麼*ptr當然也有了自己的位置。

數組和指針的關系

如果對聲明數組的語句不太明白的話，請參閱我前段時間貼出的文章<<如何理解c和c++的復雜類型聲明>>。

數組的數組名其實可以看作一個指針。看下例：

例八：

intarray[10]=,value;
...
...
value=array[0];//也可寫成：value=*array;
value=array[3];//也可寫成：value=*(array+3);
value=array[4];//也可寫成：value=*(array+4);

上例中，一般而言數組名array代表數組本身，類型是int[10]，但如果把array看做指針的話，它指向數組的第0個單元，類型是int*，所指向的類型是數組單元的類型即int。因此*array等於0就一點也不奇怪了。同理，array+3是一個指向數組第3個單元的指針，所以*(array+3)等於3。其它依此類推。

例九：

char*str[3]={
"Hello,thisisasample!",
"Hi,goodmorning.",
"Helloworld"
};
chars[80]；
strcpy(s,str[0]);//也可寫成strcpy(s,*str);
strcpy(s,str[1]);//也可寫成strcpy(s,*(str+1));
strcpy(s,str[2]);//也可寫成strcpy(s,*(str+2));

上例中，str是一個三單元的數組，該數組的每個單元都是一個指針，這些指針各指向一個字元串。把指針數組名str當作一個指針的話，它指向數組的第0號單元，它的類型是char**，它指向的類型是char*。

*str也是一個指針，它的類型是char*，它所指向的類型是char，它指向的地址是字元串"Hello,thisisasample!"的第一個字元的地址，即'H'的地址。 str+1也是一個指針，它指向數組的第1號單元，它的類型是char**，它指向的類型是char*。

*(str+1)也是一個指針，它的類型是char*，它所指向的類型是char，它指向 "Hi,goodmorning."的第一個字元'H'，等等。

下面總結一下數組的數組名的問題。聲明了一個數組TYPEarray[n]，則數組名稱array就有了兩重含義：第一，它代表整個數組，它的類型是TYPE[n]；第二 ，它是一個指針，該指針的類型是TYPE*，該指針指向的類型是TYPE，也就是數組單元的類型，該指針指向的內存區就是數組第0號單元，該指針自己佔有單獨的內存區，注意它和數組第0號單元占據的內存區是不同的。該指針的值是不能修改的，即類似array++的表達式是錯誤的。

在不同的表達式中數組名array可以扮演不同的角色。

在表達式sizeof(array)中，數組名array代表數組本身，故這時sizeof函數測出的是整個數組的大小。

在表達式*array中，array扮演的是指針，因此這個表達式的結果就是數組第0號單元的值。sizeof(*array)測出的是數組單元的大小。

表達式array+n（其中n=0，1，2，....。）中，array扮演的是指針，故array+n的結果是一個指針，它的類型是TYPE*，它指向的類型是TYPE，它指向數組第n號單元。故sizeof(array+n)測出的是指針類型的大小。

例十：

intarray[10];
int(*ptr)[10];
ptr=&array;

上例中ptr是一個指針，它的類型是int(*)[10]，他指向的類型是int[10] ，我們用整個數組的首地址來初始化它。在語句ptr=&array中，array代表數組本身。

本節中提到了函數sizeof()，那麼我來問一問，sizeof(指針名稱)測出的究竟是指針自身類型的大小呢還是指針所指向的類型的大小？答案是前者。例如：

int(*ptr)[10];

則在32位程序中，有：

sizeof(int(*)[10])==4
sizeof(int[10])==40
sizeof(ptr)==4

實際上，sizeof(對象)測出的都是對象自身的類型的大小，而不是別的什麼類型的大小。

指針和結構類型的關系

可以聲明一個指向結構類型對象的指針。

例十一：

structMyStruct
{
inta;
intb;
intc;
}
MyStructss=;
//聲明了結構對象ss，並把ss的三個成員初始化為20，30和40。
MyStruct*ptr=&ss;
//聲明了一個指向結構對象ss的指針。它的類型是MyStruct*,它指向的類型是MyStruct。
int*pstr=(int*)&ss;
//聲明了一個指向結構對象ss的指針。但是它的類型和它指向的類型和ptr是不同的。

請問怎樣通過指針ptr來訪問ss的三個成員變數？

答案：

ptr->a;

ptr->b;

ptr->c;

又請問怎樣通過指針pstr來訪問ss的三個成員變數？

答案：

*pstr；//訪問了ss的成員a。

*(pstr+1);//訪問了ss的成員b。

*(pstr+2)//訪問了ss的成員c。

雖然我在我的MSVC++6.0上調式過上述代碼，但是要知道，這樣使用pstr來訪問結構成員是不正規的，為了說明為什麼不正規，讓我們看看怎樣通過指針來訪問數組的各個單元：

例十二：

intarray[3]=;

int*pa=array;

通過指針pa訪問數組array的三個單元的方法是：

*pa;//訪問了第0號單元

*(pa+1);//訪問了第1號單元

*(pa+2);//訪問了第2號單元

從格式上看倒是與通過指針訪問結構成員的不正規方法的格式一樣。

所有的C/C++編譯器在排列數組的單元時，總是把各個數組單元存放在連續的存儲區里，單元和單元之間沒有空隙。但在存放結構對象的各個成員時，在某種編譯環境下，可能會需要字對齊或雙字對齊或者是別的什麼對齊，需要在相鄰兩個成員之間加若干個"填充位元組"，這就導致各個成員之間可能會有若干個位元組的空隙。

所以，在例十二中，即使*pstr訪問到了結構對象ss的第一個成員變數a，也不能保證*(pstr+1)就一定能訪問到結構成員b。因為成員a和成員b之間可能會有若干填充位元組，說不定*(pstr+1)就正好訪問到了這些填充位元組呢。這也證明了指針的靈活性。要是你的目的就是想看看各個結構成員之間到底有沒有填充位元組，嘿，這倒是個不錯的方法。

通過指針訪問結構成員的正確方法應該是象例十二中使用指針ptr的方法。

指針和函數的關系

可以把一個指針聲明成為一個指向函數的指針。

intfun1(char*,int);
int(*pfun1)(char*,int);
pfun1=fun1;
....
....
inta=(*pfun1)("abcdefg",7);//通過函數指針調用函數。

可以把指針作為函數的形參。在函數調用語句中，可以用指針表達式來作為實參。

例十三：

intfun(char*);
inta;
charstr[]="abcdefghijklmn";
a=fun(str);
...
...
intfun(char*s)
{
intnum=0;
for(inti=0;i{
num+=*s;s++;
}
returnnum;
}

這個例子中的函數fun統計一個字元串中各個字元的ASCII碼值之和。前面說了，數組的名字也是一個指針。在函數調用中，當把str作為實參傳遞給形參s後，實際是把str的值傳遞給了s，s所指向的地址就和str所指向的地址一致，但是str和s各自佔用各自的存儲空間。在函數體內對s進行自加1運算，並不意味著同時對str進行了自加1運算。

指針類型轉換

當我們初始化一個指針或給一個指針賦值時，賦值號的左邊是一個指針，賦值號的右邊是一個指針表達式。在我們前面所舉的例子中，絕大多數情況下，指針的類型和指針表達式的類型是一樣的，指針所指向的類型和指針表達式所指向的類型是一樣的。

例十四：

1、floatf=12.3;

2、float*fptr=&f;

3、int*p;

在上面的例子中，假如我們想讓指針p指向實數f，應該怎麼搞？是用下面的語句嗎？

p=&f;

不對。因為指針p的類型是int*，它指向的類型是int。表達式&f的結果是一個指針，指針的類型是float*,它指向的類型是float。兩者不一致，直接賦值的方法是不行的。至少在我的MSVC++6.0上，對指針的賦值語句要求賦值號兩邊的類型一致，所指向的類型也一致，其它的編譯器上我沒試過，大家可以試試。為了實現我們的目的，需要進行"強制類型轉換"：

p=(int*)&f;

如果有一個指針p，我們需要把它的類型和所指向的類型改為TYEP*TYPE， 那麼語法格式是：

(TYPE*)p；

這樣強制類型轉換的結果是一個新指針，該新指針的類型是TYPE*，它指向的類型是TYPE，它指向的地址就是原指針指向的地址。而原來的指針p的一切屬性都沒有被修改。

一個函數如果使用了指針作為形參，那麼在函數調用語句的實參和形參的結合過程中，也會發生指針類型的轉換。

例十五：

voidfun(char*);
inta=125,b;
fun((char*)&a);
...
...
voidfun(char*s)
{
charc;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}

注意這是一個32位程序，故int類型佔了四個位元組，char類型佔一個位元組。函數fun的作用是把一個整數的四個位元組的順序來個顛倒。注意到了嗎？在函數調用語句中，實參&a的結果是一個指針，它的類型是int*，它指向的類型是int。形參這個指針的類型是char*，它指向的類型是char。這樣，在實參和形參的結合過程中，我們必須進行一次從int*類型到char*類型的轉換。結合這個例子，我們可以這樣來想像編譯器進行轉換的過程：編譯器先構造一個臨時指針char*temp， 然後執行temp=(char*)&a，最後再把temp的值傳遞給s。所以最後的結果是：s的類型是char*,它指向的類型是char，它指向的地址就是a的首地址。

我們已經知道，指針的值就是指針指向的地址，在32位程序中，指針的值其實是一個32位整數。那可不可以把一個整數當作指針的值直接賦給指針呢？就象下面的語句：

unsignedinta;
TYPE*ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=20345686;
ptr=20345686;//我們的目的是要使指針ptr指向地址20345686（十進制
）
ptr=a;//我們的目的是要使指針ptr指向地址20345686（十進制）

編譯一下吧。結果發現後面兩條語句全是錯的。那麼我們的目的就不能達到了嗎？不，還有辦法：

unsignedinta;
TYPE*ptr;//TYPE是int，char或結構類型等等類型。
...
...
a=某個數，這個數必須代表一個合法的地址；
ptr=(TYPE*)a；//呵呵，這就可以了。

嚴格說來這里的(TYPE*)和指針類型轉換中的(TYPE*)還不一樣。這里的(TYPE*)的意思是把無符號整數a的值當作一個地址來看待。上面強調了a的值必須代表一個合法的地址，否則的話，在你使用ptr的時候，就會出現非法操作錯誤。

想想能不能反過來，把指針指向的地址即指針的值當作一個整數取出來。完 全可以。下面的例子演示了把一個指針的值當作一個整數取出來，然後再把這個整數當作一個地址賦給一個指針：

例十六：

inta=123,b;
int*ptr=&a;
char*str;
b=(int)ptr;//把指針ptr的值當作一個整數取出來。
str=(char*)b;//把這個整數的值當作一個地址賦給指針str。

現在我們已經知道了，可以把指針的值當作一個整數取出來，也可以把一個整數值當作地址賦給一個指針。

指針的安全問題

看下面的例子：

例十七：

chars='a';
int*ptr;
ptr=(int*)&s;
*ptr=1298；

指針ptr是一個int*類型的指針，它指向的類型是int。它指向的地址就是s的首地址。在32位程序中，s佔一個位元組，int類型佔四個位元組。最後一條語句不但改變了s所佔的一個位元組，還把和s相臨的高地址方向的三個位元組也改變了。這三個位元組是干什麼的？只有編譯程序知道，而寫程序的人是不太可能知道的。也許這三個位元組里存儲了非常重要的數據，也許這三個位元組里正好是程序的一條代碼，而由於你對指針的馬虎應用，這三個位元組的值被改變了！這會造成崩潰性的錯誤。

讓我們再來看一例：

例十八：

1、chara;

2、int*ptr=&a;

...

...

3、ptr++;

4、*ptr=115;

該例子完全可以通過編譯，並能執行。但是看到沒有？第3句對指針ptr進行自加1運算後，ptr指向了和整形變數a相鄰的高地址方向的一塊存儲區。這塊存儲區里是什麼？我們不知道。有可能它是一個非常重要的數據，甚至可能是一條代碼。而第4句竟然往這片存儲區里寫入一個數據！這是嚴重的錯誤。所以在使用指針時，程序員心裡必須非常清楚：我的指針究竟指向了哪裡。在用指針訪問數組的時候，也要注意不要超出數組的低端和高端界限，否則也會造成類似的錯誤。

在指針的強制類型轉換：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的類型)大於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是安全的。如果sizeof(ptr2的類型)小於sizeof(ptr1的類型)，那麼在使用指針ptr1來訪問ptr2所指向的存儲區時是不安全的。

©2008 Bai