參考一：
0.預備知識,最基礎的指針
其實最基礎的指針也就應該如下面代碼:
int a;
int* p=&a;
也就是說,聲明了一個int變量a,然後聲明一個int 的指針,*p指向a的地址,&也就是取地址符號,而*是指針中取內容的符號,僅僅在聲明的時候標記這個變量是指針.可能有點繞口,但是看代碼來的容易的多...
1.與const在一起的時候
常常聲明的時候會讓人一頭霧水,比如下面的聲明,均是聲明一個char* p的指針:
char * const p;
char const * p;
char const * const p; // 內容和指針都不能改
const char * const p; // 同上...內容和指針不能改
額...別暈,別暈....其實方法很簡單...你別真死記硬背...其實可以以*為分界符,在*左邊有const就說明內容不能改,在*右邊就說明指針不能改,而左邊的char和const順序是不要緊的...呵呵...你也可以理解成const是修飾後面的,正常順序應該這樣:const char * const p; 是不是看起來簡單了?
2.忽悠人的陷阱,str[]和*str的區別
先告訴你哦,下面的題目可是陷阱啊....說說程序結果...
char str1[] = “abc”;
char str2[] = “abc”;
const char str3[] = “abc”;
const char str4[] = “abc”;
const char *str5 = “abc”;
const char *str6 = “abc”;
char *str7 = “abc”;
char *str8 = “abc”;
cout << ( str1 == str2) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
怎麼樣?都輸出true?那顯然你中標了...而且cout輸出bool值的時候,就算全是真也應該都輸出1啊...4個1?那也不對...答案是0011,不信你試試...為什麼呢?
其實都說了這題是個大陷阱,因為這題根本不是比較字符串內容!而是比較字符串的地址.哦...恍然大悟...那為什麼前兩個是假呢?因為這可是說是一個深拷貝/淺拷貝的問題.當字符串是數組形式聲明並初始化,編譯器認為是新數組,分配新空間,但不是深拷貝,因為根本就不算拷貝.而如果是相同的字符串,用指針聲明,那就是比較如果有一樣的字符串,就直接把新指針指過去,這是正宗的淺拷貝.哇哈...你就中計了...
3.str[]用sizeof判斷會出錯麼?
應該說我們常常用指針有很多時候是解決字符串的問題,一般我們用strlen,這當然沒有問題,但是要你編一個呢?看看下面這個MyStrlen有問題麼?
int MyStrlen(char str[])
{
}
呵呵...咱們上當過一次..這個當然也是不對的...不錯...這個函數是錯的...為什麼呢?
首先,可以告訴你,無論何時,返回的總是3...額...是不是很奇怪,為什麼不是數組長度呢?str不是char數組指針麼?不錯...確實是數組的指針,但是,當用函數傳遞的數組指針的時候就自動退化為指針了,而指針的長度是4,你減去1了自然就是3了.但是如果按照下面代碼就可以得到正常的值.
char str[]="hello world";
int len=sizeof(str)-1;
cout<
這樣輸出的是正常值,也就是你所希望的11;
4.注意數組指針和指針
繼續上面的話題,剛剛提到了數組指針和指針,現在看看下面這端程序代碼:
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
cout<<*(a+1)<<*(ptr-1);
呵呵...BaihowFF總是給陷阱..肯定不是想當然的說就是21...確實...答案是25...額...奇怪吧..為什麼呢?
首先,a是一個數組,所以編譯器解釋&a就是a的全部長度,就是說(&a+1)也就是說移動了一個數組,指向了並不存在的a[5],所以ptr-1才會指向a數組的最後一個元素a[4],而a+1和a[1]是一樣的...所以答案是25,如果你去掉了(&a+1)的括號,那麼答案就是想當然的21了...呵呵...很微妙吧....
5.注意指針要分配給足夠的空間
新手在剛剛接觸指針的時候經常會忘記給指針分配空間,直接用肯定是有問題的,那麼下面的程序呢?
char a;
char *str=&a;
strcpy(str,”hello”);
cout<
BaihowFF是壞蛋..總會下套...呵呵..確實是圈套...這段程序能夠輸出hello,但是輸出後就崩潰了...原因就在你分配str指針的時候僅僅給了1字節的空間,但是你拷貝了6字節過去(不要忘記了最後的'\0'結束).運行輸出後程序因為訪問了沒有分配的呵呵空間,當然崩潰了.如果你只strcpy(str,"");那程序是可以正常運行的.
6.小心編譯器的指針字符串初始化
經常我們想自己處理字符串,但是像下面的初始化是很危險的!!!
char* s="AAA";
cout<
s[0]='B';
cout<
你可以拿這段程序去編譯...沒錯!編譯器報告正常!...這是最要命的...其實程序不能運行的...輸出AAA後就崩潰了..為什麼?因為當你在第一句初始化的時候,編譯器就認為這是個字符串常量了...再做數組操作的時候肯定錯了羅...最好的習慣是聲明一個指針,用new分配空間,然後用庫函數操作,比如strcpy,strcat等等...
7.讓人一眼看上去迷糊的函數指針
看看這句代表什麼意思?
int (*s[10])(int);
咦...這是什麼?其實這是一個函數指針數組,指向了一組int fun(int)的函數,第一眼確實讓人有點迷糊...但是請習慣這樣...
8.注意函數傳遞指針的時候是副本
副本?又下副本?...汗...老兄...不是這個意思...別沉浸在WOW裡了啊...看看下面程序的問題:
void GetMemory(char *p)
{
p=new char[100];
strcpy(p,"hello world");
}
void main(void)
{
char *str=NULL;
GetMemory(str);
cout<
delete []str;
str=NULL;
}
當然了..喜歡下套的BaihowFF又給了錯程序....錯在哪呢?看上去是對的,而且編譯器編譯也正確啊..怎麼就是不能通過呢?而且還崩潰了...好費解吧...
其實原因很簡單...GetMemory這個函數出問題了!函數參數是不能傳遞分配空間的...因為傳遞過去實際上是一個副本p...不能返回的...而且你在delete那就是件很危險的事情..因為壓根沒有內容...那我實在想這樣用函數分配怎麼辦呢?像下面這樣改一下就ok了:
void GetMemory(char **p)
{
*p=new char[100];
strcpy(*p,"hello world");
}
void main(void)
{
char *str=NULL;
GetMemory(&str);
cout<
delete []str;
str=NULL;
}
這樣就能正常工作了,但是看起來好別扭啊...嗯..確實...但是還可以用其他方法哦....你想想...肯定有辦法的...
9.請時刻記住要初始化字符串
嗯...這點大家都知道...那你猜猜下面的程序結果是多少?
char a[10];
cout<
答案應該讓你以外...竟然是15...沒道理吧?!其實strlen函數的結果和是否初始化有關的...雖然你分配了空間..但是沒有初始化..庫函數會出錯的..sizeof不受影響...切忌初始化哦....
10.小括號,大區別
看看這兩端聲明,有什麼不同?我直接在注釋裡告訴你答案吧...這樣好看點...
char (*str)[20];
char *str[20];
千萬別小看括號哦...區別大了吧....
參考二：
c語言面試題__指針篇
1. char * const p;
char const * p
const char *p
上述三個有什麼區別？
char * const p; //常量指針，p的值不可以修改
char const * p；//指向常量的指針，指向的常量值不可以改
const char *p；//和char const *p
------------------------------------------------------
2. char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
打印結果是什麼？
解答：結果是：0 0 1 1
str1,str2,str3,str4是數組變量，它們有各自的內存空間；而str5,str6,str7,str8是指針，它們指向相同的常量區域
-----------------------------------------------
3.以下代碼中的兩個sizeof用法有問題嗎？
void UpperCase( char str[] ) //將str中的小寫字母轉換成大寫字母
{
for( size_t i=0; i
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符長度為: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;
答：函數內的sizeof有問題。
根據語法，sizeof如用於數組，只能測出靜態數組的大小，無法檢測動態分配的或外部數組大小。
函數外的str是一個靜態定義的數組，因此其大小為6，
函數內的str實際只是一個指向字符串的指針，沒有任何額外的與數組相關的信息，因此sizeof作用於上只將其當指針看，一個指針為4個字節，因此返回4。
-------------------------------------------------
4. main()
{
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
}
輸出結果是什麼？
答案：輸出：2,5
*(a+1）就是a[1]，*(ptr-1)就是a[4],執行結果是2，5
&a+1不是首地址+1，系統會認為加一個a數組的偏移，是偏移了一個數組的大小（本例是5個int）
int *ptr=(int *)(&a+1);
則ptr實際是&(a[5]),也就是a+5
原因如下：
&a是數組指針，其類型為int (*)[5];
而指針加1要根據指針類型加上一定的值，不同類型的指針+1之後增加的大小不同。
a是長度為5的int數組指針，所以要加5*sizeof(int)
所以ptr實際是a[5]
但是prt與(&a+1)類型是不一樣的(這點很重要)
所以prt-1只會減去sizeof(int*)
a,&a的地址是一樣的，但意思不一樣
a是數組首地址，也就是a[0]的地址，&a是對象（數組）首地址，
a+1是數組下一元素的地址，即a[1],&a+1是下一個對象的地址，即a[5].
--------------------------------------------
5. 請問以下代碼有什麼問題：
int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}
答案：沒有為str分配內存空間，將會發生異常。問題出在將一個字符串復制進一個字符變量指針所指地址。雖然可以正確輸出結果，但因為越界進行內在讀寫而導致程序崩潰。
---------------------------------------------
6. char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);
有什麼錯？
答案：
"AAA"是字符串常量。s是指針，指向這個字符串常量，所以聲明s的時候就有問題。
cosnt char* s="AAA";
然後又因為是常量，所以對是s[0]的賦值操作是不合法的。
---------------------------------------------
7. int (*s[10])(int)表示的是什麼？
答案：int (*s[10])(int)函數指針數組，每個指針指向一個int func(int param)的函數。
---------------------------------------------
8. 有以下表達式：
int a=248; b=4;
int const c=21;
const int *d=&a;
int *const e=&b;
int const *f const =&a;
請問下列表達式哪些會被編譯器禁止？為什麼？
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
答案：
*c這是個什麼東東，禁止
*d說了是const， 禁止
e = &a說了是const禁止
const *f const =&a;禁止
------------------------------------------
9. #include
#include
void getmemory(char *p)
{
p=(char *) malloc(100);
strcpy(p,"hello world");
}
int main( )
{
char *str=NULL;
getmemory(str);
printf("%s/n",str);
free(str);
return 0;
}
分析一下這段代碼
答案：程序崩潰，getmemory中的malloc不能返回動態內存，free（）對str操作很危險
-----------------------------------------
10. char szstr[10];
strcpy(szstr,"0123456789");
產生什麼結果？為什麼？
答案：長度不一樣，會造成非法的OS
------------------------------------------
11.要對絕對地址0x100000賦值，我們可以用(unsigned int*)0x100000 = 1234;
那麼要是想讓程序跳轉到絕對地址是0x100000去執行，應該怎麼做？
答案：*((void (*)( ))0x100000 ) ( );
首先要將0x100000強制轉換成函數指針,即:
(void (*)())0x100000
然後再調用它:
*((void (*)())0x100000)();
用typedef可以看得更直觀些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
------------------------------------------
12.分析下面的程序：
void GetMemory(char **p,int num)
{
*p=(char *)malloc(num);
}
int main()
{
char *str=NULL;
GetMemory(&str,100);
strcpy(str,"hello");
free(str);
if(str!=NULL)
{
strcpy(str,"world");
}
printf("\n str is %s",str);軟件開發網www.mscto.com
getchar();
}
問輸出結果是什麼？
答案：輸出str is world。
free只是釋放的str指向的內存空間,它本身的值還是存在的.所以free之後，有一個好的習慣就是將str=NULL.
此時str指向空間的內存已被回收,如果輸出語句之前還存在分配空間的操作的話,這段存儲空間是可能被重新分配給其他變量的,
盡管這段程序確實是存在大大的問題（上面各位已經說得很清楚了），但是通常會打印出world來。
這是因為，進程中的內存管理一般不是由操作系統完成的，而是由庫函數自己完成的。
當你malloc一塊內存的時候，管理庫向操作系統申請一塊空間（可能會比你申請的大一些），然後在這塊空間中記錄一些管理信息（一般是在你申請的內存 前面一點），並將可用內存的地址返回。但是釋放內存的時候，管理庫通常都不會將內存還給操作系統，因此你是可以繼續訪問這塊地址的。
-------------------------------------------
13.char a[10]；
strlen(a)為什麼等於15？
#include "stdio.h"
#include "string.h"
void main()
{
char aa[10];
printf("%d",strlen(aa));
}
答案：sizeof()和初不初始化，沒有關系；
strlen()和初始化有關。
--------------------------------------------
14.char (*str)[20];/*str是一個數組指針，即指向數組的指針．*/
char *str[20];/*str是一個指針數組，其元素為指針型數據．*/
---------------------------------------------
15.
#include
#include
#include
#include
#include
#include
typedef struct AA
{
int b1:5;
int b2:2;
}AA;
void main()
{
AA aa;
char cc[100];
strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
memcpy(&aa,cc,sizeof(AA));
cout << aa.b1 <
輸出結果是多少？
答案：-16和１
首先sizeof(AA)的大小為4,b1和b2分別占5bit和2bit.經過strcpy和memcpy後,aa的4個字節所存放的值是: 0,1,2,3的ASC碼，即00110000,00110001,00110010,00110011所以，最後一步：顯示的是這４個字節的前５位，和 之後的２位分別為：10000,和01，因為int是有正負之分
-----------------------------------------------
