編譯器成員指針
❶ 是不是不管有沒有創建類（這個類里的成員包含虛函數）的對象，編譯器都會自動生成一個_vfptr指針
this指針作為一個隱含參數傳遞給非靜態成員函數，用以指向該成員函數所屬類所定義的對象。當不同的對象調用同一個類的成員函數代碼時，編譯器會依據該成員函數的this指針所指向的不同對象來確定應該引用哪個對象的數據成員。所以this指針只存於類中，創建類了，不創建對象也存在
❷ 為什麼類成員可以是自己類的指針，而且我在編譯的時候發現這個成員是佔有一定內存的，和this指針不一樣
建立base *q之前，sizeof(x) = sizeof(int) + sizeof(int) + sizeof(指向虛函數表的指針)，int在32位機中佔4位元組，指針也是4位元組，所以為12
建立base *q之後，就相當於在原來的基礎上多了一個指針而已，而上面說了，指針的大小都是4位元組，所以就為16了。
還有，為什麼可以在類中聲明自己類的指針，因為此時編譯器可以計算出它的大小，假如你要是聲明自己的類對象，
即base b，此時會報錯，因為這種嵌套定義使得編譯器無法計算類的大小。
❸ vc中嵌套結構體成員指針初始化的理解 struct node { char* name; node* p; } vc編譯器默認二者都為NULL
我跟你寫了完整程序，還有結果，你看過了就明白了
#include"stdafx.h"
#include"stdio.h"
#include"malloc.h"
structnode{char*name;node*p;};//vc編譯器默認二者都為NULL？
intmain(intargc,char*argv[])
{
node*pnode;
printf("%d ",pnode);
pnode=(node*)malloc(sizeof(node));
printf("%d%d ",pnode->name,pnode->p);
return0;
}
❹ c語言中的指針應該怎麼理解
這是我收錄的指針講義
第一章。指針的概念
指針是一個特殊的變數，它裡面存儲的數值被解釋成為內存里的一個地址。
要搞清一個指針需要搞清指針的四方面的內容：指針的類型，指針所指向的 類型，指針的值或者叫指針所指向的內存區，還有指針本身所佔據的內存區。讓 我們分別說明。
先聲明幾個指針放著做例子：
例一：
(1)int *ptr;
(2)char *ptr;
(3)int **ptr;
(4)int (*ptr)[3];
(5)int *(*ptr)[4];
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所指向的類型)個位元組。
第三章。運算?amp;和*
這里&是取地址運算符，*是...書上叫做"間接運算符"。
&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當然也有了自己的位置。
第五章。數組和指針的關系
如果對聲明數組的語句不太明白的話，請參閱我前段時間貼出的文?lt;>。
數組的數組名其實可以看作一個指針。看下例：
例八：
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]，但如果把a
rray看做指針的話，它指向數組的第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扮演的是指針，故arr
ay+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上調式過上述代碼，但是要知道，這樣使用p
str來訪問結構成員是不正規的，為了說明為什麼不正規，讓我們看看怎樣通過指
針來訪問數組的各個單元：
例十二：
int array[3]={35,56,37};
int *pa=array;
通過指針pa訪問數組array的三個單元的方法是：
*pa;//訪問了第0號單元
*(pa+1);//訪問了第1號單元
*(pa+2);//訪問了第2號單元
從格式上看倒是與通過指針訪問結構成員的不正規方法的格式一樣。
所有的C/C++編譯器在排列數組的單元時，總是把各個數組單元存放在連續的存儲區里，單元和單元之間沒有空隙。但在存放結構對象的各個成員時，在某種編譯環境下，可能會需要字對齊或雙字對齊或者是別的什麼對齊，需要在相鄰兩個成員之間加若干?quot;填充位元組"，這就導致各個成員之間可能會有若干個位元組的空隙。
所以，在例十二中，即使*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++重載成員指針運算符
你這個問題問了很多遍了
P1是PComplex的一個對象，
不過PComplex設計的目的就是作為指針的替代
並且P1可以像普通指針一樣使用->運算符
因此書上把P1稱作指針，是一種簡稱
需要注意的是，PComplex和真正的指針之間還是有區別的
比如Complex* RealPointer = P1;這樣的語句就無法執行。
至於為什麼P1=&C1可以執行，其原因在於
在沒有合適的=運算符時，
C++編譯器會尋找合適的隱式類型轉換
將該句解釋成了如下的語句：
P1=PComplex(&C1);
其中PComplex(&C1)是你定義的構造函數
=運算符的左右對象都是PComplex，這個運算符是系統默認生成的
因此代碼正常執行。
在另一個問題中有人答到explicit的問題，我再解釋一下
如果將你代碼中的
PComplex(Complex * PC=NULL)
改為
explicit PComplex(Complex * PC=NULL)
編譯就會失敗，因為此時編譯器不能隨便解釋出
PComplex(&C1)
這一句
============
綜上所述，你這段代碼里有兩個關鍵性問題需要你深入理解，
1是類型的隱式轉換（以及explicit關鍵字）
2是編譯器默認生成的=運算符
PS:關於內存越界的回答是錯誤的
❻ 編譯器怎麼處理指針
其實指針就是一個變數，只不過你面存儲的是某個內存單元格的地址。
測試：
3,2293620,3
測試代碼：
#include "stdio.h"
#include "conio.h"
main()
{
int a=3;
int *p=&a;
printf("%d,%d,%d",a,p,*p);
getch();
}
其本質還是一個變數。
只是對p的賦值，和取值，操作的時候和普通變數不同
指針變數= 地址
*（指針）表示單元格中的值
指針+1，移動相應的長度的單元格，還是地址！
❼ C語言的指針是什麼
針是C語言中廣泛使用的一種數據類型。 運用指針編程是C語言最主要的風格之一。利用指針變數可以表示各種數據結構； 能很方便地使用數組和字元串； 並能象匯編語言一樣處理內存地址，從而編出精練而高效的程序。指針極大地豐富了C語言的功能。 學習指針是學習C語言中最重要的一環， 能否正確理解和使用指針是我們是否掌握C語言的一個標志。同時， 指針也是C語言中最為困難的一部分，在學習中除了要正確理解基本概念，還必須要多編程，上機調試。只要作到這些，指針也是不難掌握的。
指針的基本概念 在計算機中，所有的數據都是存放在存儲器中的。 一般把存儲器中的一個位元組稱為一個內存單元， 不同的數據類型所佔用的內存單元數不等，如整型量佔2個單元，字元量佔1個單元等， 在第二章中已有詳細的介紹。為了正確地訪問這些內存單元， 必須為每個內存單元編上號。 根據一個內存單元的編號即可准確地找到該內存單元。內存單元的編號也叫做地址。 既然根據內存單元的編號或地址就可以找到所需的內存單元，所以通常也把這個地址稱為指針。 內存單元的指針和內存單元的內容是兩個不同的概念。 可以用一個通俗的例子來說明它們之間的關系。我們到銀行去存取款時， 銀行工作人員將根據我們的帳號去找我們的存款單， 找到之後在存單上寫入存款、取款的金額。在這里，帳號就是存單的指針， 存款數是存單的內容。對於一個內存單元來說，單元的地址即為指針， 其中存放的數據才是該單元的內容。在C語言中， 允許用一個變數來存放指針，這種變數稱為指針變數。因此， 一個指針變數的值就是某個內存單元的地址或稱為某內存單元的指針。圖中，設有字元變數C，其內容為「K」(ASCII碼為十進制數 75)，C佔用了011A號單元(地址用十六進數表示)。設有指針變數P，內容為011A， 這種情況我們稱為P指向變數C，或說P是指向變數C的指針。 嚴格地說，一個指針是一個地址， 是一個常量。而一個指針變數卻可以被賦予不同的指針值，是變。 但在常把指針變數簡稱為指針。為了避免混淆，我們中約定：「指針」是指地址， 是常量，「指針變數」是指取值為地址的變數。 定義指針的目的是為了通過指針去訪問內存單元。
既然指針變數的值是一個地址， 那麼這個地址不僅可以是變數的地址， 也可以是其它數據結構的地址。在一個指針變數中存放一
個數組或一個函數的首地址有何意義呢？ 因為數組或函數都是連續存放的。通過訪問指針變數取得了數組或函數的首地址， 也就找到了該數組或函數。這樣一來， 凡是出現數組，函數的地方都可以用一個指針變數來表示， 只要該指針變數中賦予數組或函數的首地址即可。這樣做， 將會使程序的概念十分清楚，程序本身也精練，高效。在C語言中， 一種數據類型或數據結構往往都佔有一組連續的內存單元。 用「地址」這個概念並不能很好地描述一種數據類型或數據結構， 而「指針」雖然實際上也是一個地址，但它卻是一個數據結構的首地址， 它是「指向」一個數據結構的，因而概念更為清楚，表示更為明確。 這也是引入「指針」概念的一個重要原因。
指針變數的類型說明
對指針變數的類型說明包括三個內容：
(1)指針類型說明，即定義變數為一個指針變數；
(2)指針變數名；
(3)變數值(指針)所指向的變數的數據類型。
其一般形式為： 類型說明符 *變數名；
其中，*表示這是一個指針變數，變數名即為定義的指針變數名，類型說明符表示本指針變數所指向的變數的數據類型。
❽ 從編譯器角度分析C語言中數組名和指針的區別
從編譯生成的角度來說
數組名 沒有本身的存儲空間，其只是一個地址。 代表數組的首地址。
於是 數組名的值 不可能被改變。
而指針 是一個變數 有自身的存儲空間
可以被改變值 執行數學操作。
❾ 如何使用指向類的成員函數的指針
指向函數的指針的用法：
1.指向函數的指針的類型
指向函數的指針應該怎樣聲明？拿兩個字元串的比較函數來說：
int strCompare(const string & s1, const string & s2) ;
如果兩個字元串相等就返回0，否則，s1< s2返回負數,s1 > s2返回正數其實函數名不是其類型的一部分，函數類型是只由它的返回類型和參數來決定。函數名稱只不過是指向函數代碼的地址。所以指向函數的指針的類型應該用下面的形式聲名：
int (*pf)( const string &, const string & );
2.初始化和賦值
指向函數的指針可如下被初始化只有當賦值操作符左邊指針的參數表和返回類型與右邊函數或指針的參數表和返回類型
完全匹配時初始化和賦值才是正確的如果不匹配則將產生編譯錯誤消息在指向函數
類型的指針之間不存在隱式類型轉換。
int (*pfi)( const string &, const string & ) = strCompare;
int (*pfi2)( const string &, const string & ) = &strCompare;
指向函數的指針可以如下被賦值
pfi = strCompare;
pfi2 = pfi;
3.調用
如下代碼：
#include <iostream>
using namespace std;
int min( int*, int );
int (*pf)( int*, int ) = min;
const int iaSize = 5;
int ia[ iaSize ] = { 7, 4, 9, 2, 5 };
int main()
{
cout << "Direct call: min: "
<< min( ia, iaSize ) << endl;
cout << "Indirect call: min: "
<< pf( ia, iaSize ) << endl;
return 0;
}
int min( int* ia, int sz )
{
int minVal = ia[ 0 ];
for ( int ix = 1; ix < sz; ++ix )
if ( minVal > ia[ ix ] )
minVal = ia[ ix ];
return minVal;
}
4.函數指針的數組
我們可以聲明一個函數指針的數組例如
int (*testCases[10])();
將testCases 聲明為一個擁有10 個元素的數組每個元素都是一個指向函數的函數指針，該函數沒有參數返回類型為int。
上面的聲明等價於下面聲明：
typedef int (*PFV)(); // 定義函數類型指針的typedef
PFV testCases[10];
函數指針的數組可以用一個初始化列表來初始化該表中每個初始值都代表了一個與數
組元素類型相同的函數例如
int lexicoCompare( const string &, const string & );
int sizeCompare( const string &, const string & );
typedef int ( *PFI2S )( const string &, const string & );
PFI2S compareFuncs[2] =
{
lexicoCompare,
sizeCompare
};
// 兩個等價的調用
pfCompare[ 0 ]( string1, string2 ); // 編寫
((*pfCompare)[ 0 ])( string1, string2 ); // 顯式
5,參數和返回類型
函數參數的類型不能是函數類型函數類型的參數將被自動轉換成該函數類型的指針
例如
// typedef 表示一個函數類型
typedef int functype( const string &, const string & );
void sort( string *, string *, functype );
編譯器把sort()當作已經聲明為
void sort( string *, string *,
int (*)( const string &, const string & ) );
上面這兩個sort()的聲明是等價的
注意除了用作參數類型之外函數指針也可以被用作函數返回值的類型例如
int (*ff( int ))( int*, int );
該聲明將ff()聲明為一個函數它有一個int 型的參數返回一個指向函數的指針類型
為
int (*) ( int*, int );
同樣使用typedef 名字可以使聲明更容易讀懂例如下面的typedef PF 使得我們能更
容易地分解出ff()的返回類型是函數指針
typedef int (*PF)( int*, int );
PF ff( int );
函數不能聲明返回一個函數類型如果是則產生編譯錯誤例如函數ff()不能如下
聲明
// typedef 表示一個函數類型
typedef int func( int*, int );
func ff( int ); // 錯誤: ff()的返同類型為函數類型
❿ C語言結構體指針成員所指向的變數如何訪問
第一種寫法：
(*a).p=&b;
.的優先順序高於*，(*pointer)兩邊的括弧不能少。如果去掉括弧寫作*pointer.memberName，那麼就等效於*(pointer.memberName)，這樣意義就完全不對了。
第二種寫法：
a->p=&b;
->是一個新的運算符，習慣稱它為「箭頭」，有了它，可以通過結構體指針直接取得結構體成員；這也是->在C語言中的唯一用途。
結構體是一種數據類型，是一種創建變數的模板，編譯器不會為它分配內存空間，就像 int、float、char 這些關鍵字本身不佔用內存一樣；結構體變數才包含實實在在的數據，才需要內存來存儲。下面的寫法是錯誤的，不可能去取一個結構體名的地址，也不能將它賦值給其他變數。
(10)編譯器成員指針擴展閱讀：
用指針引用結構體變數成員方式總結與技巧：
一、(*指針變數名).成員名
注意，*p 兩邊的括弧不可省略，因為成員運算符「.」的優先順序高於指針運算符「*」，所以如果 *p 兩邊的括弧省略的話，那麼 *p.num 就等價於 *(p.num) 了。
因為指針變數 p 指向的是結構體變數第一個成員的地址，即字元數組 name 的首地址，所以 p 和 (*p).name 是等價的。
「等價」僅僅是說它們表示的是同一個內存單元的地址，但它們的類型是不同的。指針變數 p 是 struct 型的，而 (*p).name 是 char* 型的。所以在 strcpy 中不能將 (*p).name 改成 p。用 %s 進行輸入或輸出時，輸入參數或輸出參數也只能寫成 (*p).name 而不能寫成 p。
二、直接用：指針變數名->成員名
來代替，它們是等價的。「->」是「指向結構體成員運算符」，它的優先順序同結構體成員運算符「.」一樣高。p->num 的含義是：指針變數 p 所指向的結構體變數中的 num 成員。p->num 最終代表的就是 num 這個成員中的內容。