上次說了一些有意思的面試題， 今天我們結著看看一些關于指針和sizeof的面試題：

下面是我看到的一些面試題

1、簡述   

  之間的區(qū)別。

   首先討論：
              char  * const p;   這里可以知道const修飾是指針變量p； 因此指針p的指向不能改變，這樣的變量定義必須首先初始化，否則將不能編譯通過。但是p指向的變量的存儲內容可以改變。

Exp：

     char chTest1;
                      char chTest2;
                      char  * const p=&chTest1;
                      // p=&chTest2;   這個地方是錯誤的,不能這樣賦值
                     *p=‘c’；
                     chTest1=‘b’；

   接下來討論：
              char const *p;     這里可以知道const修飾的是*p； 因此可以知道不能通過*p指向來改變變量的值； 但是指針p的指向可以改變，而且可以通過原變量進行改變值。
            

Exp：

這里可以知道： 

1）p的指向可以改變
2）不能通過*p= 某個值進行賦值
3）指針指向的變量的值自己可以改變。
    
最后討論：

const char  *p=&chTest1; 

這里可以知道const修飾的是*p；

因此這個與char const *p；

具有相同的效果。

Exp：

char chTest1;
               char chTest2;
               const char  *p=&chTest1;
               p=&chTest2;
               chTest1='a';
              // *p='a';  這個地方錯誤， 不能這樣修改值。

   總結：
         修飾符僅對其修飾的對象起作用，對別的變量不起作用。

6、以下代碼中的兩個sizeof用法有問題嗎？

  Exp：
     這個問題的考察點是sizeof的用法。那么我們應該如何看待這個問題呢？

1、這里首先我們需要知道的是sizeof 是個運算符， 它具有運算的優(yōu)先級別， 那么sizeof運算的優(yōu)先級在什么地方呢？

可以查看運算符優(yōu)先級的定義： sizeof 的優(yōu)先級和 *p（P為指針）、&p（變量，取地址）的優(yōu)先級一樣， 排在優(yōu)先級的第二位。

2、其次要明白sizeof關鍵字的作用

sizeof 關鍵字返回的是操作數(shù)在內存中占用的字節(jié)數(shù)。

這里要看sizeof操作符的操作對象：

1） 類型關鍵字

sizeof（int）：  這個取決系統(tǒng)的定義， 當在32位機器上時； sizeof int == 4
                            而在16位機器上時， sizeof int == 2
2） 變量

          int iTest；
          sizeof iTest；  這樣返回的是這種變量類型在內存中所占用的空間。
          即：sizeof iTest == sizeof int；

3） 字符串字面值

           sizeof 'abcd';
          那么返回的是：字符串在內存空進中占用的字節(jié)數(shù)。 這里我們知道'abcd'在內存中占用的是5個字節(jié)，那么很顯然有sizeof 'abcd'==5;

4) 數(shù)組
         這里有點難度
         char chTest[5];
        sizeof(chTest)==5; //這里可以知道chTest數(shù)組有5個元素，并且每個元素占用一個字節(jié)，因此sizeof（chTest）==5；

        那么如果我們這樣定義呢？
         int iTest[5];
        sizeof(iTest)= ?  // 答案是20 ， 因為有5個元素，每個元素占4個字節(jié)，所以占用20個字節(jié)的空間。
      
        二維數(shù)組呢？
         char chTest[10][20];
         sizeof(chTest)= ?  //200
        既然sizeof（chTest）==200； 那么sizeof(chTest[10])= ?  答案是 20 .
        
        又如：
         int iTest[10][20];
         sizeof(iTest)= ?  // 800
         同樣 sizeof(iTest[10])= ?  答案是 80 

       通過這里我們得出結論：
       對于sizeof操作數(shù)組的時候要分兩種情況：
a、 一維數(shù)組
           sizeof（數(shù)組名） 返回的是 數(shù)組元素個數(shù) * 每個元素占用的字節(jié)數(shù)
          sizeof（數(shù)組名[n]） 返回的是：數(shù)組類型定義的單個變量所占用的字節(jié)數(shù)
         即：
              int iTest[4];
          則
              sizeof(iTest)=14;
              sizeof[iTest[1]]=4;  
             
b、 多維數(shù)組
          sizeof（數(shù)組名）     返回的是：一維的長度*二維的長度*....* 每個元素占用的字節(jié)數(shù)
          sizeof（數(shù)組名[n]）  返回的是：其后面各位長度的乘積* 每個元素占用的字節(jié)數(shù)，
                              這樣必須保證sizeof的操作數(shù)沒有取到最后一維。
          即：int iTest[2][3][4];
                sizeof(iTest[2][3])= 4*sizeof[int]=16; 
c) 多維數(shù)組
         sizeof(數(shù)組變量定義式)；
         即：
          int iTest[2][3][4][5];
          sizeof(iTest[2][3][4][5])= ?  
         這里返回的是 數(shù)組的維數(shù) 就是 4 。
        
5、傳遞的是指針的時候
         如果操作的是指針那么情形又如何呢？
         這里也分兩種情形：

1）當操作數(shù)是指針本身的時候
         Exp：
            int *iTest；
          那么
            sizeof（iTest） = ？ //這里有一個規(guī)則，當sizeof操作變量的時候，返回的是變量本身的存儲長度， 因此
                                 //如果在16位的系統(tǒng)中， 這里返回2； 而在32位系統(tǒng)中返回的是4；
                      
2）當操作數(shù)有* 取值間接運算符號時
         Exp：
            int *iTest；
          那么
            sizeof（*iTest） = ？ // 這里返回的是 4， 其實返回的是sizeof（int）的長度； 即返回的是其指向的
                                  //變量類型的 所占用的空間
        可以用：
            float *fTest；
           sizeof（*fTest）= ？  // 這里返回的值是 4
           sizeof(fTest)= ?     //  取決于系統(tǒng)  16位的系統(tǒng)返回 2， 32位系統(tǒng)返回 4， 64位系統(tǒng)返回8 即地址總線的寬度。

      現(xiàn)在回到我們的問題：

 void UpperCase( char str[] ) // 將 str 中的小寫字母轉換成大寫字母 
           {    
                for( size_t i=0; i <sizeof(str)/sizeof(str[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;   

1、首先確定sizeof的語法問題：

2、接著確定邏輯有沒有問題
           我們先看： sizeof（str[0]）分析可知str[0]是個char的變量 ， 因此占用一個字節(jié)；
           再看：
                sizeof（str）；
           數(shù)組當做實參傳遞的時候，相當于傳的指針，在函數(shù)里面sizeof就是取指針所占的內存空間所以是4個字節(jié)，這樣是求不出整個數(shù)組的大小的！

3、 既然不能這樣求那么我們運行的時候怎樣才可以得到正確結果呢

使用strlen就可以

          這個可以在VC6.0中用下列代碼測試：
        Exp：

/*
 * test the sizeof key word
 *
 */
#include <stdio.h>
#include <conio.h>

#include <string.h>

 void UpperCase( char str[] )  
{   int i;
    printf('sizeof ：%d,%d',sizeof(str),sizeof(str[0]));

   printf('strlen ：%d',strlen(str));

    for(i=0; i< strlen(str)-1 ;++i )
        if( 'a' <=str[i] && str[i] <='z' )
               str[i] -= ('a'-'A' );
}
int main(int argc,char *argv[])
{
    char  chTest[]='abcd';
    printf('%d\n',sizeof(chTest));
    UpperCase(chTest);

   puts（chTest）；// 因為我們知道chTest[4]='\0'. 所以雖然沒有傳遞，但是還是可以實現(xiàn)轉換的功能
    getch();
}

   通過這個例子可以看出來， 有些時候確實不是我們想的那樣，