笔试 C/C++ 10.2网题

以下定义中,哪一个是指向数组的指针P:

正确答案: A 你的答案: 空 (错误)
int(*p)[5]
int * p[5]
(int * )p[5]
int *p[]

A：数组指针
B：指针数组
C：强制类型转换
D：定义错误
所以选A

（）的优先级大于[ ]，所以这个表达式其实是在定义一个指针，本质是*p，而[5]在（*p）后面作用是修饰这个指针，补充说明这个指针指向的是一个包含5个元素的数组(行指针)

下列说法正确的是（ ）

#include “stdio.h”
#include “string.h”

void fun( char *s)
{
char t[7];
s=t;
strcpy(s, “example”);
}

int main()
{
char *s;

fun(s);
printf("%s",s);

return 0;
}

正确答案: D 你的答案: C (错误)
输出结果为"example"
输出结果为"烫烫烫烫"
程序编译时出现错误
程序运行时出现错误

如果s没有分配内存空间， strcpy(s, “hello”)就会导致内存访问的异常。 可以用 s = (char*)malloc(10);分配10字节的内存给s， 或 s = new char[10];
主函数里的s没有被初始化，即使初始化了，传到fun函数里，也会存在溢出的情况，程序终止。即使s初始化了，也不会输出"example"，这只是值传递。

下面程序的输出是什么？

int main(void)
{
int a[5] = {1, 2, 3, 4, 5};
int *ptr = (int *)(&a + 1);
printf("%d,%d", *(a + 1), *(ptr - 1));
return 0;
}

2 5

a是数组首元素的地址,a+1的步长是int，所以是2
&a是数组的首地址，&a+1步长是int[5]
ptr是int类型的指针，指向a数组的尾后位置，ptr-1的步长是int,所以是a数组的最后一个元素 5

若调用fputc函数输出字符成功，则其返回值是（）。

输出的字符

有以下程序

#include
main()
{int a=2,b=3,c=4,d=0;
if(a==2 &&b++==3)
if(b!=3 || c–==4)
printf("%d,%d,%dn",a,b,c);
else printf("%d,%d,%dn",a,b,c);
else printf("%d,%d,%dn",a,b,c);
}
程序运行后的输出结果是（ ）

2，4，4

注意里面的陷阱：if(b!=3 || c–==4)，因为b不等于3，所以if语句直接返回true，不执行c-- = = 4操作，所以c还是等于4

float 类型（即 IEEE754 单精度浮点数格式）能表示的最大整数是（ ）。

2^ 128-2^ 104

float指数位8位，指数范围-128至127 。小数位23位。。则最大数为1.11111111111111111111111*2^ 127=(2-2^ -23)*2^ 127=2^ 128-2^104

请声明一个指针，其所指向的内存地址不能改变，但内存中的值可以被改变。

正确答案: B 你的答案: C (错误)
const int const *x = &y;
int * const x = &y;
const int *x = &y;
int const *x = &y;
const int * const x = &y;

若const限定符在 * 之前，则const限定的是ptr而不限定ptr。也就是说，ptr可以改变其所指向的对象，但不能通过该指针修改其所指向对象的值。
若const限定符在 * 之后，则const限定的是ptr而不限定ptr。也就是说，ptr不可以改变其所指向的对象，但能通过该指针修改其所指向对象的值。
若在之前有const限定符且在之后也有const限定符，则ptr与*ptr都被限定。也就是说，ptr既不可以改变其所指向的对象，也不能通过该指针修改其所指向对象的值。
另外：只要 在 * 之后有 const限定符，则该指针在声明时必须初始化。

有以下程序

main()
{ int i;

for(i=0;i<3;i++)

switch(i)
{

case 0:printf("%d",i);

case 2:printf("%d",i);

default:printf("%d",i);
}
}
程序运行后的输出结果是( )。

000122

switch语句中没有break会执行满足条件的和之后的所有条件，i=0，case0,2,default均会执行；i=1,执行default;i=2，执行case2和default.综上，000 1 22

下列代码运行出错，可能会是哪一行引起的?

复制代码
void getMemory(char *p)
{
p = (char *)malloc(100); // 1
}

int main(int argc, char const *argv[])
{
char *str = NULL;
getMemory(str);
strcpy(str,“hello wrold”); //2
printf("%sn", str); //3
free(str); //4
}

答案：2

GetMemory(str); //把str传进去，str是一个指针，而他实际上是一个int
void GetMemory(char *p) // p是str的一个副本
{
p=(char *)new char[100]; // p的值改变，但是str的值并没有改变。
}
而双重指针为什么就可以了呢：
GetMemory(&str); //把str的地址传进去
void GetMemory(char ** p) // p是str地址的一个副本
{

*p = (char *)new char[100]; // p指向的值改变，也就是str的值改变。
}

有以下结构体，请问在64位系统中，sizeof(struct B)的大小为

struct A
{
 int a;
 union
 {
     long b;
     short c;
 };
};
struct B
{
 char e;
 struct A d;
 int f;
};

解答：
结构体在C中是一种集合，而不是一种新的数据类型！
B相当于
struct B
{
char e;
int a;
union
{
long b;
short c;
};
int f;
};
1.union共享内存取最长的long 8（windows 64位系统中vs2019实测long是4，可能这里是linux）；
2.所有类型对齐(char e)+7，(int a)+4, (int f)+4, 4*8 = 32;

请阅读以下程序，其运行结果是（）

void main()
{
char c=‘A’;
if(‘0’<=c<=‘9’) printf (“YES”);
else printf(“NO”);
}

正确答案: A 你的答案: 空 (错误)
YES
NO
YESNO
语句错误

if(‘0’<=c<=‘9’) 等价于if((‘0’<=c)<=‘9’) ，因为0的ASCII码为048，A的ASCII码为065大于’0’，所以结果为true，不过我有一个疑惑点，就是当前面为true时，后面就不进行比较了吗？
拓展ASCII的大小比较：小写字母(a～z)大于大写字母(A～Z)大于字符(`0’～’9’)。

int a=4,则对于表达式++(a++)的结果说法正确的是（）

正确答案: D 你的答案: B (错误)
结果为5
结果为6
结果为7
以上不都是

a++的结果是4，然后进行++4是不对的，++运算只是针对于变量的，a++是右值，不能对常量来进行++运算。

单选】下面的程序会打印几个hello?

int main(void)
{
fork();
printf(“hellon”);
fork();
printf(“hellon”);
while(1);
return
}
正确答案:
6

每次fork后，子进程将获得与父进程一样的环境。假设原始进程为P，第一次fork后，多了一个P0，接着P,P0各自打印一次。再fork一次，P,P0分别fork出来P1,P00。这时4个进程都打印一次。加起来一共是6次。

假定CSomething是一个类，执行下面这些语句之后，内存里创建了____个CSomething对象。

CSomething a();
CSomething b(2);
CSomething c[3];
CSomething &ra = b;
CSomething d=b;
CSomething *pA = c;
CSomething *p = new CSomething(4);

6

CSomething a(); 只是个函数声明
CSomething b(2); +1
CSomething c[3]; +3，对象数组
CSomething &ra = b; 引用，没有新构造
CSomething d=b; +1，调用拷贝构造函数
CSomething *pA = c; 只是给指针赋值
CSomething *p = new CSomething(4); +1，构造并给指针赋值
总共6个

注意区别:
CSomething a();
CSomething a;
前者是一个函数的声明，与默认构造函数区分；//返回类型为CSomething,形参表为空
后者是一个对象的定义；

class A { int a; short b; int c; char d; }; class B { double a; short b; intc; char d; }; 在32位机器上用gcc编译以上代码，求sizeof(A),sizeof(B)分别是多少。

16 24

原则有3条（楼上已经说了），讲一下自己的理解：

1. 结构体变量的首地址 必须 是内部最宽数据类型的倍数（虽然和做题没什么关系）
2. 按顺序一个变量一个变量看，要求current变量的首地址 必须是自己大小的倍数。
3. 到了最后一个变量，要求整个结构体的大小的最宽数据类型的倍数。

那么看一下 这道 题：
A: int a （4个字节） 4
short b (2个字节，起始地址4是2的倍数，不补) 4+2
int c (4个字节，4+2不是4的倍数，被2个 ) 4+2+2（补）+4
char d (1个字节，4+2+2+4是1的倍数，不补) 4+2+2（补）+4 +1
最后补3个字节，让整体大小为4的倍数 4+2+2(补)+4+1+3（补） =16

B: double a （8个字节） 8
short b (2个字节，起始地址8是2的倍数，不补) 8+2
int c (4个字节，8+2不是4的倍数，被2个 ) 8+2+2（补）+4
char d (1个字节，8+2+2+4是1的倍数，不补) 8+2+2（补）+4 +1
最后补7个字节，让整体大小为8的倍数 8+2+2(补)+4+1+7（补） =24

【单选】下面函数输出结果是什么：

int main() {
int k = 12345;
printf("%2dn", k);
return 0;
}

12345

%d就是普通的输出了，%d 是输出十进制整数 d是decimal的缩写
% 2d是将数字按宽度为2，采用右对齐方式输出，如果数据位数不到2位，则左边补空格。
%02d:默认情况下，数据数据宽度不够2位是用空格填补的，但是因为2d前面有0，表示，数据宽度不足时用0填补。

“%2d” 指定数据输出为2列，输出的数据显示在此2列区域的右侧， 如果超出，则按实际输出

若变量已正确的定义为float类型，要通过输入函数scanf（“%f%f%f”，&a,&b,&c）给a赋值10，b赋值22，c赋值33，以下不正确的输入形式是（ ）

正确答案: B C 你的答案: A D (错误)
10
22
33

10.0,22.0,33.0

10.0
22.0,33.0

10 22
33

如果scanf中%d是连着写的如“%f%f%f”,在输入数据时，数据之间不可以用逗号分隔，只能用空白字符、空格、tab键、回车键 分隔。
若是“%f,%f,%f”，则在输入数据时需要加“,”，如“2,3,4”。