C/C++ 笔试（一）

以下程序的运行结果是（）
cpp 复制代码
```
int main(void) 
{
    printf("%s , %5.3s\n", "computer", "computer"); 
    return 0; 
}
```
A computer , puter

B computer , com

C computer , computer

D computer , compu.ter

B

%m.ns 输出占m列，但只取字符串中左端n个字符。这n个字符输出在m列的右侧，左补空格。
若有定义语句：int year=1009,*p=&year;以下不能使变量 year 中的值增至 1010 的语句是（）

A * p+=1;

B (* p)++;

C ++(* p) ;

D *p++;

D

A 其效果等同于 *p = *p + 1

B 解引用,后置++

C 解引用,前置++

D 首先执行解引用操作（即读取指针当前指向的值），然后执行指针自增操作（即移动指针到下一个位置）。但是，这个读取的值并不会被存储在一个临时变量中，它仅仅是为了执行解引用这个动作。之后，指针会立即移动到下一个位置。
下面代码会输出()
cpp 复制代码
```
int main()
{ 
    int a[4]={1,2,3,4}; 
    int *ptr=(int*)(&a+1); 
    printf("%d",*(ptr-1)); 
    return 0;
}
```
A 4

B 1

C 2

D 3
A

数组名是一个常量指针，指向的是首元素地址，但是有这两个例外：
1. sizeof(arr) 此时的数组名代表整个数组，即单独放在sizeof中的数组名代表整个数组
2. &arr 这是的数组名也代表整个数组，取出的是整个数组的地址
这里&a是把整个数组拿出来了,+1指针后移一个int的距离，后面ptr-1往前移动一个int的距离就是 4 了
请找出下面程序中有哪些错误（）
cpp 复制代码
```
int main()
{
    int i = 10;
    int j = 1;
    const int *p1;//(1)
    int const *p2 = &i; //(2)
    p2 = &j;//(3)
    int *const p3 = &i;//(4)
    *p3 = 20;//(5)
    *p2 = 30;//(6)
    p3 = &j;//(7)
    return 0;
}
```
A 1,2,3,4,5,6,7

B 1,3,5,6

C 6,7

D 3,5

C

常量指针：指针所指空间的值不能被修改，但是指针的指向可以改变

指针常量：指针就是一个常量，指向不能被修改，但是所指空间的指可以改变

区分：const * 的相对位置：const在 * 的左边：常量指针；const在 * 的右边：指针常量

1是一个常量指针，2也是常量指针，指向的值就不能被修改， 6修改了p2指向空间的值， 6错误, 3 p2的指向发生了改变，4是一个指针常量，5 p3所指空间的值被修改，7 指针的指向发生了改变，7错误。
在32位cpu上选择缺省对齐的情况下，有如下结构体定义：
cpp 复制代码
```
struct A{
    unsigned a : 19;
    unsigned b : 11;
    unsigned c : 4;
    unsigned d : 29;
    char index;
};
```
则sizeof（struct A）的值为（）

A 9

B 12

C 16

D 20

C

32位cpu选择缺省对齐是以4字节一个单位

4字节：19 + 11

4字节：4

4字节：29

4字节：8
设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是

A n=0;while(ch=getchar()!='\n') n++；

B n=0;while(getchar()!='\n')n++;

C for(n=0;getchar()!='\n';n++);

D n=0;for(ch=getchar();ch!='\n';n++);

D

for循环的初始化部分只会执行一次
假设在一个 32 位 little endian 的机器上运行下面的程序，结果是多少？
cpp 复制代码
```
int main()
{
    long long a = 1, b = 2, c = 3;
    printf("%d %d %d\n", b, c, a);
    return 0;
}
```
A 1,2,3

B 2,0,3

C 1,3,2

D 3,2,1
B

大端：低位存高地址

小端：低位存低地址
cpp 复制代码
```
int a = 1;
大端: 00 00 00 01
小端: 01 00 00 00
低地址      高地址
```
三个数是从右向左入栈的，程序栈帧是由高地址向低地址开辟的

a、b、c在程序栈中的存储：

02 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00

低地址高地址

栈是后进先出的，b先打印4字节是02 00 00 00 ，出栈，c再打印4字节是00 00 00 00，出栈，a先打印4字节是03 00 00 00，所以最后打印是 2 0 3

注：三个数的入栈顺序是由使用时决定的。

cpp 复制代码

int main()
{
    int m=0123, n=123;
    printf("%o %o\n", m, n);
    return 0;
}

程序运行后的输出结果是（）

A 0123 0173

B 0123 173

C 123 173

D 173 173

C

二进制：10101b

八进制：0123

十进制：123

十六进制：0x123 或 123h

%d：十进制方式输出

%o：十进制方式输出

%x：十六进制方式输出

二维数组X按行顺序存储，其中每个元素占1个存储单元。若X [4] [4]的存储地址为0xf8b82140,X [9] [9]的存储地址为0xf8b8221c,则X [7] [7]的存储地址为()。

A 0xf8b821c4

B 0xf8b821a6

C 0xf8b82198

D 0xf8b821c0

A

解法一：

设：数组的起始地址为start，总共m行，n列

&x [4] [4] = start + 4*n + 4 = 0xf8b82140

&x [9] [9] = start + 9*n + 9 = 0xf8b8221c

start = n =

&x [7] [7] = start + 7*n + 7

解法二：

&x [4] [4] = 0xf8b82140

&x [4] [9] = 0xf8b82145

&x [9] [9] = 0xf8b8221c

4 4 和 9 9 隔了5行

21c - 145 = 0xb7 = 215

一行有43列

&x [7] [7] = &x [7] [9] - 2

= &x [4] [9] + 3*43 -2

= 0xf8b82145 + 127

= 0xf8b82145 + 0x75

= 0xf8b821c4

求函数返回值，输入x=9999
cpp 复制代码
```
int func(int x)
{
    int count=0;
    while (x)
    {
        count++;
        x=x&(x-1);//与运算
    }
    return count;
}
```
A 8

B 9

C 10

D 12

A

x=x&(x-1) 算法就是把x二进制中的一位1消去，所以就要计算x二进制中1的个数

9的二进制：1001

9999的二进制：1001 1001 1001 1001