C_C++语言笔试面试题目含答案

1.

void Example(char acHello[]) {

printf(\"%d\ return; }

void main() {

char acHello[] = \"hello\"; Example(acHello); return; }

的输出是( )

A 4 B 5 C 6 D不确定

2.网络上传输的字节序默认是大字节的，如果主机是小字节序，在网络通信时则须进行字节序转换；如果主机是大字节序，为了程序的一致性及可移植性，最好也在程序中加上字节序转换的操作（空操作）。( ) A. 正确 B.错误 3. int *(*ptr)();

则以下叙述中正确的是( ) A) ptr是指向一维组数的指针变量 B) ptr是指向int型数据的指针变量

C) ptr是指向函数的指针,该函数返回一个int型数据

D) ptr是指向函数的指针,该函数的返回值是指向int型数据的指针 4.此函数实现把32位IP地址(网络序)以字符串的方式打印出来： char *IpAddr2Str(unsigned long ulIpAddr) {

char szIpAddr[32];

unsigned long ulLocIpAddr = ntohl(ulIpAddr);//把网络序转话为主机序 (void)VOS_sprintf(szIpAddr, \"%d.%d.%d.%d\

(ulLocIpAddr >> 16) & 0xff, (ulLocIpAddr >> 8) & 0xff, ulLocIpAddr & 0xff);

return szIpAddr; }

下面描述正确的是（）： A、数组szIpAddr空间不够；

B、函数返回局部数组szIpAddr变量地址； C、输出的IP地址次序颠倒； 5.

#define OK 0 #define ERR 1

#define ERROR (-1) #define BUFFER_SIZE 256

char *GetMemory(unsigned long ulSize) {

char *pcBuf = NULL;

pcBuf = (char *)malloc(ulSize); if(NULL == pcBuf) {

return ERROR; }

return pcBuf; }

void Test(void) {

char *pszBuf = NULL;

pszBuf = GetMemory(BUFFER_SIZE); if(NULL != pszBuf) {

strcpy(pszBuf, \"Hello World!\\r\\n\"); printf(pszBuf); free(pszBuf); }

return; }

如下描述正确的是：

A、pszBuf指向的内存不能超过255

B、GetMemory函数的异常分支返回了-1，是一个非法地址 C、GetMemory中异常分支没有释放空间；

D、pcBuf为局部指针，指向的内存将在GetMemory被调用后释放

6、#include \"stdio.h\"

unsigned short *Sum(unsigned char a, unsigned char b) {

unsigned short s = 0;

s = a + b; return &s; }

int main() {

unsigned short *p = NULL; unsigned char a = 1, b = 2;

p = Sum(a, b);

printf(\"%u+%u\ printf(\"=%u\\n\ return 0; }

程序执行结果是（）

A.1+2=0 B.1+2=3 C.1+2=NULL D.不可预测 7、设有如下定义: BOOL gStatusA = FALSE; BOOL gStatusB = TRUE; int gVarA = 100; int gVarB = 100;

则执行main函数后gVarA和gVarB的值分别为(

BOOL CheckA() {

if(gStatusA) {

gVarA++; } else {

gVarA--; }

return gStatusA; }

BOOL CheckB() {

if(gStatusB) {

gVarB++; } else {

gVarB--;

) }

return gStatusB; }

int main(int argc, char* argv[]) {

if(CheckA() && CheckB() ) {

printf(“Status OK”); } return 0; }

A, 99和100 B, 99和101 C 99和99 D 101和99

8.下面的代码中，函数Test执行完毕后，希望输出无符号长整型的1。 void VarInit(unsigned char *pucArg) {

*pucArg = 1; return; }

void Test() {

unsigned long ulGlobal; VarInit(&ulGlobal); printf(\"%lu\ return; }

下面描述正确的是：（ ）

A.给VarInit( )函数传递的参数类型错误 B.printf（）输出格式错误

C.传给VarInit( )中参数pucArg的值为空指针 9、

void AddFunc (unsigned int a, unsigned int b, unsigned int * c) {

*c = a + b； }

void main(void) {

unsigned char e = 200; unsigned char f = 100; unsigned char g = 0;

AddFunc((unsigned int)e,(unsigned int)f,(unsigned int *)&g);

printf(\"%d \}

下面说法正确的是（）：

A 对g进行类型转换导致函数调用时写内存越界； B 对e、f进行类型转换导致函数调用时写内存越界； C 函数调用时不能改变g的值。 10、void main(void) {

unsigned char a =200; unsigned char b =100; unsigned char c = 0; c=a+b;

printf(\"%d %d\}

下列程序的执行结果为() A 300 300 B 44 44 C 300 44 D 44 300

11、在X86，VC++6.0环境下，有下列程序 #include

int main() {

char cA;

unsigned char ucB; unsigned short usC;

cA = 128; ucB = 128;

usC = cA + ucB; printf(\"0x%x \

usC = cA + (short)ucB; printf(\"0x%x \

usC = (unsigned char)cA + ucB; printf(\"0x%x \

usC = cA + (char)ucB; printf(\"0x%x \

return 0;

}

输出结果是( )

A) 0x0 0x0 0x100 0xff00 B) 0x0 0x100 0x100 0xff00 C) 0x0 0x100 0x100 0x0 D) 0x0 0x0 0x100 0x0

12.switch(c)中的c的数据类型可以是char、long、float、unsigned、bool. ( ) A. 正确 B. 错误 13.void Example( ) {

int i;

char acNew[20];

for(i = 0; i < 10; i++) {

acNew[i] = '0'; }

printf(\"%d\\n\ return; }

的输出为( )

A 0 B 10 C 11 D不确定 14.如下程序用于把\"blue\"字符串返回： char *GetBlue(void) {

char* pcColor ; char* pcNewColor; pcColor = \"blue\";

pcNewColor = (char*)malloc(strlen(pcColor)); if(NULL == pcNewColor) {

return NULL; }

strcpy(pcNewColor, pcColor); return pcNewColor; }

下面描述正确的是：

A、字符串“blue”存放在栈内； B、函数GetBlue返回局部变量地址；

C、内存空间分配长度不够，strcpy函数拷贝越界； 15.给出以下定义:

char acX[ ]= \"abcdefg\";

char acY[ ]= {'a','b','c','d','e','f','g'}; 则正确的叙述为( )

A) 数组acX和数组acY等价 B) 数组acX和数组acY的长度相同 C) 数组acX的长度大于数组acY的长度 D) 数组acX的长度小于数组Y的长度 16.有以下程序段

char acArr[]= \"ABCDE\"; char *pcPtr;

for(pcPtr = acArr; pcPtr < acArr + 5; pcPtr++) {

printf(\"%s\\n\ } return;

输出结果是( )

A) ABCD B) A C) E D) ABCDE B D BCDE C C CDE D B DE E A E 17.void Example() {

int i;

char acNew[20] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

for(i = 0; i < 10; i++) {

acNew[i] = '0'; }

printf(\"%d\\n\ return; }

的输出为：( )

A 0 B 10 C 11 D不确定 18.如下程序用于把\"blue\"字符串打印出来： void PrintBlue() {

char pcBlue[] = {'b','l','u','e'}; printf(\"%s\ return; }

下面描述正确的是（）：

A、pcBlue数组初始化时没有字符串结束符； B、数组pcBlue定义时必须指明长度；

19.如下代码实现中，FuncA为每毫秒定时执行的函数，在该函数中，需要实现每TIME_INTERVAL毫秒执行一次DO_Something()的操作。

请指出段代码中的错误： #define ULONG unsigned long #define TIME_INTERVAL 200 void DoSomething(void) {

/*....*/ return; }

void FuncA ( ) {

static ULONG ulPreCall = 0 ; ULONG ulNowInMsHigh = 0 ; ULONG ulNowInMsLow = 0 ;

( VOID ) VOS_Tm_Now( &ulNowInMsHigh, &ulNowInMsLow ) ; /* 获取当前的时间,以毫秒为单位，用64bits表示， ulNowInMsHigh为高32位, ulNowInMsLow为低32位*/

if( ( 0 == ulPreCall ) || ( ulNowInMsLow >= (ulPreCall + TIME_INTERVAL) ) ) {

ulPreCall = ulNowInMsLow; } else {

return ; }

DoSomething();

return ; }

A、函数FUNC_A第一次被调用时，不执行Do_Something()操作； B、函数FUNC_A功能在一段时间后失效，因为ulNowInMsLow溢出翻转； C、ulPreCall不应该定义为静态变量； 20、

#define NULL 0 #define MEM_OK 0 #define MEM_ERR 1

enum ENUM_STAT_ITEM {

STAT_ITEM0, STAT_ITEM1, STAT_ITEM_BUTT

};

typedef struct tag_PERM_COUNT_STAT_INFO {

unsigned short stat_item ; unsigned short number; } _SPermCountStatInfo;

_SPermCountStatInfo pcsi[STAT_ITEM_BUTT] = {

{ STAT_ITEM0, 16000}, { STAT_ITEM1, 50000} , }

unsigned long *pulStatDataBuffer = NULL;

unsigned short AllocPermMemory(void) {

unsigned short usBufferSize = 0; unsigned short usLoop = 0;

for(usLoop = 0; usLoop < STAT_ITEM_BUTT; usLoop ++) {

usBufferSize += pcsi[usLoop].number ; }

pulStatDataBuffer = (unsigned long*)malloc(sizeof(unsigned long) * usBufferSize);

if (NULL == pulStatDataBuffer) {

return MEM_ERR; }

return MEM_OK; }

下面说法正确的是（）：

A unsigned short 类型不能表示循环体中将16000与50000相加的和66000 B 数组pcsi的number域是unsigned short类型，不能表示50000这么大的数字 C 循环条件应该改为usLoop<=STAT_ITEM_BUTT 21.请指出下面这段代码中的错误：

unsigned long FuncB ( unsigned long ulCount ) {

unsigned long ulSum = 0 ;

while( 0 <= ulCount )

{

ulSum += ulCount ; ulCount--; }

return ulSum ; }

void test(void) {

unsigned long ulTotal = 0; ulTotal=FuncB(10); printf(\"%lu\}

下面描述正确的是()： A、while循环判断始终为真； B、test打印输出55；

C、循环体内在执行2的32次方后，ulSum开始溢出翻转； 22.请指出下面程序的错误: void Test(void) {

char *szStr = (char *) malloc(100); if(NULL == szStr) {

return; }

strcpy(szStr, \"hello\"); free(szStr); if(NULL != szStr) {

strcpy(szStr, \"world\"); printf(\"%s\ } return; }

下面描述正确的是（ ）

A、strcpy没有将结尾符拷贝到szStr中 B、对释放空间的指针进行拷贝操作 C、szStr 被free后，szStr即为空。

23.#define BUFFER_SIZE 256 void GetMemory(char **ppszBuf) {

if(NULL == ppszBuf)

{

ASSERT(0); return ; }

*ppszBuf = (char *)malloc(BUFFER_SIZE); return; }

void Test(void) {

char *pszBuf=NULL; GetMemory(&pszBuf);

strcpy(pszBuf, \"hello world\\r\\n\"); printf(\"%s\ free(pszBuf); return; }

下面说法正确的是（）： A、pszBuf的值永远为NULL； B、malloc内存后没有判断是否成功； C、strcpy拷贝越界；

D、GetMemory无法将申请的内存地址传递给pszBuf；

24、请问下面函数中1、2、3应该填入什么语句才合理？（A、不添,不添，不添

B、free(pMsg); , free(ptmpMsg);,不添

C、free(pMsg);,free(ptmpMsg);,free(ptmpMsg); D、不添,free(pMsg);,free(ptmpMsg);

E、free(pMsg); ,free(pMsg); ,free(ptmpMsg); F、不添,不添,free(ptmpMsg);

#define COMM_MSG_LEN 100

char *GetMessageBuffer(int malloc_len) {

char *ptr=NULL;

ptr=(char *)malloc(malloc_len) return ptr; }

int FuncTest(void) {

int malloc_len = COMM_MSG_LEN; char *pMsg=NULL; char *ptmpMsg=NULL;

）

pMsg = GetMessageBuffer(malloc_len); if(NULL == pMsg) {

____1___ return ERROR; }

fillMessage(pMsg); sendMessage(pMsg);

ptmpMsg = GetMessageBuffer(malloc_len); if(NULL == ptmpMsg) {

____2___ return ERROR; }

FillMessage(ptmpMsg); SendMessage(ptmpMsg); free(pMsg); ____3___ return OK; }

25.以下叙述中不正确的是( )

A) 在不同的函数中可以使用相同名字的变量 B) 函数中的形式参数是在栈中保存

C) 在一个函数内定义的变量只在本函数范围内有效

D) 在一个函数内的复合语句中定义的变量在本函数范围内有效(复合语句指函数中的成对括号构成的代码)

26.全局变量可以定义在被多个.C文件包含着的头文件中。( ) A. 正确 B. 错误

27.在函数内部定义的变量(静态变量、寄存器变量等特殊变量除外)的内存是在栈内存中，所以在定义函数内部的变量的时候，一定要保证栈不能够溢出。如果临时变量占用空间较大，应该使用内存申请的方式，这样该变量指向的内存就是在堆内存中了。( ) A. 正确 B. 错误

28.局部变量可以和全局变量重名，编译的时候不会出现错误，但一旦不小心，就可能导致使用错误变量，所以在定时局部变量的时候，不要和全局变量重名。( ) A. 正确 B. 错误 29.设有如下定义:

unsigned long pulArray[] = {6, 7, 8, 9, 10}; unsigned long *pulPtr; 则下列程序段的输出结果为( ) pulPtr = pulArray; *(pulPtr + 2) += 2;

printf (\"%d,%d\\n\

A)8,10 B)6,8 C)7,9 D)6,10 30. struct stu {

int num; char name[10]; int age; };

void Fun(struct stu *p) {

printf(\"%s\\n\ return; }

void main() {

struct stu students[3]={ {9801,\"Zhang\ {9802,\"Wang\ {9803,\"Zhao\ Fun(students + 2); return; }

输出结果是( )

A) Zhang B)Zhao C) Wang D) 18 31.以下程序运行后,输出结果是( ) void main( ) {

char *szStr = \"abcde\"; szStr += 2;

printf(\"%lu \\n\ return; }

A cde B 字符c的ASCLL码值 C \"abcde\"这个常串中字符c所在的地址 D 出错 32.设有以下宏定义:

#define N 3

#define Y(n) ((N+1)*n) /*这种定义在编程规范中是不允许的，如果你在实际中这么用了，请自打手心三下*/

则执行语句:z = 2 * (N + Y(5 + 1));后,z的值为( ) A) 出错 B) 42 C) 48 D)54 33、有如下宏定义和结构定义 #define MAX_SIZE A+B struct _Record_Struct {

unsigned char Env_Alarm_ID :4;

unsigned char para1 :2; unsigned char state; unsigned char avail:1; } * Env_Alarm_Record ;

pointer = (struct _Record_Struct *)malloc( sizeof(struct _Record_Struct) * MAX_SIZE) ;

当A=2, B=3时pointer分配( )个字节的空间。 注意：机器是按照4字节对齐 A)20 B)15 C)11 D) 9

34、请问下面题目中a,b,c输出值为多少？（ ）

A、10,210,30 B、100,210,300 C、110,210,310 D、100,210,30 E、110,200,30

#include

#define FUNC(A) A++;\\ A *= 10;

int main(int argc, char* argv[]) {

int a = 10; int b = 20; int c = 30;

if(a > 10) FUNC(a);

if(b >= 20) FUNC(b);

if(c > 30) {

FUNC(c); }

printf(\"a=%d,b=%d,c=%d\\r\\n\ return 0; }

35.在X86下,有下列程序 #include void main() {

union {

int k; char i[2]; }*s,a; s = &a;

s->i[0] = 0x39; s->i[1] = 0x38; printf(\"%x\\n\ }

输出结果是( )

A) 3839 B) 3938 C) 380039 D) 36、#define MAX_MEM_SIZE 100 int GetMem(int iLen, void **ppMem) {

if(NULL==ppMem) {

return －1; }

if(iLen<=0) {

return 0; }

else if(iLen *ppMem=malloc(iLen); return iLen; } else {

*ppMem=malloc(MAX_MEM_SIZE); return MAX_MEM_SIZE; } }

void main() {

char *pMyMem; int i; int j;

i = GetMem(i, (void**)&pMyMem); if(NULL!=pMyMem)

不可预知 {

for(j=0; j pMyMem[j]=0; } } }

下面说法正确的有；（ ）

A、因为pMyMem未初始化，main函数中的GetMem可能会返回－1;

B、因为i未初始化，main函数中GetMem可能会返回比MAX_MEM_SIZE大的值; C、因为pMyMem未初始化，for循环内的赋值操作可能会导致写内存异常; D、无论pMyMem, i, j为何值时，main函数内都不会出现写内存异常； 37、#define MAX_MEM_SIZE 100 int GetMem(int iLen, void **ppMem) {

if(iLen<0) {

return -1; }

else if(0==iLen) {

return 0; }

else if(iLen *ppMem=malloc(iLen); return iLen; } else {

*ppMem=malloc(MAX_MEM_SIZE); return MAX_MEM_SIZE; } }

void main() {

char *pMyMem; int i,k; unsigned int j;

j=GetMem(i, &pMyMem); if(j>0) {

for(k=0; k pMyMem[k]=0; } } }

下面说法正确的有：

A、只要将pMyMem初始化为NULL，可以避免main函数内的for循环出现写内存异常； B、虽然i和pMyMem均未初始化，只要将if(j>0)改为if((0C、虽然i和pMyMem均未初始化，只要将main函数内的for循环比较由k二:多项选择题

1. 定义结构体时有下面几种说法，请指出正确的(多选)：___

A、结构体中的每个部分，最好进行四字节对齐； B、结构体的总长度最好是四字节对齐； C、结构中成员的存放不用考虑字节对齐情况；

2. 0x12345678 在采用BigEndian中内存的排列顺序是______,在采用LittleEndian内存中的排列顺序是______.

(答案从左到右内存地址依次增加)

A.12 34 56 78 B.34 12 78 56 C.78 56 34 12 D.56 78 12 34 3.下面程序期望输出str = hello world:

char * GetStr(char *p) {

p = \"hello world\"; return p; }

void main() {

char *str = NULL;

if(NULL != GetStr(str)) {

printf(\"\\r\\n str = %s\

} return; }

下面描述正确的是： A、str始终为NULL；

B、函数GetStr返回值始终不为空；

C、该程序无法得到预期的输出结果，因为GetStr函数无法将字符串地址带给实参；

4、下面程序期望得到 g_Variable的值，并打印出来。

unsigned char g_Variable;

void GetGlobalAddr(unsigned char *p) {

p = &g_Variable; }

void main() {

unsigned char *temp = NULL_PTR;

GetGlobalAddr(temp);

printf(\"\\r\\n Got global variable value = %u\ return; }

下面说法正确的是（）： A 对p强制类型转换错误；

B 调用函数时，局部变量p存在于栈中； C p值的改变不会影响temp；

D 调用函数后，temp的值被改变为g_Variable的地址。 5、

#define MAX_LEN 2

UC *ConvertCode(UC *pByte, UC num) {

UL i = 0;

UC strTemp[MAX_LEN];

if (NULL == pByte) {

return NULL; }

memcpy(strTemp, pByte, MAX_LEN); return (UC *)strTemp;

}

void main(void) {

UC str[MAX_LEN]; UC *p;

str[0] = 0x12; str[1] = 0x34;

p = ConvertCode(str, sizeof(str)); printf(\"%s\ return; }

下面查错的说明中，描述正确的是（）： A、输入参数p_byte为空指针 B、函数ConvertCode返回值没有判断

C、没有判断p_byte指向空间和MAX_LEN的大小 D、返回局部变量地址

6.下列定义正确的有(多选)：( ) A: char *pcPtr = \"abcd\"; B: char pc[4]= \"abcd\"; C: char pc[] = \"abcd\"; D: char pc[] = 'abcd';

E: char pc[] = {'a','b','c','d','\\0'}; F: char pc[] = 'a' 'b' 'c' 'd'; 7.

void GetMemory(char **ppcChar, int iLength) {

if(NULL == ppcChar) {

return; }

*ppcChar = (char *)malloc(iLength); return; }

void main(int argc, char* argv[]) {

char *szStr = NULL; int iLen = 100;

GetMemory(&szStr, iLen);

if(NULL != szStr) {

strcpy(szStr, \"hello\"); printf(szStr); } return; }

下面描述正确的是()：

A、iLength应该判断是否大于0； B、程序中使用魔鬼数字；

C、当szStr不为空时，没有释放分配的内存； D、printf(szStr)无法输出字符串

8.请指出下面程序问题 #define MAX_LEN 254

unsigned char Array[MAX_LEN]; int Test(void) {

int i;

for ( i = 0; i <= MAX_LEN; i++ ) {

Array[i] = i; } return; }

下面说法正确的是（）： A、i = MAX_LEN时，数组越界 B、argv参数形式错误 C、i = MAX_LEN时,赋值溢出 D、return无返回值

9、#include #include #include #define MAX_MSG_LEN 2048 BOOL MaxMsgFlag = FALSE; char *GetBuffer(int msg_len) {

char *ptr=NULL; int len =msg_len; ptr=(char *)malloc(len); if(NULL == ptr )

{

return NULL; }

return ptr; }

int main(int argc, char* argv[]) {

int msg_len ; char *pMsg;

if(TRUE == MaxMsgFlag) {

msg_len = MAX_MSG_LEN; }

pMsg = getBuffer(msg_len); if(NULL != pMsg ) {

strcpy(pMsg,\"I love this game !\"); printf(\"%s\ free(pMsg); }

return 0; }

上面的程序存在问题，下面描述正确的是（ ） A、函数getBuffer应该判断入参msg_len是否大于0。 B、按照编程规范，函数main中pMsg应该赋初值 C、函数main中msg_len没有赋初值

三:填空题

1.

char *pcColor = \"blue1\" ; char acColor[] = \"blue1\" ; strlen(pcColor) = _____ strlen(acColor) = _____ sizeof(pcColor) = _____ sizeof(acColor) = _____ 2.

char str[] = \"\\\\\\0\"; char *p = str; int n = 1000; 请计算

sizeof (str ) = ____________

sizeof ( p ) = ______________ sizeof ( n ) = ______________ 3.UCHAR *pucCharArray[10][10]; typedef union unRec {

ULONG ulIndex; USHORT usLevel[6]; UCHAR ucPos; }REC_S;

REC_S stMax,*pstMax;

四字节对齐方式时： sizeof(pucCharArray) = ______, sizeof(stMax)=_______, sizeof(pstMax)=________,sizeof(*pstMax)=________. 4.

UCHAR *pszTest = \"hello\"; UCHAR aucTest[] = \"hello\";

请问 sizeof(pszTest) = _____ , sizeof(*pszTest) = ______, sizeof(aucTest) = ______. 5.typedef struct tagTest {

UCHAR ucFlag; ULONG ulLen; }TEST_S;

TEST_S test[10];

四字节对齐方式时： sizeof(TEST_S) = __8___, sizeof(test)___80___. 6.typedef union unHead {

UCHAR aucSrc [6]; struct tagContent {

UCHAR ucFlag[3]; ULONG ulNext;// }Content; }HEAD_S;

32CPU,VC编译环境下：

在强制一字节对齐情况下，请指出sizeof(HEAD_S) = ______7_; 在强制二字节对齐情况下，请指出sizeof(HEAD_S) = __6______; 在强制四字节对齐情况下，请指出sizeof(HEAD_S) = ___8_____; 7. struct BBB {

long lNum;4 char *pcName;4 short sDate;2

char cHa[2];2 short sBa[6];6+2 }*p;

p = 0x100000;

p + 0x1 = 0x_100014___

(unsigned long)p + 0x1 = 0x_100004_____ (unsigned long *)p + 0x1 = 0x100004______ (char *)p + 0x1 = 0x_100004_____ 8.在4字节对齐的情况： typedef struct tagRec {

long lA1; 4 char cA2; 4 char cA3;4 long lA4;4 long lA5;4 } REC_S;

void main(int argc, char *argv[]) {

REC_S stMax ;

printf(\"sizeof(stMax)= %d\ return; }

输出结果为:

sizeof(stMax)=___20_ 9.struct tagAAA {

unsigned char ucId:1;4 unsigned char ucPara0:2;4 unsigned char ucState:6;8 unsigned char ucTail:4;4 unsigned char ucAvail;4 unsigned char ucTail2:4;4 unsigned long ulData;4 }AAA_S;

问：AAA_S在字节对齐分别为1、4的情况下，占用的空间大小是多少？19 32 10.#pragma pack(4)/*编译选项，表示4字节对齐*/ int main(int argc, char* argv[]) {

struct tagTest1 {

short a;4 char d; 4

long b; 4 long c; 4 16 };

struct tagTest2 12 {

long b; 4 short c; 2 char d;2 long a; 4 };

struct tagTest3 {

short c;4 long b;4 char d; 4 long a; 4 };

struct tagTest1 stT1; struct tagTest2 stT2; struct tagTest3 stT3;

printf(\"%d %d %d\ return 0; }

#pragma pack()（编译选项结束） 请问输出结果是：____16，12，16 11.union tagAAAA {

struct {

char ucFirst; short usSecond; char ucThird; }half; long lI; }number;

struct tagBBBB {

char ucFirst; short usSecond; char ucThird; short usForth; }half;

struct tagCCCC {

struct {

char ucFirst; short usSecond; char ucThird; }half; long lI; };

在字节对齐为1下，sizeof(union tagAAAA)、sizeof(struct tagBBBB)、sizeof(struct tagCCCC)是____ ____ _____

在字节对齐为4下，sizeof(union tagAAAA)、sizeof(struct tagBBBB)、sizeof(struct tagCCCC)是____ ____ _____

12.以下程序的输出的结果是___________ #pragma pack(4)/*四字节对齐*/ int main(int argc, char* argv[]) {

unsigned char puc[4]; struct tagPIM

unsigned char ucPim1; unsigned char ucData0:1; unsigned char ucData1:2; unsigned char ucData2:3; }*pstPimData;

pstPimData = (struct tagPIM *)puc; memset(puc, 0, 4);

{

//此时内存情况为： // ucPim1(8bits)->puc[0] // // pstPinData->00000000 <-puc[0] //对应puc[1]中的编号：ucData0->8; ucData1->6、7; ucData2->3、4、5 // 编号： 12345678 // 00000000 <-puc[1] // 00000000 <-puc[2] // 00000000 <-puc[3] pstPimData->ucPim1 = 1;

//执行完此步后，内存状况为： // pstPinData->00000001 <-puc[0] // 00000000 <-puc[1] // 00000000 <-puc[2] // 00000000 <-puc[3] pstPimData->ucData0 = 2;

//执行完此步后，内存状况为： // pstPinData->00000001 <-puc[0] // 00000000 <-puc[1] //因为ucData0只有1bit的空间而2的二进制为10，所以只保存了0，1溢出，丢掉 // 00000000 <-puc[2] // 00000000 <-puc[3] pstPimData->ucData1 = 3;

//执行完此步后，内存状况为： // pstPinData->00000001 <-puc[0] // 00000110 <-puc[1] 3为11 // 00000000 <-puc[2] // 00000000 <-puc[3] pstPimData->ucData2 = 4;

//执行完此步后，内存状况为： // pstPinData->00000001 <-puc[0] // 00100110 <-puc[1] 4为100 // 00000000 <-puc[2] // 00000000 <-puc[3] //所以至此puc[1]中为00100110，所以转换为16进制为26

printf(\"%02X %02X %02X %02X\\n\

//输出为： 01 26 00 00 return 0;

}

#pragma pack()/*恢复缺省对齐方式*/

13.下面的代码中，函数Test执行完毕后，打印的结果是 _____。 unsigned long g_ulGlobal = 0; void GlobalInit(unsigned long ulArg) {

ulArg = 0x01;

return; }

void Test() {

GlobalInit(g_ulGlobal); printf(\"%lu\

return; }

14.void main () {

unsigned long ulA = 0x11000000; printf(\"%x\ return; }

输出结果为： 15.struct tagABC {

char cB; short sC; char cD; long lA; }*pAbc;

pAbc = 0x100000;

那么pAbc+0x100 = 0x_________; (ULONG)pAbc + 0x100 = 0x_________;(ULONG *)pAbc + 0x100 = 0x_________;(char *)pAbc + 0x100 = 0x_______; 16.unsigned long FuncC ( unsigned long ulAction ) {

unsigned long ulResult = 0 ;

switch ( ulAction ) {

case ACTION_A: {

ulResult += 1 ; break ; }

case ACTION_B: {

ulResult += 1 ; } default: {

ulResult += 1 ; } }

printf( \"ulResult = %u\

return ulResult ;

}

当输入为ACTION_B时，输出结果为： ulResult = _________; 17.在VRP中，实现了strncpy类似的函数，定义如下: #define CHAR char

#define ULONG unsigned long #define VOID void

CHAR *VOS_strncpy(CHAR *pcDest, const CHAR *szSrc, ULONG ulLength) {

CHAR *pcPoint = pcDest;

if(( NULL == szSrc ) || ( NULL == pcDest ) ) {

return NULL; }

while(ulLength && (*pcPoint = *szSrc))/*这里采用了在判断语句中赋值的方式(*pcPoint = *szSrc)，建议尽量不使用*/ {

pcPoint++; szSrc++; ulLength--; }

if(!ulLength) {

*pcPoint = '\\0'; }

return pcDest; }

VOID main(VOID) {

CHAR szStrBuf[ ] = \"1234567890\"; CHAR szStrBuf1[ ] = \"1234567890\";

strncpy(szStrBuf, \"ABCD\ VOS_strncpy(szStrBuf1, \"ABCD\ printf(\"Str1 = %s\\nStr2 = %s\}

输出结果为： 18.

char acHello[] = \"hello\\0world\"; char acNew[15] = {0}; strcpy(acNew,acHello); strlen(acNew) = _____ sizeof(acHello) = ______

19.

char acHello[] = \"hello\\0world\"; char acNew[15] = {0}; memcpy(acNew,acHello,12); strlen(acNew) = _____ sizeof(acHello) = _____

20.以下程序的输出结果是________. #include int fun(int x,int y) {

static int m = 0; static int i = 2; i += m + 1; m = i + x + y; return m; }

void main() {

int j = 4; int m = 1; int k; k = fun(j, m); printf(\"%d,\ k=fun(j, m); printf(\"%d\\n\ return; }

21.以下程序的输出的结果是___________ int x = 3; void Incre(); void main() { int i;

for (i = 1; i < x; i++) { Incre(); } return; }

void Incre() {

static int x = 1; x *= (x + 1); printf(\"%d \

return; }

22.以下程序的输出结果为________

#define CIR(r) r*r /*请注意这种定义的缺陷，不允许这么定义*/ void main() {

int a = 1; int b = 2; int t;

t = CIR(a + b); printf(\"%d\\n\ return; }

23. enum ENUM_A {

X1, Y1, Z1 = 5, A1, B1 };

enum ENUM_A enumA = Y1; enum ENUM_A enumB = B1;

请问 enumA = ____; enumB = ______; 24、enum NEW_SERV_ID {

NSID_SERV_NULL = 0, ...

NSID_SERV254 = 254, NSID_SERV255 , NSID_BUTT };

unsigned char GetNsid(char nsid) {

return (nsid); }

GetNsid(NSID_SERV_NULL) = _____; GetNsid(NSID_SERV255) = _______; GetNsid(NSID_BUTT) = __.

答案 一:单项选择题

1 A 2A 3D 4B 5B 6D 7A 8A 9AC 10C 11A 12B 13D 14C 15C 16D 17B 18A 19B 20A 21A 22B 23B 24D 25D 26B 27A 28A 29D 30B 31C 32C 33D 34D 35D 36D 37D

二:多项选择题

1.AB 2AC 3ABC 4BC 5BCD 6ACE 7ABC 8AD 9AC

二:填空题 1. 5 5 4 6 2. 3 4 4

3. 400 12 4 12 4. 4 1 6 5. 8 80 6. 7 8 8

7. 100018

100001 100004 100001 8. 16

9. 9 12 10. 12 12 16 11. 4 6 8 8 8 12

12. 01 26 00 00 13. 0 14. 0

15. 100C00

100100 100400 100100 16. 2

17. Str1 = ABCD567890

Str2 = ABCD 18. 5 12 19. 5 12 20. 8， 17 21. 2 6 22. 5 23. 1,7

24. 0,255,0