開發程序員使用指針

㈠ c語言為什麼用指針

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

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

例一：

(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的結果也是個指針，且這兩個指針的類型和所指向的類型是一樣的，所以用
&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]={0,1,2,3,4,5,6,7,8,9},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={20,30,40};//聲明了結構對象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]={35,56,37};

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
{

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的作用是把一個整數的
四個位元組的順序來個顛倒。注意到了嗎？在函數調用語句中，實參&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所指向的存儲區時是不安全的。至於為什麼，讀者結合例十七來想
一想，應該會明白的。

㈡ c語言中指針怎麼使用

1、使用場景

使用指針時，必須將它指向一個變數的地址或者為它分配空間方能使用，如下所示：

#include<stdio.h>

#include <stdlib.h>

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

{

int a[5]={0,1,2,3,4};

int *b,*d;

int c=2;

int *e=a; //e指向a數組首地址

//*b=2; 無法直接初始化

//printf("%d ", *b);

e=e+2; //移動兩個地址單元

d=&c; //d指向c的地址來表示值

c=4; //修改原c變數的值，d指針的值會發生改變

b=(int *)malloc(sizeof(int));//為b分配一個int型空間來直接存儲值

*b=2;//分配空間後可以直接賦值了

printf("this is e,b,c,d :%d %d %d %d ",*e,*b,c,*d);

2、類型說明

（1）int *a :表示一個指向int型變數的指針，指向的是變數的地址單元

（2）char *b:表示一個指向char變數的指針

*a表示的是這個指針指向地址的值，a為此指針本身的地址，這點要明確，一般用*(a+1)、*(a+2)來表示值，如：

int nums[5]={0,1,2,3,4};

int *a=nums;

printf("%d %d %p ",*a,*(a+1),a);

(2)開發程序員使用指針擴展閱讀：

指針的運算

指針指向變數地址，若原變數的內容發生了變化，它本身也會發生變化，指針之間的運算一般為值運算和地址運算

（1）值運算：直接通過*運算方式，像a+*(a+1),結果為第一個元素與第二個元素相加。

int nums[5]={0,1,2,3,4};

int *a=nums;

（2）地址運算：通過a+i的方式.指針會指向a的下i個地址。

int nums[5]={0,1,2,3,4};

int *a=nums;

a=a+2;

printf("%d ",*a);

結果輸出2。

參考資料來源 ：指針-網路

㈢ 指針的作用是什麼啊

第一，指針的使用使得不同區域的代碼可以輕易的共享內存數據。當然小夥伴們也可以通過數據的復制達到相同的效果，但是這樣往往效率不太好。因為諸如結構體等大型數據，佔用的位元組數多，復制很消耗性能。

但使用指針就可以很好的避免這個問題，因為任何類型的指針佔用的位元組數都是一樣的（根據平台不同，有4位元組或者8位元組或者其他可能）。

第二，指針使得一些復雜的鏈接性的數據結構的構建成為可能，比如鏈表，鏈式二叉樹等等。

第三，有些操作必須使用指針。如操作申請的堆內存。還有：C語言中的一切函數調用中，值傳遞都是「按值傳遞」的。如果要在函數中修改被傳遞過來的對象，就必須通過這個對象的指針來完成。

(3)開發程序員使用指針擴展閱讀

指針的表現形式是地址，核心是指向關系指針運算符「*」的作用是按照指向關系訪問所指向的對象．如果存在A指向B的指向關系，則A是B的地址，「*A」表示通過這個指向關系間接訪問B。

如果B的值也是一個指針，它指向C，則B是C的地址，「*B」表示間接訪問C如果C是整型、實型或者結構體等類型的變數或者是存放這些類型的數據的數組元素，則B(即C的地址)是普通的指針，稱為一級指針,用於存放一級指針的變數稱為一級指針變數。

㈣ 請問C語言中 指針是什麼有什麼作用請用通俗的語言解釋

通俗的說，就是你家的門牌號，

簡單地說指針就是指向變數和對象的地址。
指針的用途非常廣泛，比如如果你想通過函數改變一個變數的值，就得用指針而不能用值傳遞。還有在很多時候變數，特別是對象的數據量實在太大，程序員就會用指針來做形參，只需要傳遞一個地址就行，大大提高了效率。
以上還只是指針的初步應用，隨著你在C語言學習上的逐步深入，你會發現更多的用途的

㈤ C語言的指針有什麼優缺點

1、指針的優點

是標識一塊內存。電腦內存上的每一個位元組都具有一個編號，稱為地址(可以簡單理解為指針)，任何讀寫內存的指令都必須攜帶地址信息，否則電腦不知道讀寫那塊內存。

不管程序是用什麼語言寫的，要運行數據和代碼必須駐留內存，CPU要執行指令必須有一個「指針」程序計數器指向內存的代碼塊，如果某個指令要操作內存數據，該指令必須攜帶額外的地址信息。

2、指針的缺點

指針可以操作任何東西，所以指針很靈活、很強大，但也引入了復雜性。

(5)開發程序員使用指針擴展閱讀

1、指針利用地址，它的值直接指向（points to）存在電腦存儲器中另一個地方的值。由於通過地址能找到所需的變數單元，可以說，地址指向該變數單元。

2、輸出一串字元時，只需要知道它的第一個字元的地址，就可以將這個字元串輸出，而第一個字元的地址，可以用指針儲存。所以有n個字元串時，就可以用n個指針來儲存。

3、為了保存一個數據在內存中的地址，就需要指針變數。因此指針是程序數據在內存中的地址，而指針變數是用來保存這些地址的變數。

㈥ 指針該怎麼用

一、什麼是指針
其實指針就像是其它變數一樣，所不同的是一般的變數包含的是實際的真實的數據，而指針包含的是一個指向內存中某個位置的地址。
二、指針的定義
int *pNumber;
這樣就定義了int類型的指針。指針變數名稱以p為首字元，這是程序員通常在定義指針時的一個習慣，以提高便程序的閱讀性，表示這是個指針。另外，雖然int* pNumber和int *pNumber是相同的，但是使用後一種的編程風格更好一些。比如：
int *pNumber1,*pNumber2;表示定義兩個指針，*號和變數靠近；反之，我們可能會定義成int* pNumber1,pNumber2，這將是一個錯誤的定義，pNumber2就不是指針了。
三、指針的優點
a.為函數提供修改調用變元的靈活手段；
b.支持C 動態分配子程序
c.可以改善某些子程序的效率
>>在數據傳遞時，如果數據塊較大（比如說數據緩沖區或比較大的結構），這時就可以使用指針傳遞地址而不是實際數據，即提高傳輸速度，又節省大量內存。
d.為動態數據結構（如二叉樹、鏈表）提供支持
四、指針賦值及轉換：
a）同類型直接賦值，異類型要進行轉換。
b）強制轉換：可以把表達式結果硬性轉換為指定類型
c）char * p;(int *)p 把p強制轉換為int型，記住轉換過程中要注意兩個類型的大小，大轉小時可能會有數據丟失（如int到double）
d）涉及void *的:
c 中void *類型可賦值給任何類型的指針，反之亦然
c 中都需要強制轉換
void *可看作無窮大能接納任何類型賦值，反之不行int * p =9;void * t= p（正確）;p=t(錯誤)
e）不涉及void *的都要強制轉換
五、指針和數組
不帶下標的數組名返回數組的起始地址，即數組首元素的地址，所以對數組的訪問可有兩種方式：數組下標和指針算術。例如：
char* pChar;
char chs[100];
pChar = chs;這樣pChar就指向chs數組的首地址。
六、數組與引用
a.引用只是變數的別名，而不是指向變數的指針(區別於取址運算符"&")不佔內存空間，對變數引用的改變其相應的變數也會改變。
b.不能對引用使用指針間接運算符「*」進行復引用操作
c.引用必須在聲明時初始化int &c = count;(c是count的別名)
七、指針空間的動態分配與回收
動態分配是指針的關鍵技術。它是用來在不必定義變數的情況下分配內存和讓指針去指向它們。分配了內存，別忘了回收。你動態地分配了一個內存空間，可它絕不會被自動刪除。也就是說，這塊內存空間會一直存在，直到你告訴電腦你已經使用完了。可結果是，你並沒有告訴電腦你已不再需要這塊內存空間了，所以它會繼續占據著內存空間造成浪費，甚至你的程序運行完畢，其它程序運行時它還存在。當這樣的問題積累到一定程度，最終將導致系統崩潰。所以這是很重要的，在你用完它以後，請釋放它的空間。

㈦ c語言中用指針的好處有哪些

指針非常的好，它把相同的事物歸類，然後把事物做出標記，避免給相同的特點做變數。比如說你和你同學，你們兩個人都有心臟、肝、肺等器官，如果命名心臟1、心臟2這樣比較麻煩，這時如果用上指針，指向你說心臟時說的是你的心臟，指向你同學時說的是你同學的心臟，如果人非常的多，你不用指針，那麼命名心臟1、2、3、4、5.。。。那是非常的多的不必要的變數。我現在運用PLC和WINCC連接時有的時候就用指針。節省了通訊時間，省略了很多的變數。

㈧ C語言指針的作用有哪些

指針的用途非常廣泛，比如如果你想通過函數改變一個變數的值，就得用指針而不能用值傳遞。還有在很多時候變數，特別是對象的數據量實在太大，程序員就會用指針來做形參，只需要傳遞一個地址就行，大大提高了效率。簡單地說指針就是指向變數和對象的地址。

㈨ 可以介紹一下c語言裡面的指針怎麼運用嗎

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

(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所指向的存儲區時是不安全的。

㈩ 為什麼要用指針

其實說C#和java裡面不用指針，但處處是「指針」，裡面不存在c++中的值傳遞，而是傳遞引用，而引用本質上就是指針。
為什麼需要指針呢？由於c/c++開發先與java和c#，c/c++為了給程序員以控制內存的目的而提出了指針。
一個簡單的例子就是垃圾回收機制。在c/c++中，你可以使用delete(free)來釋放內存，在c#和java裡面就只能靠其自己的內存回收機制來回收了。有些時候，內存吃緊的話是必須要立馬釋放的。那麼這種情況c#和java就做不到了。
所以說c#和java裡面不是不要指針，而是處處是「指針」，只是它給你封裝了，不在讓你頭疼c/c++中指針帶來的一些問題了。
淺見，如有錯誤，純屬失誤。哈哈。