C语言编程基础考试试题

文档名称 文档密级

C语言编程基础考试

[考前说明]本题目中不考虑头文件引用问题(假定已经包含正确的头文件)，C语言的标准函数都可用；如果不特别说明，

假定程序运行环境为：操作系统Windows 2000, VC6.0编译环境，缺省为四字节对齐，X86(80586)CPU处理器(32位小字节序处理器). 一、单选题

1、 给出以下定义:

char acX[ ]= \

char acY[ ]= {'a','b','c','d','e','f','g'};

则正确的叙述为( )

A) 数组acX和数组acY等价 B) 数组acX和数组acY的长度相同 C) 数组acX的长度大于数组acY的长度 D) 数组acX的长度小于数组Y的长度

2、 void example(char acHello[])

{

printf(\ return; }

void main()

{

char acHello[] = \ example(acHello); return;

}

的输出是( )

A 4 B 5 C 6 D不确定

3、 以下叙述中不正确的是( )

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

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

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

4、 设有如下定义:

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

1

文档名称 文档密级

*(pulPtr + 2) += 2;

printf (\

A)8,10 B)6,8 C)7,9 D)6,10

5、 有以下程序段

char acArr[]= \ char *pcPtr;

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

printf(\ }

return;

输出结果是( )

A) ABCD B) A C) E D) ABCDE B D BCDE C C CDE D B DE E A E

6、 void example( )

{

int i;

char acNew[20];

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

acNew[i] = '0'; }

printf(\ return; }

的输出为( D )

A 0 B 10 C 11 D不确定

7、 switch(c)中的c的数据类型可以是char、long、float、unsigned、bool. ( )

A. 正确 B. 错误

8、 全局变量可以定义在被多个.C文件包含着的头文件中。( )

A. 正确 B. 错误

9、 struct stu

{

int num; char name[10];

2

文档名称 文档密级

int age; };

void fun(struct stu *p) {

printf(\ return; }

void main() {

struct stu students[3]={ {9801,\ {9802,\ {9803,\ fun(students + 2); return; }

输出结果是( )

A) Zhang B)Zhao C) Wang D) 18

10、 以下程序运行后,输出结果是( )

void main( )

{

char *szStr = \ szStr += 2;

printf(\ return; }

A cde B 字符c的ASCLL码值 C \这个常串中字符c所在的地址 D 出错

11、 在X86下,有下列程序

#include void main() {

union {

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

s->i[0] = 0x39; s->i[1] = 0x38;

printf(\ }

3

文档名称 文档密级

输出结果是( )

A) 3839 B) 3938 C) 380039 D) 不可预知

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

13、 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(\ return; }

的输出为：( )

A 0 B 10 C 11 D不确定

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

15、 局部变量可以和全局变量重名，编译的时候不会出现错误，但一旦不小心，

就可能导致使用错误变量，所以在定时局部变量的时候，不要和全局变量重名。( )

A. 正确 B. 错误

16、 设有以下宏定义: #define N 3

#define Y(n) ((N+1)*n) /*这种定义在编程规范中是严格禁止的*/ 则执行语句:z = 2 * (N + Y(5 + 1));后,z的值为( ) A) 出错 B) 42 C) 48 D)54

17、 int *(*ptr)();

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

4

文档名称 文档密级

B) ptr是指向int型数据的指针变量

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

D) ptr是指向函数的指针,该函数的返回值是指向int型数据的指针

18、 0x12345678 在采用BigEndian中内存的排列顺序是______,在采用LittleEndian内存中的排列顺序是______. (答案从左到右内存地址依次增加)

A.12 34 56 78 B.34 12 78 56 C.78 56 34 12 D.56 78 12 34

19、 请指出下面程序问题

#define MAX_LEN 254

unsigned char Array[MAX_LEN]; int main(int argc, char *argv[]) {

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无返回值

20、 #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);

5

文档名称 文档密级

strcpy(pszBuf, \ printf(\ free(pszBuf); return;

}

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

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

21、 如下程序用于把\字符串打印出来：

void PrintBLUE() {

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

}

下面描述正确的是（）：

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

22、 请指出下面这段代码中的错误：

unsigned long FUNC_B ( unsigned long ulCount ) {

unsigned long ulSum = 0 ;

while( 0 <= ulCount ) {

ulSum += ulCount ; ulCount--; }

return ulSum ; }

void test(void)

{

unsigned long ulTotal = 0; ulTotal=FUNC_B(10); printf(\}

下面描述正确的是()：

6

文档名称 文档密级

A、while循环判断始终为真； B、test打印输出55；

C、循环体内在执行2的32次方后，ulSum开始溢出翻转；

23、 此函数实现把32位IP地址(网络序)以字符串的方式打印出来：

char *IpAddr2Str(unsigned long ulIpAddr)

{

char szIpAddr[32];

unsigned long ulLocIpAddr = ntohl(ulIpAddr);//把网络序转话为主机序 (void)VOS_sprintf(szIpAddr, \ (ulLocIpAddr >> 16) & 0xff, (ulLocIpAddr >> 8) & 0xff, ulLocIpAddr & 0xff);

return szIpAddr; }

下面描述正确的是（）：

A、数组szIpAddr空间不够；

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

24、 如下程序用于把\字符串返回：

char *GetBLUE(void) {

char* pcColor ; char* pcNewColor;

pcColor = \

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

return NULL;

}

strcpy(pcNewColor, pcColor); return pcNewColor; }

下面描述正确的是：

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

C、内存空间分配长度不够，strcpy函数拷贝越界；

25、 如下代码实现中，FUNC_A为每毫秒定时执行的函数，在该函数中，需要

实现每TIME_INTERVAL毫秒执行一次DO_Something()的操作。 请指出段代码中的错误： #define ULONG unsigned long #define TIME_INTERVAL 200

7

文档名称 文档密级

void DO_Something(void) {

/*....*/ return; }

void FUNC_A ( )

{

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 ; }

DO_Something(); return ; }

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

26、 下面的代码中，函数Test执行完毕后，希望输出1。请指出错误：

void VarInit(unsigned char *pucArg) {

*pucArg = 1; return; } void Test()

{

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

下面描述正确的是：（ ）

8

文档名称 文档密级

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

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

27、 #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, \ printf(pszBuf); free(pszBuf); }

return;

}

如下描述正确的是：

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

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

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

28、 void AddFunc (unsigned int a, unsigned int b, unsigned int * c)

{

*c = a + b; }

void main(void) {

unsigned char e = 200;

9

文档名称 文档密级

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

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

}

下面说法正确的是（）：

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

29、 #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 shrot 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; }

10

文档名称 文档密级

return MEM_OK; }

下面说法正确的是（）：

A unsigned short 类型不能表示循环体中将16000与50000相加的和66000 B 数组pcsi的number域是unsigned short类型，不能表示50000这么大的数字 C 循环条件应该改为usLoop<=STAT_ITEM_BUTT

30、 设有如下定义: 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”);

11

文档名称 文档密级

return 0; }

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

31、 请问下面函数中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 *get_message_buffer(int malloc_len) {

char *ptr=NULL;

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

int func_test(void) {

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

pMsg=get_message_buffer(malloc_len); if(NULL == pMsg) { }

____1___

return ERROR;

fillMessage(pMsg);

sendMessage(pMsg);

ptmpMsg=get_message_buffer(malloc_len); if(NULL == ptmpMsg) { }

12 ____2___

return ERROR;

}

文档名称 文档密级

fillMessage(ptmpMsg); sendMessage(ptmpMsg); free(pMsg); ____3___ return OK;

32、 请问下面题目中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); }

33、 #define MAX_MEM_SIZE 100

int GetMem(int iLen, void **ppMem) {

if(NULL==ppMem) {

return -1;

13 }

printf(\return 0;

}

文档名称 文档密级

if(iLen<=0) {

return 0; }

else if(iLen

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

else {

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

void test() {

char *pMyMem; int i; int j;

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

for(j=0; j

pMyMem[j]=0; }

} }

下面说法正确的有；（ ）

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

B、因为i未初始化，test函数中GetMem可能会返回比MAX_MEM_SIZE大的值; C、因为pMyMem未初始化，for循环内的赋值操作可能会导致写内存异常; D、无论pMyMem, i, j为何值时，test函数内都不会出现写内存异常；

34、 #define MAX_MEM_SIZE 100

int GetMem(int iLen, void **ppMem) {

if(iLen<0)

14

文档名称 文档密级

{

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 test() {

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，可以避免test函数内的for循环出现写内存异常； B、虽然i和pMyMem均未初始化，只要将if(j>0)改为if((0

C、虽然i和pMyMem均未初始化，只要将test函数内的for循环比较由k

D、上面三种说法都不对。

15

文档名称 文档密级

35、 #define BUF_LEN 2048

struct AAA

{

ULONG ulLen; //指示buf中实际占用字节数 CHAR buf[BUF_LEN]; //存储缓冲区

};

函数PrintBufLen的作用是打印出结构体中的buf的实际占用长度,有下面两种实现方法： 方法一：

VOID PrintBufLen(struct AAA* pBuf) {

if(NULL == pBuf)

{

printf(\ return; }

printf(\ return; }

方法二：

VOID PrintBufLen(struct AAA Buf) {

printf(\ return;

}

以下说法只有一个正确的是：（ ）

A:优选方法一，原因是以指针作为入参，减少函数参数压栈的系统开销。 B:优选方法二，原因是可以不做入参合法性判断，不容易出错。 C:两种方法差不多，可以任意选择。 D:以上说法都不对。

36、 void main(void)

{

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

c=a+b; printf(\}

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

16

文档名称 文档密级

D 44 300

37、 有如下宏定义和结构定义

#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

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

int main() { }

17 char c;

unsigned char uc; unsigned short us; c = 128; uc = 128; us = c + uc; printf(%us = c + (short)uc; printf(\

us = (unsigned char)c + uc; printf(%us = c + (char)uc; printf(\return 0;

文档名称 文档密级

输出结果是( )

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

39、 #include \

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(\printf(\return 0;

程序执行结果是（ ）

A.1+2=0 B.1+2=3 C.1+2=NULL D.不可预测

二、多选题

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

if(NULL == ppcChar)

{

return; }

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

}

void main( ) {

char *szStr = NULL;

GetMemory(&szStr, 100); if(NULL != szStr) {

18

文档名称 文档密级

strcpy(szStr, \ printf(szStr); }

return;

}

下面描述正确的是()：

A、iLength应该判断是否大于0；

B、程序中使用魔鬼数字；

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

41、 下面程序期望输出str = hello world:

char * GetStr(char *p) {

p = \ return p; }

void main() {

char *str = NULL;

if(NULL != GetStr(str)) {

printf(\ } return;

}

下面描述正确的是：

A、Str始终为NULL；

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

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

42、 下面程序期望得到 global_variable的值，并打印出来。 unsigned char global_variable; void GetGlobalAddr(unsigned char *p) {

p = &global_variable; }

void main()

{

unsigned char *temp = NULL_PTR; GetGlobalAddr(temp);

19

文档名称 文档密级

printf(\ return;

}

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

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

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

43、 #define MAX_LEN 2

_UC *ConvertCode(_UC *p_byte, _UC num) {

_UL i = 0;

_UC strTemp[MAX_LEN];

if (NULL == p_byte) {

return NULL; }

memcpy(strTemp, p_byte, MAX_LEN); return (_UC *)strTemp; }

void main(void) {

_UC str[MAX_LEN]; _UC *p; str[0] = 0x12;

str[1] = 0x34;

p=ConvertCode(str, MAX_LEN); printf(\ return 0;

}

下面说明中，描述正确的是（）： A、输入参数p_byte为空指针

B、函数ConvertCode返回值没有判断 C、没有判断p_byte空间和MAX_LEN的大小 D、返回局部变量地址

44、 #include #include #include #define MaxMsgLen 2048 BOOL MaxMsgFlag = FALSE;

20

文档名称 文档密级

char *get_buffer(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 = MaxMsgLen;

}

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

strcpy(pMsg,\ printf(\ free(pMsg); } return 0;

}

上面的程序存在问题，下面描述正确的是（ ）

A、函数get_buffer没有判断入参msg_len是否大于等于0。 B、函数main中pMsg没有赋初值

C、函数main中msg_len没有赋初值

D、函数main中free(pMsg)后，没有把pMsg置为NULL。

45、 请指出下面程序的错误:（ ） void Test(void)

{

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

return; }

strcpy(szStr, \

21

文档名称 文档密级

free(szStr); if(NULL != szStr)

{

strcpy(szStr, \ printf(szStr); }

return; }

A、strcpy没有将结尾符拷贝到szStr中 B、对释放空间的指针进行拷贝操作 C、printf随机打印

D、没有返回值

46、 定义结构体时有下面几种说法，请指出正确的___

A、结构体中的每个部分，最好进行四字节对齐； B、结构体的总长度最好是四字节对齐；

C、结构中成员的存放不用考虑字节对齐情况；

47、 下列定义正确的有( )

A: char *pcPtr = \ B: char pc[4]= \ C: char pc[] = \

D: char pc[] = 'abcd';

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

三、填空:

48、 char *pcColor = \

char acColor[] = \strlen(pcColor) = _____ strlen(acColor) = _____ sizeof(pcColor) = _____ sizeof(acColor) = _____ 5 5 4 6

49、 char str[] = \

char *p = str; int n = 1000; 请计算

sizeof (str ) = ____________ sizeof ( p ) = ______________ sizeof ( n ) = ______________ 3 4 4

22

文档名称 文档密级

50、 UCHAR *pucCharArray[10][10];

typedef union unRec {

ULONG ulIndex; USHORT UCHAR

usLevel[6]; ucPos;

}REC_S;

REC_S stMax,*pstMax;

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

400 12 4 12 {

51、 typedef union unHead

UCHAR aucSrc [6]; struct tagContent {

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

32CPU,VC编译环境下：

在强制一字节对齐情况下，请指出sizeof(HEAD_S) = ________; 在强制二字节对齐情况下，请指出sizeof(HEAD_S) = ________; 在强制四字节对齐情况下，请指出sizeof(HEAD_S) = ________; 7 8 8

52、 UCHAR *pszTest = \

UCHAR aucTest[] = \

请问 sizeof(pszTest) = _____ , sizeof(*pszTest) = ______, sizeof(aucTest) = ______.

4 1 6

53、 struct BBB

{

long lNum; char *pcName; short sDate; char cHa[2]; short sBa[6]; }*p;

p = 0x100000;

23

文档名称 文档密级

p + 0x1 = 0x____

(unsigned long)p + 0x1 = 0x______ (unsigned long *)p + 0x1 = 0x______ (char *)p + 0x1 = 0x______ 100018 100001 100004 100001

54、 在4字节对齐的情况：

typedef struct tagRec {

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

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

REC_S stMax ;

printf(\ return; }

输出结果为: sizeof(stMax)=____ 16

55、 void main ()

{

unsigned long ulA = 0x11000000;

printf(\ return; }

输出结果为： 0

56、 在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 ) ))

24

文档名称 文档密级

{

return NULL; }

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

{

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

if(!ulLength) {

*pcPoint = '\\0'; }

return pcDest; }

VOID main(VOID) {

CHAR szStrBuf[ ] = \ CHAR szStrBuf1[ ] = \

strncpy(szStrBuf, \

VOS_strncpy(szStrBuf1, \ printf(\}

输出结果为： ABCD567890 ABCD

57、 char acHello[] = \

char acNew[15] = {0}; strcpy(acNew,acHello); strlen(acNew) = _____ sizeof(acHello) = ______ 5 12

58、 typedef struct tagTest

{

UCHAR ULONG }TEST_S;

25 ucFlag; ulLen;

文档名称 文档密级

TEST_S test[10];

四字节对齐方式时： sizeof(TEST_S) = ______, sizeof(test)________. 8 80

59、 struct tagAAA

{ unsigned char ucId:1; unsigned char ucPara0:2; unsigned char ucState:6; unsigned char ucTail:4; unsigned char ucAvail;

unsigned char ucTail2:4; unsigned long ulData; }AAA_S;

问：AAA_S在字节对齐分别为1、4的情况下，占用的空间大小是多少？ 9 12

60、 #pragma pack(4)/*编译选项，表示4字节对齐*/

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

struct tagTest1 {

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

struct tagTest2 {

long b; short c; char d;

long a; };

struct tagTest3 {

short c; long b;

char d; long a; };

struct tagTest1 stT1; struct tagTest2 stT2;

26

文档名称 文档密级

struct tagTest3 stT3;

printf(\ return 0; }

#pragma pack()（编译选项结束） 请问输出结果是：_________ 12 12 16

61、 enum ENUM_A

1 7

62、 以下程序的输出结果是________.

#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(\ k=fun(j, m); printf(\ return; }

27 {

X1, Y1,

Z1 = 5, A1, B1 };

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

请问 enumA = ____; enumB = ______;

8 17

文档名称 文档密级

63、 以下程序的输出结果为________

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

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

t = CIR(a + b); printf(\ return; } 5

64、 char acHello[] = \

char acNew[15] = {0}; memcpy(acNew,acHello,12); strlen(acNew) = _____ sizeof(acHello) = _____ 5 12

65、 union tagAAAA

{

struct {

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

struct tagBBBBB {

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

struct tagCCCC {

28

文档名称 文档密级

struct {

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

};

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

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

4 6 8 8 8 12

66、 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_______;

100C00 100100 100400 100100

67、 unsigned long FUNC_C ( unsigned long ulAction )

{

unsigned long ulResult = 0 ;

switch ( ulAction ) {

case ACTION_A: {

ulResult += 1 ; break ; }

case ACTION_B: {

29

文档名称 文档密级

ulResult += 1 ; } default: {

ulResult += 1 ; } }

printf( \

return ulResult ;

}

当输入为ACTION_B时，输出结果为： ulResult = _________; 2

68、 下面的代码中，函数Test执行完毕后，打印的结果是 _____。

unsigned long g_ulGlobal = 0; void GlobalInit(unsigned long ulArg) {

ulArg = 0x01;

return; }

void Test() {

GlobalInit(g_ulGlobal); printf(\ return; } 0

69、 以下程序的输出的结果是___________

int x = 3; void incre(); void main()

{ int i;

for (i = 1; i < x; i++) {

incre(); }

return; }

30

文档名称 文档密级

void incre() {

static int x = 1; x *= (x + 1); printf(\ return; } 2 6

70、 以下程序的输出的结果是___________

#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);

pstPimData->ucPim1 = 1; pstPimData->ucData0 = 2; pstPimData->ucData1 = 3; pstPimData->ucData2 = 4;

printf(\ return 0; }

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

71、 enum NEW_SERV_ID

{

NSID_SERV_NULL = 0, ...

NSID_SERV254 = 254, NSID_SERV255 , NSID_BUTT

31

文档名称 文档密级

};

unsigned char GetNsid(char nsid) {

return (nsid); }

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

三、指出下列程序中导致不能出现预期结果的唯一错误(不考虑编程规范错误)

72、 下面程序把\这个字符串输出，请指出其中的错误。

void Test(void) {

char pcArray[10];

strncpy(pcArray,\ printf(\ return;

}

strncpy没有把中止符NULL写入数组中

73、 如下程序用于把\系统备板工作异常\字符串打印出来，请指出其中的错

误：

void PrintErrInfo(void) {

char acMsg[16];

strcpy(acMsg,\系统备板工作异常\ printf(\ return;

}

每个汉字占两个字节，空间不足，字符串结尾还有'\\0'

74、 如下函数实现打印字符串\的功能，请指出错误： #define BUFFER_SIZE 256 void GetMemory(char *pszBuf) {

if(NULL == pszBuf) {

ASSERT(0); return ; }

32

文档名称 文档密级

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

void Test(void) {

char *pszBuf = NULL; GetMemory(pszBuf); if(NULL == pszBuf) {

return ; }

strcpy(pszBuf, \ printf(\ free(pszBuf); return;

}

函数要返回指针就需要传进去指针的地址

75、 如下函数实现打印字符串\的功能，请指出错误：

char *GetMemory(void)

{

char pcBuf[] = \ return pcBuf; }

void Test(void) {

char *pcStr = NULL; pcStr = GetMemory(); if(NULL == pcStr)

{

printf(\ return; } else {

printf(\ }

return; }

要打印的字符串存在于栈内存,可能不会正确打印

76、 下面程序把\这个字符串输出，请指出其中的错误。

void PrintBLUE(void)

33

文档名称 文档密级

{

char* pcColor ; char pcNewColor[5]; pcColor = \

strncpy(pcNewColor, pcColor,4); printf(\ return;

}

strncpy没有把中止符NULL写入数组中

77、 请指出下面程序错误的地方:

LONG A() {

if (条件1) {

return; }

return VOS_OK; } VOID B() {

if (A())

{

DoSomeThing1(); } else {

DoSomeThing2(); } return; }

return语句少了返回值

78、 本题不考虑魔鬼数字问题

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;

34

}

文档名称 文档密级

unsigned char g = 0;

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

g是一个字节的变量，将g的地址强制转换成四个字节unsigned int地址,导致写内存越界

79、 找出下面题目中的错误

#define ID_LEN struct STR_A { }

32

char aucID[ID_LEN]; int iA;

struct STR_B { }

// 该函数将pstB内的paucID指向结构stA的aucID

void funcA(struct STR_A stA, struct STR_B *pstB) {

pstB->paucID = stA.aucID; char *paucID; int iB;

}

main() {

STR_A stA = {0}; STR_B stB;

strcpy(stA.aucID, “12345”); funcA(stA, &stB);

printf(“%s\\n”, stB.paucID);

}

funcA传入的stA的参数是一个值拷贝，pstB指向的是堆栈中的地址。

80、 以下函数主要目的是为一个全局空间迅速填充指定字符garbage，请指出有错误的地方 #define MAX_LEN 20 char pBuffer[MAX_LEN]; unsigned char garbage=0x4E;

int longfill(const char *pv, unsigned char b)

35

{

文档名称 文档密级

unsigned short val = 0;

/* 用4 个字节拼成一个长字 */

val = (b<<24) | (b<<16) | (b<<8) | b; }

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

int i = 0;

int len = MAX_LEN/4;

for(i=0;i

return 0;

*(unsigned long *)pv= val; return 0;

val溢出

81、 指出下面程序的错误

VOID B(ULONG *p) {

*p = 66 * 10000; return; }

VOID A() {

unsigned short a ＝ 10*1000; B((ULONG *)(&a)); return; }

字符越界/溢出

82、 #define MAX_LEN 2

void ConvertCode(_UC *p_byte, _UC num) {

_UL i = 0;

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

p_byte[i] = ((p_byte[i] & 0xF0) >> 4) | ((p_byte[i] & 0x0F) << 4); } }

void main(void)

36

{

文档名称 文档密级

_UC * str = NULL_PTR; ConvertCode(str, MAX_LEN); }

ConvertCode函数没有进行入参的有效性判断

83、 请指出下面函数的性能问题

#define MAX_PRAM_LENGTH 10000 typedef struct {

unsigned char ucCommand;

unsigned short usLength; unsigned char Para[MAX_PRAM_LENGTH]; } DEBUG_MSG;

void PringDebugMsg (DEBUG_MSG DebugMessage) {

int i;

printf(\

for (i = 0 ; i < DebugMessage.usLength && i < MAX_PRAM_LENGTH; i++) { }

printf(\

}

使用超大结构数组变量作为参数，有可能将栈顶爆，导致程序异常。

37

本文来源：https://www.bwwdw.com/article/oai3.html