1 預處理

問題1：什麼是預編譯？何時需要預編譯？

答：

預編譯又稱預處理，是整個編譯過程最先做的工作，即程式執行前的一些預處理工作。主要處理#開頭的指令。如拷貝#include包含的檔案程式碼、替換#define定義的巨集、條件編譯#if等。.

何時需要預編譯：

1、總是使用不經常改動的大型程式碼體。

2、程式由多個模組組成，所有模組都使用一組標準的包含檔案和相同的編譯選項。在這種情況下，可以將所有包含檔案預編譯為一個預編譯頭。

 

問題2：寫一個“標準”巨集，這個巨集輸入兩個引數並返回較小的一個

答:#define MIN(x, y) ((x)<(y)?(x):(y)) //

結尾沒有;

 

問題3：#與##的作用？

答：#是把巨集引數轉化為字串的運算子，##是把兩個巨集引數連線的運算子。

例如：

#define STR(arg) #arg          則巨集STR(hello)展開時為”hello”

#define NAME(y) name_y      則巨集NAME(1)展開時仍為name_y

#define NAME(y) name_##y    

則巨集NAME(1)展開為name_1

#define DECLARE(name, type) typename##_##type##_type，

則巨集DECLARE(val, int)展開為int val_int_type

問題4：如何避免標頭檔案被重複包含？

答：

例如，為避免標頭檔案my_head.h被重複包含，可在其中使用條件編譯：

#ifndef _MY_HEAD_H

#define _MY_HEAD_H    /*空巨集*/

/*其他語句*/

#endif

2 關鍵字

問題1：static關鍵字的作用？

答：

Static

的用途主要有兩個，一是用於修飾儲存型別使之成為靜態儲存型別，二是用於修飾連結屬性使之成為內部連結屬性。

1靜態儲存型別：

在函式內定義的靜態區域性變數，該變數存在記憶體的靜態區，所以即使該函式執行結束，靜態變數的值不會被銷燬，函式下次執行時能仍用到這個值。

在函式外定義的靜態變數——靜態全域性變數，該變數的作用域只能在定義該變數的檔案中，不能被其他檔案通過extern引用。

2 內部連結屬性

       靜態函式只能在宣告它的原始檔中使用。

問題2：const關鍵字的作用？

答：

1宣告常變數，使得指定的變數不能被修改。

const int a = 5;/*a的值一直為5，不能被改變*/

const int b; b = 10;/*b的值被賦值為10後，不能被改變*/

const int *ptr; /*ptr為指向整型常量的指標，ptr的值可以修改，但不能修改其所指向的值*/

int *const ptr;/*ptr為指向整型的常量指標，ptr的值不能修改，但可以修改其所指向的值*/

const int *const ptr;/*ptr為指向整型常量的常量指標，ptr及其指向的值都不能修改*/

2修飾函式形參，使得形參在函式內不能被修改，表示輸入引數。

如int fun(const int a);或int fun(const char *str);

3修飾函式返回值，使得函式的返回值不能被修改。

const char *getstr(void);使用：const *str= getstr();

const int getint(void);  使用：const int a =getint();

問題3：volatile關鍵字的作用？

答：

volatile指定的關鍵字可能被系統、硬體、程序/執行緒改變，強制編譯器每次從記憶體中取得該變數的值，而不是從被優化後的暫存器中讀取。例子:硬體時鐘;多執行緒中被多個任務共享的變數等。

問題4：extern關鍵字的作用？

答：

1用於修飾變數或函式，表明該變數或函式都是在別的檔案中定義的，提示編譯器在其他檔案中尋找定義。

extern int a;

extern int *p;

extern int array[];

extern void fun(void);

其中，在函式的宣告帶有關鍵字extern，僅僅是暗示這個函式可能在別的原始檔中定義，沒有其他作用。如：

標頭檔案A：A_MODULE.h中包含

extern int func(int a, int b);

原始檔A: A_MODULE.c中

#include “A_MODULE.h”

int func(int a, int b)

{

         returna+b;

}

此時，展開標頭檔案A_MODULE.h後，為

extern int func(int a, int b);/*雖然暗示可能在別的原始檔中定義，但又在本檔案中定義，所以extern並沒有起到什麼作用，但也不會產生錯誤*/

int func(int a, int b)

{

         returna+b;

}

而原始檔B：B_MODULE.c中，

#include “A_MODULE.h”

int ret = func(10,5);/

展開標頭檔案A_MODULE.h後，為

extern int func(int a, int b);/*暗示在別的原始檔中定義，所以在下面使用func(5,10)時，在連結的時候到別的目標檔案中尋找定義*/

int ret = func(10,5);

2 用於extern “c

extern “c”的作用就是為了能夠正確實現C++程式碼呼叫其他C語言程式碼。加上extern "C"後，會指示編譯器這部分程式碼按C語言的編譯方式進行編譯，而不是C++的。

C++作為一種與C相容的語言，保留了一部分面向過程語言的特點，如可以定義不屬於任何類的全域性變數和函式，但C++畢竟是一種面向物件的語言，為了支援函式的過載，對函式的編譯方式與C的不同。例如，在C++中，對函式void fun(int,int)編譯後的名稱可能是_fun_int_int，而C中沒有過載機制，一般直接利用函式名來指定編譯後函式的名稱，如上面的函式編譯後的名稱可能是_fun。

這樣問題就來了，如果在C++中呼叫的函式如上例中的fun(1,2)是用C語言在原始檔a_module.c中實現和編譯的，那麼函式fun在目標檔案a_module.obj中的函式名為_fun，而C++在原始檔b_module.cpp通過呼叫其對外提供的標頭檔案a_module.h引用後，呼叫fun，則直接以C++的編譯方式來編譯，使得fun編譯後在目標檔案b_module.obj的名稱為_fun_int_int，這樣在連結的時候，因為_fun_int_int的函式在目標檔案a_module.obj中不存在，導致了連結錯誤。

解決方法是讓b_module.cpp知道函式fun是用C語言實現和編譯了，在呼叫的時候，採用與C語言一樣的方式來編譯。該方法可以通過extern “C”來實現（具體用法見下面）。一般，在用C語言實現函式的時候，要考慮到這個函式可能會被C++程式呼叫，所以在設計標頭檔案時，應該這樣宣告標頭檔案：

/*標頭檔案a_module.h*/

/*標頭檔案被CPP檔案include時，CPP檔案中都含有該自定義的巨集__cplusplus*/

/*這樣通過extern “C”告訴C++編譯器，extern “C”{}裡包含的函式都用C的方式來編譯*/

#ifdef __cplusplus 

extern “C”

{

#endif

extern void fun(int a, int b);

#ifdef __cplusplus

}

#endif

extern "C"的使用方式

1. 可以是單一語句

   extern "C" doublesqrt(double);

2. 可以是複合語句, 相當於複合語句中的宣告都加了extern "C"

    extern "C"

    {

        double sqrt(double);

        int min(int, int);

    }

3.可以包含標頭檔案，相當於標頭檔案中的宣告都加了extern"C"

   extern "C"

   {

       #include <cmath>

  }

4. 不可以將extern"C" 新增在函式內部

5. 如果函式有多個宣告，可以都加extern"C", 也可以只出現在第一次宣告中，後面的宣告會接受第一個連結指示符的規則。

6. 除extern"C", 還有extern "FORTRAN" 等。

問題5：sizeof關鍵字的作用？

答：

sizeof是在編譯階段處理，且不能被編譯為機器碼。sizeof的結果等於物件或型別所佔的記憶體位元組數。sizeof的返回值型別為size_t。

變數：int a;  sizeof(a)為4；

指標：int *p;  sizeof(p)為4；

陣列：int b[10]; sizeof(b)為陣列的大小，4*10；int c[0]; sizeof(c)等於0

結構體：struct (int a; char ch;)s1; sizeof(s1)為8 與結構體位元組對齊有關。

注意：不能對結構體中的位域成員使用sizeof

sizeof(void)等於1

sizeof(void *)等於4

3 結構體

問題1：結構體的賦值？

答：

C語言中對結構體變數的賦值或者在初始化或者在定義後按欄位賦值。

方式1：初始化

struct tag

{

     chara;

   int b;

}x = {‘A’, 1};/*初始化*/

或

struct tag

{

char a;

int b;

};

struct tag x = {‘A’,1};/*在定義變數時初始化*/

GNU C中可使用另外一種方式：

struct tag

{

char a;

int b;

}x =

{

.a = ‘A’,

.b =1;

};

或

struct tag

{

char a;

int b;

};

struct tag x =

{

     .a= ‘A’,

   .b=1,

};

方式2：定義變數後按欄位賦值

struct tag

{

char a;

int b;

};

struct tag x;/*定義變數*/

x.a = ‘A’;/*按欄位賦值*/

x.b = 1; /*按欄位賦值*/

而當你使用初始化的方式來賦值時，如x = {‘A’,1};則出錯。

方式3：結構變數間的賦值

struct tag

{

     chara;

   int b;

};

struct tag x,y;

x.a=’A’;

x.b=1;

y = x;/*結構變數間直接賦值*/

問題2：結構體變數如何比較？

答：雖然結構體變數之間可以通過=直接賦值，但不同通過比較符如==來比較，因為比較符只作用於基本資料型別。這個時候，只能通過int memcmp(const void *s1, const void *s2, size_t n);來進行記憶體上的比較。

問題3：結構體位域

答：

位域是一個或多個位的欄位，不同長度的欄位（如宣告為unsigned int型別）儲存於一個或多個其所宣告型別的變數中（如整型變數中）。

位域的型別：可以是char、short、int，多數使用int，使用時最好帶上signed或unsigned

位域的特點：欄位可以不命名，如unsignedint :1;可用來填充；unsigned int :0; 0寬度用來強制在下一個整型（因此處是unsigned int型別）邊界上對齊。

位域的定義：

struct st1

{

unsigned chara:7;/*欄位a佔用了一個位元組的7個bit*/

unsigned charb:2;/*欄位b佔用了2個bit*/

unsigned charc:7;/*欄位c佔用了7個bit*/

}s1;

sizeof(s1)等於3。因為一個位域欄位必須儲存在其位域型別的一個單元所佔空間中,不能橫跨兩個該位域型別的單元。也就是說，當某個位域欄位正處於兩個該位域型別的單元中間時，只使用第二個單元，第一個單元剩餘的bit位置補（pad）0。

於是可知Sizeof(s2)等於3*sizeof(int)即12

struct st2

{

unsigned inta:31;

unsigned intb:2;/*前一個整型變數只剩下1個bit，容不下2個bit，所以只能存放在下一個整型變數*/

unsigned int c:31;

}s2;

位域的好處：

       1.有些資訊在儲存時，並不需要佔用一個完整的位元組， 而只需佔幾個或一個二進位制位。例如在存放一個開關量時，只有0和1 兩種狀態，用一位二進位即可。這樣節省儲存空間，而且處理簡便。這樣就可以把幾個不同的物件用一個位元組的二進位制位域來表示。
        2.可以很方便的利用位域把一個變數給按位分解。比如只需要4個大小在0到3的隨即數，就可以只rand()一次，然後每個位域取2個二進位制位即可，省時省空間。

位域的缺點：

不同系統對位域的處理可能有不同的結果，如位段成員在記憶體中是從左向右分配的還是從右向左分配的，所以位域的使用不利於程式的可移植性。

問題4：結構體成員陣列大小為0

結構體陣列成員的大小為0是GNU C的一個特性。好處是可以在結構體中分配不定長的大小。如

typedef struct st

{

        inta;

int b;

char c[0];

}st_t;

sizeof(st_t)等於8，即char c[0]的大小為0.

相關推薦