C語言指針筆試題
C語言的模塊化程序結構用函數來實現，即將複雜的C程序分爲若干模塊，每個模塊都編寫成一個C函數，然後通過主函數調用函數及函數調用函數來實現一大型問題的C程序編寫，下面就由本站小編爲大家介紹一下C語言指針筆試題的文章，歡迎閱讀。
C語言指針筆試題篇1
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
if( ‘a’<=str[i] && str[i]<=’z’ )
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].
C語言指針筆試題篇2
1. 請問以下代碼有什麼問題：
int main
{
char a;
char *str=&a;
strcpy(str,”hello”);
printf(str);
return 0;
}
答案：沒有爲str分配內存空間，將會發生異常。問題出在將一個字符串複製進一個字符變量指針所指地址。雖然可以正確輸出結果，但因爲越界進行內在讀寫而導致程序崩潰。
2. char* s=”AAA”;
printf(“%s”,s);
s[0]=’B';
printf(“%s”,s);
有什麼錯?
答案：
“AAA”是字符串常量。s是指針，指向這個字符串常量，所以聲明s的時候就有問題。
cosnt char* s=”AAA”;
然後又因爲是常量，所以對是s[0]的賦值操作是不合法的。
3. int (*s[10])(int) 表示的是什麼?
答案：int (*s[10])(int) 函數指針數組，每個指針指向一個int func(int param)的函數。
4. 有以下表達式：
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; 禁止
5. #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操作很危險
博主：getmemory中p是形參，是一個指針變量，getmemory(str)調用後，傳入的是指針變量保存的對象地址，p=(char *) malloc(100)實際上是把申請的動態內存空間的首地址付給p指向的地址(即str指向的地址null)，這個是錯誤的。應該修改成指向指針的指針void getmemory(char **p)，這樣malloc返回的地址付給*p(即str變量本身)。
6 char szstr[10];
strcpy(szstr,”0123456789″);
產生什麼結果?爲什麼?
答案：長度不一樣，會造成非法的OS
C語言指針筆試題篇3
11.要對絕對地址0×100000賦值，我們可以用(unsigned int*)0×100000 = 1234;
那麼要是想讓程序跳轉到絕對地址是0×100000去執行，應該怎麼做?
答案：*((void (*)( ))0×100000 ) ( );
首先要將0×100000強制轉換成函數指針,即:
(void (*))0×100000
然後再調用它:
*((void (*))0×100000);
用typedef可以看得更直觀些:
typedef void(*) voidFuncPtr;
*((voidFuncPtr)0×100000);
12. 分析下面的程序：
void GetMemory(char **p,int num)
{ //p，指向指針的指針，*p，p指向的指針(即str)，**p，最終的對象，str指向的單元
*p=(char *)malloc(num); //申請空間首地址付給傳入的被p指向的指針，即str
}
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); 軟件開發網
getchar;
}
問輸出結果是什麼?
答案：輸出str is world。
free 只是釋放的str指向的內存空間,它本身的值還是存在的.所以free之後，有一個好的習慣就是將str=NULL.
此時str指向空間的內存已被回收,如果輸出語句之前還存在分配空間的操作的話,這段存儲空間是可能被重新分配給其他變量的,
儘管這段程序確實是存在大大的問題(上面各位已經說得很清楚了)，但是通常會打印出world來。
這是因爲，進程中的內存管理一般不是由操作系統完成的，而是由庫函數自己完成的。
當你malloc一塊內存的時候，管理庫向操作系統申請一塊空間(可能會比你申請的大一些)，然後在這塊空間中記錄一些管理信息(一般是在你申請的內存 前面一點)，並將可用內存的地址返回。但是釋放內存的時候，管理庫通常都不會將內存還給操作系統，因此你是可以繼續訪問這塊地址的。
a[10];
strlen(a)爲什麼等於15?
#include “stdio.h”
#include “string.h”
void main
{
char aa[10];
printf(“%d”,strlen(aa));
}
答案：sizeof和初不初始化，沒有關係;
strlen和初始化有關。
(*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 <
cout << aa.b2 <
}
輸出結果是多少?
答案：-16和1
首先sizeof(AA)的大小爲4,b1和b2分別佔5bit和2bit.經過strcpy和memcpy後,aa的4個字節所存放的值是: 0,1,2,3的ASC碼，即00110000,00110001,00110010,00110011所以，最後一步：顯示的是這4個字節的前5位，和 之後的2位分別爲：10000,和01，因爲int是有正負之分