作為IT行業人士需要掌握的最基本的計算機語言—c語言，如今的地位只高不低，c語言掌握程度的高低往往在面試的時候可以完全表現出來，而有些問題是大家平時似乎是知道的，但卻不能完整準確地回答上來的，小編當年也遇到了很多此類問題，所以今天大家帶來精心整理的C語言經典面試題 ，希望對大家有所幫助。
溫馨提示：文章末尾有亮點！
已保存
預處理
問題一：什麼是預編譯？何時需要預編譯？
答：預編譯又稱預處理，是整個編譯過程最先做的工作，即程序執行前的一些預處理工作。主要處理#開頭的指令。如拷貝#include包含的文件代碼、替換#define定義的宏、條件編譯#if等。.
何時需要預編譯：
1、總是使用不經常改動的大型代碼體。
2、程序由多個模塊組成，所有模塊都使用一組標準的包含文件和相同的編譯選項。在這種情況下，可以將所有包含文件預編譯為一個預編譯頭。
問題二：寫一個“標準”宏，這個宏輸入兩個參數並返回較小的一個
答:#define MIN(x, y) ((x)
問題三：#與##的作用？
答：#是把宏參數轉化為字符串的運算符，##是把兩個宏參數連接的運算符。
例如：
#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
問題四：如何避免頭文件被重複包含？
答：
例如，為避免頭文件my_head.h被重複包含，可在其中使用條件編譯：
#ifndef _MY_HEAD_H
#define _MY_HEAD_H /*空宏*/
/*其他語句*/
#endif
關鍵字
問題一：static關鍵字的作用？
答：
Static的用途主要有兩個，一是用於修飾存儲類型使之成為靜態存儲類型，二是用於修飾鏈接屬性使之成為內部鏈接屬性。
1.靜態存儲類型：
在函數內定義的靜態局部變量，該變量存在內存的靜態區，所以即使該函數運行結束，靜態變量的值不會被銷燬，函數下次運行時能仍用到這個值。
在函數外定義的靜態變量——靜態全局變量，該變量的作用域只能在定義該變量的文件中，不能被其他文件通過extern引用。
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();
問題三：volatile關鍵字的作用？
答：
volatile指定的關鍵字可能被系統、硬件、進程/線程改變，強制編譯器每次從內存中取得該變量的值，而不是從被優化後的寄存器中讀取。例子:硬件時鐘;多線程中被多個任務共享的變量等。
問題四：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
}
4. 不可以將extern"C" 添加在函數內部
5. 如果函數有多個聲明，可以都加extern"C", 也可以只出現在第一次聲明中，後面的聲明會接受第一個鏈接指示符的規則。
6. 除extern"C", 還有extern "FORTRAN" 等。
問題五：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
結構體
問題一：結構體的賦值？
答：
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;/*結構變量間直接賦值*/
問題二：結構體變量如何比較？
答：雖然結構體變量之間可以通過=直接賦值，但不同通過比較符如==來比較，因為比較符只作用於基本數據類型。這個時候，只能通過int memcmp(const void *s1, const void *s2, size_t n);來進行內存上的比較。
問題三：結構體位域
答：
位域是一個或多個位的字段，不同長度的字段（如聲明為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個二進制位即可，省時省空間。
位域的缺點：
不同系統對位域的處理可能有不同的結果，如位段成員在內存中是從左向右分配的還是從右向左分配的，所以位域的使用不利於程序的可移植性。
問題四：結構體成員數組大小為0
結構體數組成員的大小為0是GNU C的一個特性。好處是可以在結構體中分配不定長的大小。如
typedef struct st
{
inta;
int b;
char c[0];
}st_t;
sizeof(st_t)等於8，即char c[0]的大小為0.
#define SIZE 100
st_t *s = (st_t *)malloc(sizeof(st_t) + SIZE);
函數
問題一：函數參數入棧順序
答：
C語言函數參數入棧順序是從右向左的，這是由編譯器決定的，更具體的說是函數調用約定決定了參數的入棧順序。C語言採用是函數調用約定是__cdecl的，所以對於函數的聲明，完整的形式是：int __cdecl func(int a, int b);
問題二：inline內聯函數
答：
inline關鍵字僅僅是建議編譯器做內聯展開處理，即是將函數直接嵌入調用程序的主體，省去了調用/返回指令。
內存分配回收
問題一： malloc/free與new/delete的區別
答：
1) malloc與free是C/C++語言的標準庫函數，new/delete是C++的運算符。它們都可用於申請動態內存和釋放內存。
2) 對於非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由於malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加於malloc/free。因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
我們不要企圖用malloc/free來完成動態對象的內存管理，應該用new/delete。由於內部數據類型的“對象”沒有構造與析構的過程，對它們而言malloc/free和new/delete是等價的。
3) 既然new/delete的功能完全覆蓋了malloc/free，為什麼C++不把malloc/free淘汰出局呢？這是因為C++程序經常要調用C函數，而C程序只能用malloc/free管理動態內存。
如果用free釋放“new創建的動態對象”，那麼該對象因無法執行析構函數而可能導致程序出錯。如果用delete釋放“malloc申請的動態內存”，結果也會導致程序出錯，但是該程序的可讀性很差。所以new/delete必須配對使用，malloc/free也一樣。
問題二：malloc(0)返回值
答：如果請求的長度為0，則標準C語言函數malloc返回一個null指針或不能用於訪問對象的非null指針，該指針能被free安全使用。
可變參數列表
可變參數列表是通過宏來實現的，這些宏定義在stdarg.h頭文件，它是標準庫的一部分。這個頭文件聲明瞭一個類型va_list和三個宏：va_start、va_arg和va_end。
typedef char *va_list;
#define va_start(ap, A) (void)((ap) = (char *)&(A) + _Bnd(A, _AUPBND))
#define va_arg(ap, T) (*(T )((ap) += _Bnd(T, _AUPBND)) - _Bnd(T, _ADNBND)))
#define va_end(ap) (void)0
int print(char *format, …)
宏va_start的第一個參數是va_list類型的變量，第二個參數是省略號前最後一個有名字的參數，功能是初始化va_list類型的變量，將其值設置為可變參數的第一個變量。
宏va_arg的第一個參數是va_list類型的變量，第二個參數是參數列表的下一個參數的類型。va_arg返回va_list變量的值，並使該變量指向下一個可變參數。
宏va_end是在va_arg訪問完最後一個可變參數之後調用的。
問題一：實現printf函數
* A simple printf function. Only support the following format:
* Code Format
* %c character
* %d signed integers
* %i signed integers
* %s a string of characters
* %o octal
* %x unsigned hexadecimal
*/
int my_printf( const char* format, ...)
{
va_list arg;
int done = 0;
va_start (arg, format);
while( *format != '')
{
if( *format == '%')
{
if( *(format+1) == 'c' )
{
char c = (char)va_arg(arg, int);
putc(c, stdout);
} else if( *(format+1) == 'd' || *(format+1) == 'i')
{
char store[20];
int i = va_arg(arg, int);
char* str = store;
itoa(i, store, 10);
while( *str != '') putc(*str++, stdout);
} else if( *(format+1) == 'o')
{
char store[20];
int i = va_arg(arg, int);
char* str = store;
itoa(i, store, 8);
while( *str != '') putc(*str++, stdout);
} else if( *(format+1) == 'x')
{
char store[20];
int i = va_arg(arg, int);
char* str = store;
itoa(i, store, 16);
while( *str != '') putc(*str++, stdout);
} else if( *(format+1) == 's' )
{
char* str = va_arg(arg, char*);
while( *str != '') putc(*str++, stdout);
}
// Skip this two characters.
format += 2;
} else {
putc(*format++, stdout);
}
}
va_end (arg);
return done;
}
其他
問題一：ASSERT()的作用
答:ASSERT()是一個調試程序時經常使用的宏，在程序運行時它計算括號內的表達式，如果表達式為FALSE (0), 程序將報告錯誤，並終止執行。如果表達式不為0，則繼續執行後面的語句。這個宏通常原來判斷程序中是否出現了明顯非法的數據，如果出現了終止程序以免導致嚴重後果，同時也便於查找錯誤。例如，變量n在程序中不應該為0，如果為0可能導致錯誤，你可以這樣寫程序：
......
ASSERT( n != 0);
k = 10/ n;
.....
ASSERT只有在Debug版本中才有效，如果編譯為Release版本則被忽略。
assert()的功能類似，它是ANSI C標準中規定的函數，它與ASSERT的一個重要區別是可以用在Release版本中。
問題二：system("pause");的作用
答:系統的暫停程序，按任意鍵繼續，屏幕會打印，"按任意鍵繼續。。。。。"省去了使用getchar（）；
問題三：請問C++的類和C裡面的struct有什麼區別？
答:c++中的類具有成員保護功能，並且具有繼承，多態這類oo特點，而c裡的struct沒有。c裡面的struct沒有成員函數,不能繼承,派生等等.
找錯題
試題一：
void test1()
{
char string[10];
char* str1 = "0123456789";
strcpy(string, str1);
}
解答：字符串str1有11個字節（包括末尾的結束符''），而string只有10個字節，故而strcpy會導致數組string越界。
試題二：
void test2()
{
char string[10], str1[10];
int i;
for(i=0; i<10; i++)
{
str1= 'a';
}
strcpy(string, str1);
}
解答：因為str1沒有結束符''，故而strcpy複製的字符數不確定。strcpy源碼如下：
[cpp] view plain copy
- #include
- char *strcpy(char *s1, cosnt char *s2)
- {
- char *s = s1;
- for (s = s1; (*s++ = *s2++) != '';)/*最後的結束符''也會被複制*/
- ;
- return s1;
- }
試題三：
void test3(char* str1)
{
char string[10];
if(strlen(str1) <= 10 )
{
strcpy(string, str1);
}
}
解答：應修改為if (strlen(str1) < 10)，因為strlen的結果未統計最後的結束符''。strlen的源碼如下：
[cpp] view plain copy
- #include
- size_t strlen(const char *s)
- {
- const char *sc;
- for (sc = s; *sc != ''; ++sc)/*不包含最後的結束符''*/
- ;
- return (sc - s);
- }
試題四：
void GetMemory(char *p)
{
p = (char *)malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory(str);
strcpy(str,"hello world");
printf(str);
}
解答：C語言中的函數參數為傳值參數，在函數內對形參的修改並不能改變對應實參的值。故而調用GetMemory後，str仍為NULL。
試題五：
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf(str);
}
解答：GetMemory中，p為局部變量，在函數返回後，該局部變量被回收。故而str仍為NULL
試題六：
void GetMemory( char **p, int num )
{
*p = (char *)malloc(num);
}
void Test( void )
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
解答：試題6避免了試題4的問題，但在GetMemory內，未對*p為NULL情況的判斷。當*p不為NULL時，在printf後，也未對malloc的空間進行free
試題七：
void Test( void )
{
char *str = (char *)malloc( 100 );
strcpy(str, "hello" );
free(str);
... //省略的其它語句
}
解答：未對str為NULL的情況的判斷，在free(str)後，str未設置為NULL，可能變成一個野指針（後面對str的操作可能會導致踩內存）。
試題八：
swap(int* p1,int* p2)
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
解答：在swap函數中，p是個野指針，可能指向系統區，導致程序運行的崩潰。故而，程序應改為：
swap(int* p1,int* p2)
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
寫在最後
喜歡此篇文章或覺得這篇文章對你有幫助的讀者可以點播關注或者轉發，私信小編001即可獲得小編自己整理的一份2018最新的C/C++資料和0基礎入門教程，歡迎初學和進階中的小夥伴
閱讀更多 ccc雲志 的文章
