C语言编程基础考试

注意：以下所有选择题均为不定项选择题，参考答案在最下面，仅供参考。

在该平台上所有基本数据类型的缺省对齐边界等于类型长度。

第01题

以下描述正确的有：
A.1个字节有4比特
B.1个字节有8比特
C.1个字节有16比特
D.1个字节有几比特和字节序有关
E.1个字节有几比特和CPU是32位还是64位有关

第02题

STATIC ULONG g_ulA = ~0UL;STATIC ULONG g_ulB = (ULONG)-1L;STATIC ULONG g_ulC = 0xFUL;STATIC ULONG g_ulD = ~0xFUL;STATIC ULONG g_ulE = ~0UL >> 4;STATIC ULONG g_ulF = ~(~0UL >> 4);

关于以上程序描述正确的有：
A.g_ulA是和CPU字长等长掩码，所有位均为1
B.g_ulB是和CPU字长等长掩码，所有位均为1
C.g_ulC是和CPU字长等长掩码，低4位为1，其余位为0
D.g_ulB是和CPU字长等长掩码，低4位为0，其余位为1
E.g_ulB是和CPU字长等长掩码，高4位为0，其余位为1
F.g_ulB是和CPU字长等长掩码，高4位为1，其余位为0

第03题

typedef UINT * PUINT;int main(VOID){    UINT uiData;    const UINT *puiA;    UINT * const puiB;    const PUINT puiC;    puiA = &uiData;    *puiA = 100U;    puiB = &uiData;    *puiB = 200U;    puiC = &uiData;    *puiC = 300U;    return 0;}

关于以上程序描述正确的有：
A.第011行有编译错误
B.第012行有编译错误
C.第014行有编译错误
D.第015行有编译错误
E.第017行有编译错误
F.第018行有编译错误

第04题

/* 代码I */ INT main(VOID){    ULONG ulA = 0;    while(ulA < 20)    {        if(10 == ulA)        {            continue;        }        else        {            break;        }        ulA++;    }    printf("%lu\r\n", ulA);    return 0;}/* 代码II */INT main(VOID){    ULONG ulA = 0;    while(ulA < 20)    {        if(10 == ulA)        {            break;        }        else        {            continue;        }        ulA++;    }    printf("%lu\r\n", ulA);    return 0;}

关于以上程序描述正确的有：
A.代码I，输出结果为0
B.代码I，输出结果为10
C.代码I，输出结果为20
D.代码II，输出结果为0
E.代码II，输出结果为10
F.代码II，输出结果为20

第05题

INT main(VOID){    const UINT uiData = 0;    UINT *puiData;    puiData = &uiData;    *puiData = 100U;    printf("%u\r\n", uiData);    return 0;}

关于以上程序描述正确的有：
A.程序无法执行，第006行有编译错误
B.程序无法执行，第007行有编译错误
C.程序无法执行，第009行有编译错误
D.程序可以执行，输出结果为0
E.程序可以执行，输出结果为100
F.程序可以执行，输出结果为随机值

第06题
以下描述正确的有：
A.无符号两字节的值域为0~65536
B.有符号两字节类型的值域为-32767~32768
C.有符号一字节类型，2进制11111111表示-1
D.有符号一字节类型，2进制10000000表示-127
E.有符号一字节类型，2进制11110110表示-10

第07题

typedef struct tagMsg{    UINT    uiVar;    USHORT  usData;}MSG_S;/* 修改I */typedef struct tagMsg{    UINT    uiVar;    USHORT  usData;    USHORT  usDataNew;  /* 新增数据 */}MSG_S;/* 修改II */typedef struct tagMsg{    UINT    uiVar;    USHORT  usData;    USHORT  usRes;    USHORT  usDataNew;  /* 新增数据 */}MSG_S;/* 接收方处理步骤 */{    /*1.本地结构初始化*/    /*2.本地结构转字节序*/    /*3.将消息内容拷贝到本地结构，长度取消息结构和本地结构两者长度的较小值*/    /*4.本地结构转字节序*/}

关于通信结构的扩展和兼容，以下描述正确的有：
A.多字节数据要做字节序转换，否则会导致大/小字节序环境不兼容
B.不应该出现ULONG类型数据，否则会导致32/64为环境不兼容
C.不应该出现指针类型数据，因为在不同地址空间共享指针没有意义
D.对以上MSG_S通信结构体新增数据usDataNew，应采用修改I的方式
E.对以上MSG_S通信结构体新增数据usDataNew，应采用修改II的方式
F.采用以上‘接收方处理步骤’，可以实现新老版本间通信结构的扩展和兼容

第08题

VOID SetData(IN const VOID *pData){    UINT uiData;    uiData = *(UINT *)pData;    printf("%#X\r\n", uiData);    return;}INT main(VOID){    ULONG ulData = 0xAABBCCDDUL;    SetData(&ulData);    return 0;}

关于以上程序描述正确的有：
A.32位小字节序环境，输出结果为0XDDCCBBAA
B.32位大字节序环境，输出结果为0XDDCCBBAA
C.64位小字节序环境，输出结果不确定
D.64位大字节序环境，输出结果为0

第09题

/* 代码I */#define MUL(uiX, uiY)   (uiX * uiY)INT main(VOID){    printf("%u\r\n", MUL(2U+3U, 5U+8U));        return 0;}/* 代码II */#define ADD(uiX, uiY)   (uiX) + (uiY)INT main(VOID){    printf("%u\r\n", ADD(2U, 3U) * ADD(5U, 8U));    return 0;}

关于以上程序描述正确的有：
A.代码I，输出结果为25
B.代码I，输出结果为33
C.代码I，输出结果为65
D.代码II，输出结果为25
E.代码II，输出结果为33
F.代码II，输出结果为65

第10题

#define BYTESWAP_8(ucData)      (((UINT)(ucData) & 0xF0U) >> 4 | \                                 ((UINT)(ucData) & 0x0FU) << 4)#define BYTESWAP_16_1(usData)   (((UINT)(usData) & 0xF000U) >> 4 | \                                 ((UINT)(usData) & 0x0F00U) << 4 | \                                 ((UINT)(usData) & 0x00F0U) >> 4 | \                                 ((UINT)(usData) & 0x000FU) << 4)#define BYTESWAP_16_2(usData)   (((UINT)(usData) & 0xF000U) >> 12 | \                                 ((UINT)(usData) & 0x0F00U) >> 4  | \                                 ((UINT)(usData) & 0x00F0U) << 4  | \                                 ((UINT)(usData) & 0x000FU) << 12)#define BYTESWAP_32_1(uiData)   (((UINT)(uiData) & 0xFF000000U) >> 8 | \                                 ((UINT)(uiData) & 0x00FF0000U) << 8 | \                                 ((UINT)(uiData) & 0x0000FF00U) >> 8 | \                                 ((UINT)(uiData) & 0x000000FFU) << 8)#define BYTESWAP_32_2(uiData)   (((UINT)(uiData) & 0xFF000000U) >> 24 | \                                 ((UINT)(uiData) & 0x00FF0000U) >> 16 | \                                 ((UINT)(uiData) & 0x0000FF00U) << 16 | \                                 ((UINT)(uiData) & 0x000000FFU) << 24)

关于以上程序描述正确的有：
A.BYTESWAP_8可以完成8位变量的字节序转换操作
B.BYTESWAP_16_1可以完成16位变量的字节序转换操作
C.BYTESWAP_16_2可以完成16位变量的字节序转换操作
D.BYTESWAP_32_1可以完成32位变量的字节序转换操作
E.BYTESWAP_32_2可以完成32位变量的字节序转换操作
F.以上程序均不是正确的字节序转换操作

第11题

/* HASH桶个数 */#define HASH_SIZE   1024UL/* HASH算法: 将aucMac[MAC_ADDR_LEN]映射到[0-1023] *//* 代码I */ULONG HashKeyI(IN const UCHAR aucMac[MAC_ADDR_LEN]){    ULONG ulData;    ulData = (UCHAR)(aucMac[0] + aucMac[1] + aucMac[2] + aucMac[3] + aucMac[4] + aucMac[5]);    return ulData / HASH_SIZE;}/* 代码II */ULONG HashKeyII(IN const UCHAR aucMac[MAC_ADDR_LEN]){    ULONG ulData;    ulData = (UCHAR)(aucMac[0] + aucMac[1] + aucMac[2] + aucMac[3] + aucMac[4] + aucMac[5]);    return ulData % HASH_SIZE;}/* 代码III */ULONG HashKeyIII(IN const UCHAR aucMac[MAC_ADDR_LEN]){    ULONG ulData;    ulData = aucMac[0] + aucMac[1] + aucMac[2];    return ulData % HASH_SIZE;}/* 代码IV */ULONG HashKeyIV(IN const UCHAR aucMac[MAC_ADDR_LEN]){    ULONG ulData;    ulData = ((ULONG)aucMac[4] << 8) | aucMac[5];    return ulData % HASH_SIZE;}/* 代码V */ULONG HashKeyV(IN const UCHAR aucMac[MAC_ADDR_LEN]){    ULONG ulData;    ulData = ((ULONG)aucMac[0] << 8) | aucMac[1];    return ulData % HASH_SIZE;}

关于以上5个HASH算法描述正确的有：
A.代码I，HASH算法相对最优
B.代码II，HASH算法相对最优
C.代码III，HASH算法相对最优
D.代码IV，HASH算法相对最优
E.代码V，HASH算法相对最优

第12题

/* 表项 */typedef struct tagEntry{    UINT uiIndex;   /* 索引 */    UINT uiData;    /* 数据 */}ENTRY_S;/* 代码I */ENTRY_S *CodeI_Alloc(IN UINT uiIndex){    ENTRY_S *pstNew;    pstNew = malloc(sizeof(ENTRY_S));    if (NULL != pstNew)    {        memset(pstNew, 0, sizeof(ENTRY_S));        pstNew->uiIndex = uiIndex;    }    return pstNew;}/* 代码II */VOID CodeII_Free(IN ENTRY_S *pstEntry){    DBGASSERT(NULL != pstEntry);    free(pstEntry);    return;}/* 代码III */VOID CodeIII_Print(IN const CHAR *pcModule, IN const CHAR *pcFmt, ...);

关于以上程序需要添加LINT规则，描述正确的有：
A.代码I，应添加规则-sem(CodeI_Alloc, @P==malloc(8))
B.代码II，应添加规则-function(free, CodeII_Free(1))
C.代码III，应添加规则-printf(1, CodeIII_Print)

第13题

typedef struct tagData_1{    #if (__BYTE_ORDER == __LITTLE_ENDIAN)        UCHAR ucA : 1;        UCHAR ucB : 2;        UCHAR ucC : 3;    #else        UCHAR ucC : 3;        UCHAR ucB : 2;        UCHAR ucA : 1;    #endif}DATA_1_S;typedef struct tagData_2{    #if (__BYTE_ORDER == __LITTLE_ENDIAN)        UCHAR ucA : 4;        UCHAR ucB : 4;        UCHAR ucC : 4;        UCHAR ucD : 4;    #else        UCHAR ucD : 4;        UCHAR ucC : 4;        UCHAR ucB : 4;        UCHAR ucA : 4;    #endif}DATA_2_S;

关于位字段，以下描述正确的有：
A.位字段变量在不同字节序的设备上要相反定义
B.要在数据结构未填满的地方加入保留位字段
C.两字节和四字节等多字节位字段变量还有做字节序转
D.以上位字段DATA_1_S定义正确
E.以上位字段DATA_2_S定义正确

第14题

typedef union tagA{    USHORT  us1;    UINT    ui2;    UINT64  ui3;}A_U;INT main(VOID){    A_U unData = {0};    unData.ui2 = 0xAABBCCDDU;    /* 语句I */    printf("%lu\r\n", sizeof(unData));    /* 语句II */    printf("%hX\r\n", unData.us1);    /* 语句III */    printf("%llX\r\n", unData.ui3);    return 0;}

关于以上程序描述正确的有：
A.语句I，输出结果为8
B.语句I，输出结果为14
C.语句II，小字节序环境输出结果为0XCCDD
D.语句II，大字节序环境输出结果为0XAABB
E.语句III，小字节序环境输出结果为0XAABBCCDD
F.语句III，大字节序环境输出结果为0XAABBCCDD00000000

第15题

/* 数组元素 */typedef struct tagElement{    UINT    uiKey;  /* 各元素间唯一 */    UINT    uiData; /* 数据 */}ELEMENT_S;/* 数据组织 */#define DATA_NUM    256ULSTATIC ELEMENT_S g_astData[DATA_NUM];/* 代码I 根据KEY获取数组元素 */ELEMENT_S *GetElementI(IN UINT uiKey){    ULONG ulIdx;    ULONG ulIdxGet = 0;    for (ulIdx = 0; ulIdx < DATA_NUM; ++ulIdx)    {        if (uiKey == g_astData[ulIdx].uiKey)        {            ulIdxGet = ulIdx;        }    }        return &g_astData[ulIdxGet];}/* 代码II 根据KEY获取数组元素 */ELEMENT_S *GetElementII(IN UINT uiKey){    ULONG ulIdx;    ELEMENT_S *pstEach = NULL;    for (ulIdx = 0; ulIdx < DATA_NUM; ++ulIdx)    {        pstEach = &g_astData[ulIdx];        if (uiKey == pstEach->uiKey)        {            break;        }    }    return pstEach;}

关于“根据KEY获取数组元素”功能，描述正确的有：
A.代码I，实现正确，但效率有问题
B.代码I，实现错误
C.代码II，实现正确
D.代码II，实现错误
第16题

/* 代码I */INT main(VOID){    UINT uiData = 0;    if ((0 == uiData) || (1 == (++uiData)))    {        uiData += 10;    }    if ((11 == uiData) && (12 == (uiData++)))    {        uiData += 100;    }    printf("%u\r\n", uiData);    return 0;}/* 代码II */INT main(VOID){    UINT uiData = 0;    UINT uiA, uiB, uiC, uiD;    uiA = ++uiData;    uiB = uiData++;    uiC = uiData--;    uiD = --uiData;    printf("%u, %u, %u, %u\r\n", uiA, uiB, uiC, uiD);    return 0;}

关于以上程序描述正确的有：
A.代码I，输出结果为10
B.代码I，输出结果为11
C.代码I，输出结果为112
D.代码II，输出结果为1, 1, 1, 0
E.代码II，输出结果为1, 1, 2, 0
F.代码II，输出结果为1, 1, 2, 1

第17题

/* 输出500以内的所有质数 *  * 质数又称素数 * 指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数 */INT main(VOID){    ULONG ulA;    ULONG ulB;    for (ulA = 2; ulA < 500; ++ulA)    {        for (ulB = 2; ulB < ulA; ++ulB)        {            /* if (...) */            {                break;            }        }        /* if (...) */        {            printf("%lu\r\n",ulA);      /* 找到质数 */        }    }    return 0;}

分别在代码015行和021行写入一下if判断，能完成函数功能的有：
A.015行 if (0 == (ulA % ulB))
B.015行 if (0 != (ulA % ulB))
C.015行 if (ulA != ((ulA / ulB) * ulB))
D.021行 if (ulB == ulA)
E.021行 if (ulB > ulA)
F.021行 if (ulB < ulA)

第18题

typedef union tagData{    UINT    uiData;    VOID    *pData;}DATA_U;VOID PassData(IN const VOID *pData){    UINT uiData;    uiData = (UINT)(ULONG)pData;    printf("%#X\r\n", uiData);        return;}INT main(VOID){    DATA_U unData = {0};    unData.pData = (VOID *)(ULONG)0xAABBCCDDU;    PassData(unData.pData);    return 0;}

关于以上程序描述正确的有：
A.32位小字节序环境，输出结果为0XAABBCCDD
B.32位大字节序环境，输出结果为0XAABBCCDD
C.64位小字节序环境，输出结果为0XAABBCCDD
D.64位大字节序环境，输出结果为0XAABBCCDD
E.以上答案均不对

第19题

#define DATA_NUM    16UVOID PrintSize(IN UINT auiData[DATA_NUM], IN UINT *puData){    printf("%lu, %lu\r\n", sizeof(auiData), sizeof(puiData));    return;}INT main(VOID){    UINT auiData[DATA_NUM];    UINT *puiData;    puiData = malloc(sizeof(UINT) * DATA_NUM);    if (NULL == puiData)    {        return -1;    }    /* ...  */    free(puiData);    return 0;}

/* 将下述4条语句单独写入代码020行后，程序的运行结果为： */
/* 语句I */
printf("%lu, %lu\r\n", sizeof(auiData), sizeof(puiData));

/* 语句II */
PrintSize(auiData, puiData);

/* 语句III */
puiData = NULL;

/* 语句IV */
auiData = NULL;

A.写入语句I，32位环境输出结果为64,4
B.写入语句I，64位环境输出结果为64,8
C.写入语句II，32位环境输出结果为4,4
D.写入语句II，64位环境输出结果为8,8
E.写入语句III，程序可以运行，但会导致资源puiData遗漏释放
F.写入语句IV，程序不能运行，有编译错误

第20题

ULONG EncapBuf(IN const UCHAR *pucData, /* 数据 */               IN ULONG ulDataLen,      /* 数据长度 */               IN ULONG ulBufLen,       /* 缓冲区长度 */               OUT VOID **ppBuf)        /* 缓冲区 */{    ULONG ulErrCode;    VOID *pEncapBuf;    /* 封装缓冲区（可能需要重新申请）*/    pEncapBuf = *ppBuf;    /* 缓冲区不足 */    if (ulBufLen < ulDataLen)    {        free(pEncapBuf);        pEncapBuf = malloc(ulDataLen);  /* 重新申请 */        ppBuf = pEncapBuf;              /* 出参赋值 */    }    /* 封装 */    if (NULL != pEncapBuf)    {        memcpy(pEncapBuf, pucData, ulDataLen);        ulErrCode = ERROR_SUCCESS;    }    else    {        ulErrCode = ERROR_FAILED;    }    return ulErrCode;}#define BUF_INIT_LEN    4UL     /* 缓冲区初始长度 */INT main(VOID){    VOID *pBuf;    UCHAR aucData[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};    /* 申请 */    pBuf = malloc(BUF_INIT_LEN);    if (NULL == pBuf)    {        return -1;    }    /* 数据封装 */    (VOID)EncapBuf(aucData, sizeof(aucData), BUF_INIT_LEN, &pBuf);    /* 释放 */    if (NULL != pBuf)    {        free(pBuf);    }    return 0;}

关于以上程序描述正确的有：
A.代码040行申请的资源可能会遗漏释放
B.代码047行忽略返回值，可能会导致后续访问空指针
C.代码052行可能会重复释放资源
D.代码015行申请的资源可能会遗漏释放
E.代码022行可能会访问非法地址
F.代码022行可能会拷贝越界

第21题

INT main(VOID){    UINT uiI;    ULONG ulII;    UINT64 uiIII;    VOID *pIV;    UCHAR aucV[4] = {0xCC, 0xCC, 0xCC, 0xCC};    /* 语句I */    uiI = 0x80000000U;    printf("%d\r\n", uiI);        /* 语句II */    ulII = ~0UL;    printf("%#X\r\n", ulII);    /* 语句III */    uiIII = ~0ULL;    printf("%#X\r\n", uiIII);    /* 语句IV */    pIV = &uiIII;    printf("%#X\r\n", pIV);    /* 语句V */    (VOID)sscanf("11:22:33:44", "%x", &aucV[0]);    printf("%X:%X:%X:%X\r\n", aucV[0], aucV[1], aucV[2], aucV[3]);    return 0;}

关于以上程序描述正确的有：
A.语句I，输出结果为负数
B.语句II，64位环境输出结果被截断
C.语句III，32/64位环境输出结果被截断
D.语句IV，64位环境输出结果被截断
E.语句V，数组aucV的4个元素都会被改写
F.语句V，如果输出结果为11:0:0:0，说明程序运行在小字节序环境

第22题

/* 代码I */typedef ULONG (* XXX_FUNC)(IN UCHAR *pucBuf, IN ULONG ulLen);/* 代码II */#define XXX_NUM     32ULSTATIC ULONG *g_apulXXX[XXX_NUM];/* 代码III */VOID XXX_Print(VOID){    CHAR *pszXXX = "XXXXXXX";    return;}

关于以上程序的命名规范问题，描述正确的有：
A.代码I，XXX_FUNC命名正确
B.代码I，XXX_FUNC命名错误，应该为XXX_PF
C.代码II，g_apulXXX命名正确
D.代码II，g_apulXXX命名错误，应该为g_paulXXX
E.代码III，pszXXX命名错误，应该为pcXXX
F.代码III，pszXXX命名错误，应该为szXXX
第23题

/* 表项 */typedef struct tagEntry{    UINT uiIndex;   /* 索引 */    UINT uiData;    /* 数据 */}ENTRY_S;/* 代码I */VOID CodeI(IN UINT uiIndex){    ENTRY_S *pstNew;    pstNew = malloc(sizeof(ENTRY_S));    pstNew->uiIndex = uiIndex;    return;}/* 代码II */ENTRY_S *CodeII(IN ENTRY_S *pstEntry){    printf("%u, %u\r\n", pstEntry->uiIndex, pstEntry->uiData);    free(pstEntry);    return pstEntry;}/* 代码III */ENTRY_S *CodeIII(IN UINT uiIndex){    ENTRY_S *pstNew;    pstNew = malloc(sizeof(ENTRY_S));    if (NULL != pstNew)    {        pstNew->uiIndex = uiIndex;        printf("%u, %u\r\n", pstNew->uiIndex, pstNew->uiData);    }    return pstNew;}/* 代码IV */ENTRY_S *CodeIV(IN UINT uiIndex){    ENTRY_S stEntry;    stEntry.uiIndex = uiIndex;    stEntry.uiData = 0U;    return &stEntry;}

关于以上程序描述正确的有：
A.代码I，既可能访问空指针，有可能遗漏释放资源
B.代码II，可能造成调用者在后续流程中，访问释放后的资源
C.代码III，可能访问内存中的随机值
D.代码IV，可能造成调用者在后续流程中，访问内存中的随机值
第24题

/* 代码I */INT main(VOID){    printf("%#X\r\n", (0xAAAAU & 0xBBBBU) ^ (0xCCCCU | 0xDDDDU));    return 0;}/* 代码II */INT main(VOID){    printf("%#X\r\n", (0x11 << 3) | (0x22 << 2) | (0x33 << 1) | 0x44);    return 0;}/* 代码III */INT main(VOID){    printf("%#X\r\n", 0x12345678U / 16U);     return 0;}/* 代码IV */INT main(VOID){    printf("%u\r\n", 0x87654321U % 32U);    return 0;}

关于以上程序描述正确的有：
A.代码I，输出结果为0X7777
B.代码II，输出结果为0X11223344
C.代码III，输出结果为0X1234
D.代码III，输出结果为0x123456
E.代码IV，输出结果为1
F.代码IV，输出结果为33
第25题
以下描述正确的有：
A.10进制数200转换成2进制数为10001100
B.10进制数200转换成8进制数为310
C.10进制数200转换成16进制数为C8
D.16进制数777转换成8进制数为3567
E.8进制数777转换成16进制数为FF1
第26题

typedef struct tagA{    UCHAR ucA1;    UINT64 uiA2;    UCHAR ucA3;}A_S;typedef struct tagB{    UINT uiB1;    A_S stB2;    UINT uiB3;}B_S;INT main(VOID){    B_S stData = {0};    VOID *pData;    A_S *pstA;    /* 语句I */    printf("%lu\r\n", sizeof(stData));    /* 语句II */    pData = &stData;    pstA = (A_S *)((UCHAR *)pData + sizeof(UINT));    pstA->ucA1 = 100;    printf("%hhu\r\n", stData.stB2.ucA1);    return 0;}

关于以上程序描述正确的有：
A.语句I，输出结果为18
B.语句I，输出结果为32
C.语句I，输出结果为40
D.语句II，输出结果为0
E.语句II，输出结果为100
F.语句II，输出结果不确定，并且可能产生非对齐访问
第27题

/*双链表 *             pstA                pstB *               |                   | *               v                   v *           +-------+           +-------+           +-------+ *<-pstPrev--|       |<-pstPrev--|       |<-pstPrev--|       |<-pstPrev-- *           |   A   |           |   B   |           |   C   | *--pstNext->|       |--pstNext->|       |--pstNext->|       |--pstNext-> *           +-------+           +-------+           +-------+ */typedef struct tagDll_Node{    struct tagDll_Node *pstPrev;    /* 前一结点 */    struct tagDll_Node *pstNext;    /* 下一结点 */    ULONG ulData;                   /* 数据 */}DLL_NODE_S;/* 代码I */pstB->pstPrev->pstNext = pstB->pstNext;pstB->pstNext->pstPrev = pstB->pstPrev;free(pstB);/* 代码II */pstA->pstNext = pstA->pstNext->pstNext;pstA->pstNext->pstNext->pstPrev = pstA;free(pstB);/* 代码III */pstA->pstNext = pstB->pstNext;pstB->pstNext->pstPrev = pstA;free(pstB);/* 代码IV */pstA->pstNext = pstA->pstNext->pstNext;pstA->pstNext->pstPrev = pstA;free(pstB);

双链表结构如上所示，已知节点pstA和pstB，下列描述正确的有：
A.代码I，可删除“节点B”
B.代码II，可删除“节点B”
C.代码III，可删除“节点B”
D.代码IV，可删除“节点B”
第28题

/* 单链表 *             pstA                pstB *               |                   | *               v                   v *           +-------+           +-------+           +-------+ *           |       |           |       |           |       | *--pstNext->|   A   |--pstNext->|   B   |--pstNext->|   C   |--pstNext-> *           |       |           |       |           |       | *           +-------+           +-------+           +-------+ */typedef struct tagSll_Node{    struct tagSll_Node *pstNext;    /* 下一节点 */    ULONG ulData;                   /* 数据 */}SLL_NODE_S;/* 代码I */pstA->pstNext = pstX;pstX->pstNext = pstA->pstNext;/* 代码II */pstA->pstNext = pstX;pstX->pstNext = pstB;/* 代码III */pstX->pstNext = pstA->pstNext;pstA->pstNext = pstX;/* 代码IV */pstX->pstNext = pstA;pstB->pstNext = pstX;

单链表结构如上所示，已知节点pstA和pstB，下列描述正确的有：
A.代码I，可在“节点A”后插入“节点X”
B.代码II，可在“节点A”后插入“节点X”
C.代码III，可在“节点A”后插入“节点X”
D.代码IV，可在“节点A”后插入“节点X”
第29题

/* 判断uiData能否被8整除 */BOOL_T Divisible_8(IN UINT uiData){    BOOL_T bDiv;    /*if (...)*/    {        bDiv = BOOL_TRUE;    }    else    {        bDiv = BOOL_FALSE;    }    return bDiv;}

在代码006行写入以下判断 完成函数功能的有：
A.if (uiData == ((uiData /8) * 8))
B.if (uiData == ((uiData /8) * 8) + (uiData % 8))
C.if (0 == (uiData % 8))
D.if (uiData == ((uiData >> 4) << 4))
E.if (uiData == ((uiData << 4) >> 4))
F.if (0 == (uiData & 0x7))
第30题

INT main(VOID){    if (-1L < 0U)    {        printf("TRUE\r\n");    }    else    {        printf("FALSE\r\n");    }    return 0;}

关于以上程序描述正确的有：
A.32位环境输出结果为TRUE，64位环境输出结果为FALSE
B.32位环境输出结果为FALSE，64为环境输出结果为TRUE
C.32/64位环境输出结果均为TRUE
D.32/64位环境输出结果均为FALSE
E.应杜绝表达式的两个操作数出现符号和长度都不一致的情况

参考答案：

第01题（B）

第02题（ABCDEF）

第03题（BCE）

第04题（A）

第05题（E）

第06题（CE）

第07题（ABCEF）

第08题（D）

第09题（AD）

第10题（F）

第11题（D）

第12题（B）

第13题（ABC）

第14题（ACDEF）

第15题（AC）

第16题（AE）

第17题（AD）

第18题（ABC）

第19题（ABCDEF）

第20题（CD）

第21题（ABCDEF）

第22题（BCE）

第23题（ABCD）

第24题（AE）

第25题（BCD）

第26题（CD）

第27题（ACD）

第28题（BC）

第29题（ACF）

第30题（BE）