C语言编程基础考试

最新推荐文章于 2024-08-23 23:45:40 发布
最新推荐文章于 2024-08-23 23:45:40 发布
阅读量5.3k 收藏 5
点赞数 1
分类专栏： C语言编程基础考试 文章标签： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/propro1314/article/details/17593465
版权

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

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

第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    256UL
STATIC 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    16U

VOID 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     32UL
STATIC 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）

auvKone
关注
专栏目录
C考试复习
The student way
12-17 1171
https://wenku.baidu.com/view/e4af75abf61fb7360b4c65c3.html 1. 表达式  11&amp;10的结果用二进制表示为： &amp; 是按位操作，因为 0&amp;0=0，0&amp;1=0,1&amp;0=0,1&amp;1=1。 11&amp;10的操作是最高位1&amp;1=1，低位1&amp;0=0，所以11&amp;10=10...
C语言程序设计试题库（编程题-100道、程序填空题-40道 、程序阅读题-100道 、单项选择题-1.rar
11-26
C语言程序设计试题库（编程题-100道、程序填空题-40道 、程序阅读题-100道 、单项选择题-100道、判断题-170道、填空题-140道）
c考试
daming911230的专栏
11-01 411
指出下面代码的输出，并解释为什么。 main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1); printf("%d,%d",*(a+1),*(ptr-1)); } 输出：2,5  *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5  &a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个
printf介绍
最新发布
2401_86621926的博客
08-23 968
代码演示（）int main()return 0;使用如上代码就可以在屏幕上打印出Hello World的字样。printf() 不会在⾏尾⾃动添加换⾏符，运⾏结束后，光标就停留在输出结束的地⽅，不会⾃动换⾏。为了让光标移到下⼀⾏的开头，可以在输出⽂本的结尾，添加⼀个换⾏符 \nreturn 0;如果在文本的中间有换⾏，也是通过插⼊换⾏符来实现，如下⽅代码(包括打印结果):
大小端字节序存储方式。
wihkum
03-21 2089
大小端字节序存储方式。
数据结构——单链表
cdz2470的博客
04-10 2067
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。单链表中每个结点的结构如下：数据域保存了存储在该地址的数据，但指针域的指针却存放的不是该地址，而是下一个元素的地址。因此，整个单链表的结构如下：最后一个元素的指针域的指针设为nullptr，表示单链表到此结束。一般情况下，为了操作统一，设置了一个在所有数据结点之前的一个结点，称为头结点。可以利用该结点的数据部分存储单链表的个数。而指向头节点的指针称为头指针。
电子学会 青少年软件编程（C语言）等级考试八级 训练题汇总.pdf
04-19
从标题和描述中，我们可以了解到这个文件是关于电子学会 青少年软件编程（C语言）等级考试八级 的训练题汇总，涵盖了C语言编程、教育和考试等方面的知识点。 接下来，让我们从部分内容中提取出重要的知识点： * ...
青少年软件编程（C语言）等级考试试卷（二级）-2021年03月
07-18
这份青少年软件编程（C语言）等级考试（二级）2021年3月的试卷主要考察了考生对C语言的基本掌握情况，包括编程题、...通过这样的考试，考生可以检验自己在C语言编程方面的技能水平，为今后的学习和发展打下坚实基础。
简易 C语言编程训练 考试系统
05-09
【简易 C语言编程训练 考试系统】是一款基于Qt框架开发的教育工具，旨在帮助学生和初学者提升C语言编程技能。这个考试系统提供了一个交互式的环境，用户可以在这里进行编程练习，模拟真实的考试场景，提高编程能力。...
static静态变量
LC的专栏
05-17 6458
C语言提供了static关键字来修饰变量的定义，static关键字修饰的变量称为：静态变量；该关键字修饰变量的定义格式如下： static 数据类型名 变量名; 所以，在定义变量的时候，在数据类型名之前添加static关键字，定义的变量就是静态变量。那么，可以包括“静态局部变量”和“静态全局变量”。我们先来总结一下静态局部变量和静态全局变量的特点，然后，再编写测试例子证明。总结如下： (1) 静态局部变量，其作用域与局部变量一样；就是在定义变量的代码块内；生命期与全局变量一样，是整个程序...
【每日一题】（D0723）strcpy 智能指针
Sunnyside_
07-29 8707
(备注：10、14=23、30、35) 一、选择题 1、以下代码的输出是（B） std::map<int,int> m; m[0] = 1； m[1] = 2； m[2] = 3； m[3] = 4； m[4] = 5； for(auto it = m.begin(); it != m.end;) { if(it->second ==2) { m.erase(it++); printf("map after erase:%d\n",it->second); } els
关于bit位域和大小端的理解
fu724567340的专栏
06-22 7732
本文讨论的问题参考了两篇博文，在引用处后都做了说明，并在此表示感谢！大小端 由于不同的计算机系统可能存在不同的大小端模式，所以不同的体系系统间通信就需要进行大小端转换。任何在不同系统间的通信信息都经过网络字节（大端）序进行传输，也就是说不管本机是什么模式，都要保证发送端传输的数据转换为网络序，接受端都要把网络序的数据转换为本地序。（bit 位域大小端转换问题 http://www.cnblogs
枚举大小sizeof 中枚举的大小详解
Skylar
03-13 1万+
至从C语言开始enum类型就被作为用户自定义分类有限集合常量的方法被引入到了语言当中，而且一度成为C++中定义编译期常量的唯一方法（后来在类中引入了静态整型常量）。 根据上面对enum类型的描述，有以下几个问题： 1.到底enum所定义出来的类型是一个什么样的类型呢？ 2.作为一个用户自定义的类型其所占用的内存空间是多少呢？ 3.使用enum类型是否真的能够起到有限集合常量的边界约束呢？
WINHTTP的API接口说明。
热门推荐
fengsh998的专栏
11-19 4万+
BOOL WINAPI WinHttpAddRequestHeaders(   _In_  HINTERNET hRequest,   _In_  LPCWSTR pwszHeaders,   _In_  DWORD dwHeadersLength,   _In_  DWORD dwModifiers ); 作用：添加一个HTTP的请求头域。 参数说明： hRequest [in]
32位机器下面各类型的取值范围（sizeof值）
CATHY_AA的博客
06-01 6409
32位机器下面的结果：   数据类型 说明 字节数 取值范围 bool 布尔型 1 true,false char 字符型 1 -128～127 unsigned char 无符号字符型 1 0～255 short 短整型 2 -32768～32767 unsigned short 无符号短整型
针对32位系统和64为系统下sizeof（）的大小,包括指针的长度
lxie0的博客
09-05 1万+
长度 32位系统 64位系统 指针 4字节 8字节 int 4 8 char 1 1 double 8 16 情形一： #include"stdafx.h" #include<iostream> #include<stdio.h> #include<math.h> using ...
"C语言编程基础考试试题：数组定义及函数参数的大小
C语言编程基础考试试题 本文总结了一份C语言编程基础考试试题，题目来自国内某大型软件公司的内部考试题。以下为试题的具体内容和答案。 题目一：单选题 给出以下定义: char acX[] = "abcdefg"; char acY[] = {'a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值