指針是存儲地址的變數

❶ c語言中指針變數只能存儲地址

指針變數是一個變數，它保存的是另一個變數的內存地址。你如果知道了這個指針變數保存的值，就可以知道它所指向變數的內存地址，於是就可以間接訪問到那一個變數。
定義：指針變數類型
*指針變數名1,
*指針變數名2,
...
;
例如：
int
main(void)
{
int
*p;
/*定義*/
int
a;
p
=
&a;
/*把a的地址賦值到p中*/
*p
=
1;
/*間接訪問a*/
return
0;
}
把指針作為函數的參數傳遞，可以使函數可以訪問函數外部的變數，例如：
void
swap(int
*a,
int
*b)
{
int
c;
c
=
*a;
*a
=
*b,
*b
=
c;
}
指針也可以用於傳遞數組，數組名本身就是一個指針：
void
func(int
a[],
int
n)
{
.....
}
指針還可以指向指針，指向結構體(struct)，指向數組
int
**p;
/*指向int指針*/
struct
xxx
*p;
int
(*p)[100];
/*指向一個int[100]數組，括弧不可少*/

❷ 指針變數的地址與指針存放的地址是一回事嗎

這是正確的。先看一下解釋吧，變數的指針就是變數的地址。存放變數地址的變數是指針變數。即在C語言中，允許用一個變數來存放指針，這種變數稱為指針變數。因此，一個指針變數的值就是某個變數的地址或稱為某變數的指針。
可能有些難以理解，再附一段程序，

1
2
3
4
5
6
7
8
9
10
11

#include<stdio.h>
#include<stdlib.h>
int main()
{
int a=10;
int *p;
p=&a;
printf("the pointer p address %x\n",p);
printf("the pointer p value %d\n",*p);
return 0;
}

下面是運行結果，可以看到第一行輸出了指針數據p，也就是變數a的地址。採用十六進制顯示。第二行輸出了目標標量a的值，也就是10。這里用存取內容運算符'*'對目標變數a讀寫數據。

解釋的不知道能不能懂，可以自己多看一些別的書，可能有更好的解釋吧

❸ 指針與指針變數的概念是什麼

1、指針，是C語言中的一個重要概念及其特點，也是掌握C語言比較困難的部分。指針也就是內存地址，指針變數是用來存放內存地址的變數，不同類型的指針變數所佔用的存儲單元長度是相同的，而存放數據的變數因數據的類型不同，所佔用的存儲空間長度也不同。

有了指針以後，不僅可以對數據本身，也可以對存儲數據的變數地址進行操作。

2、指針變數是指存放地址的變數。因地址的改變而做出指定性質的衡量變法。

(3)指針是存儲地址的變數擴展閱讀：

指針變數定義：

1、定義指針變數的一般形式如下：

類型名*指針變數名1，*指針變數名2，... *指針變數名n ;

2、空指針

空指針是一個特殊的指針，它的值是0，C語言中用符號常量NULL（在stdio.h中定義）表示這個空值，並保證這個值不會是任何變數的地址。空指針對任何指針類型賦值都是合法的。一個指針變數具有空指針值表示當前它沒有指向任何有意義的東西。

3、void指針

（void *）類型的指針叫通用指針，可以指向任何的變數，C語言允許直接把任何變數的地址作為指針賦給通用指針。

但是需要注意void*不能指向由const修飾的變數，例如const int test; void * ptv; ptv = &test;第三句是非法的，只有將ptv聲明為const void * ptv;，上述第三句ptv = &test才是合法的。

當需要使用通用指針所指的數據參加運算時，需要寫出類型強制轉換。如通用指針ptv 所指空間的數據是整型數據，p是整型指針，用此式轉換：p=(int *)ptv;

❹ C語言中的指針就是指內存地址，指針變數指內存地址的變數對嗎

對的。
int x=0;
int *p=&x//給指針變數賦值
*p=1;//給指針變數所指的空間賦值，此時，這個空間就是x的空間，
輸出x為1
如果你要為指針空間賦值，一定要申請空間
如果你要

❺ 「指針」就是___存放地址值的變數或常量，或者答地址。 對嗎我實在不理解，請老師指教，學生有禮了。

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

指針還可以保存函數（指令）的地址，所以說指針僅僅存放數據對象的地址是錯誤的

❼ 請問 指針是指向地址的還是指向那個變數值的。

指針是一個變數，他的值是可以變得，他裡面存的是一個地址
假設我們定義一個指針 int *p; int a;
如果p = &a;
這個時候我們知道，a是一個變數，那麼內存必定要給他分配一個地址來存儲他，p指向a的意思就是p裡面存的就是a的地址。所以p就是一個存著地址的變數。
既然我們知道p裡面存著a的地址，那麼我們要找a就非常方便了，*p就表示p存的地址裡面的值，也就是a的值。
這句話怎麼理解呢？
1.p存的是地址，比作你住的地方，那麼*p就表示你了，因為*p就表示這個地址裡面的數據。
這個時候*p和a是完全一樣的了，假如你要改變a的值。a = a+1和*p =*p+1是完全一樣的，都能達到對a進行操作的目的。但是*p =*p+1和*p = *(p+1)是不一樣的，這個用的時候要特別注意，因為p裡面是地址,那麼*（p+1）就表示這個地址加1後，地址加1那不就是換了一個地址嗎？換了一個地址後裡面存的就肯定不是a了，就像可能是你的鄰居了。因為地址變了，所以就是p變了，因此*也變了，這個地方有點難理解，樓主多琢磨琢磨。
總結一句話：指針是一個萬能鑰匙，可以指向任何一個地址，可以改變任何一個地址裡面的數據（只讀的除外），因此使用指針要注意安全，以免發生異常。

❽ C語言中指針是什麼

我們都知道：C語言中的數組是指 一類 類型，數組具體區分為 int 類型數組，double類型數組,char數組 等等。同樣指針 這個概念也泛指 一類
數據類型，int指針類型，double指針類型，char指針類型等等。

通常，我們用int類型保存一些整型的數據，如 int num = 97 ， 我們也會用char來存儲字元： char ch = 'a'。

我們也必須知道：任何程序數據載入內存後，在內存都有他們的地址，這就是指針。而為了保存一個數據在內存中的地址，我們就需要指針變數。

因此：指針是程序數據在內存中的地址，而指針變數是用來保存這些地址的變數。

❾ 指針是內存地址還是存放內存地址的變數

「指針」是簡化說法
指針——地址
指針變數——存放地址的變數
都叫指針
你要區分這個「指針」在每個環境中都指什麼

❿ C語言中「指針」和「指針變數」的區別是什麼

1、概念不同

「指針」是概念，「指針變數」是具體實現，指針也是一個變數，所以需要進行定義，而對於指針的定義，與一般變數一樣。

2、 存放地址不同

一個變數的(內存)地址稱為該變數的「指針」，通過指針能找到以它為地址的內存單元。而指針變數是用來存放另一個變數的地址的（即指針）。

(10)指針是存儲地址的變數擴展閱讀：

指針和指針變數的關系

1、指針就是地址，地址就是指針。

2、地址就是內存單元的編號。

3、指針變數就是存放內存地址的變數。

4、指針和指針變數是兩個不同的概念，但要注意的是，通常我們敘述時會把指針變數簡稱為指針，實際他們含義並不一樣。

註：

指針里存的是100. 指針：地址 - 具體。

指針里存的是地址，指針：指針變數 -可變。

指針的好處：

1、直接訪問硬體

2、快速傳遞數據（指針表示地址）

3、返回一個以上的值返回一個（數組或者結構體的指針）

4、表示復雜的數據結構（結構體）

5、方便處理字元串

6、指針有助於理解面向對象