- 以下叙述中正确的是________.
- A)预处理命令行必须位于源文件的开头
- B)在源文件的一行上可以有多条预处理命令
- C)宏名必须用大写字母表示
- D)宏替换不占用程序的运行时间
答案：D
解析：
A：在C、C++等编程语言中，预处理指令（如#include、#define、#if等）
通常被放在源文件的开头，但这并不是强制性的
B：在C和C++等编程语言中，通常不建议在一行上放置多条预处理命令，
因为这样做可能会导致编译器解析错误或意外的行为
C：宏名并不必须用大写字母表示。在C和C++等编程语言中，
宏名（通过#define指令定义的）可以使用任何有效的标识符名称
D：宏替换（Macro Substitution）是在编译器的预处理阶段进行的，
而不是在程序运行时。因此，宏替换本身不占用程序的运行时间。
- 若指针p已正确定义，要使p指向两个连续的整型动态存储单元，不正确的语句是______.
- A) p = 2 * ( int* ) malloc( sizeof ( int ) );
- B) p = ( int* ) malloc ( 2 * sizeof ( int ) );
- C) p = ( int* ) malloc ( 2 * 4 );
- D) p = ( int* ) calloc ( 2 , sizeof ( int ) );
答案：A
解析：
void *calloc(size_t num, size_t size);
num：类型的数量
size：类型的大小
- 请读程序:
#include <stdio.h>
void fun(float *p1,float *p2,float *s)
{
s = (float *)calloc( 1, sizeof(float));
*s = *p1 + *(p2++);
}
int main()
{
float a[2] = {1.1, 2.2},b[2] = {10.0, 20.0},*s = a;
fun(a, b, s);
printf("%f\n",*s);
}
上面程序的输出结果是_______.
○ A) 11.100000
○ B) 12.100000
○ C) 21.100000
○ D) 1.100000
答案：D
解析：fun函数中的’*s’是形参，对main函数中的实参没有影响，所以*s的值还是a的第一个元素。
- 以下程序的输出结果是______.
#include <stdio.h>
# define FUDGE(y) 2.84 + y
# define PR(a) printf("%d",(int)(a))
# define PRINT1(a) PR(a); putchar('\n');
int main()
{
int x = 2;
PRINT1(FUDGE(5)*x);
}
○ A) 11
○ B) 12
○ C) 13
○ D) 15
答案：B
解析：PRINT1(FUDGE(5)*x);
=>PR(FUDGE(5)*x); putchar(‘\n’);
=>printf(“%d”,(int)(FUDGE(5)*x)); putchar(‘\n’);
=>printf(“%d”,(int)(2.84+5*x)); putchar(‘\n’);
所以最后打印的值是(int)(12.84)=12.
- 有以下程序段
typedef struct NODE
{
int num;
struct NODE *next;
} OLD;
以下叙述中正确的是 [单选题] [必答题]
○ A)以上的说明形式非法
○ B)NODE是一个结构体类型
○ C)OLD是一个结构体类型
○ D)OLD是一个结构体变量
答案：C
解析：struct NODE才是结构体类型
- 有以下程序
#include <stdio.h>
#include <string.h>
struct STU
{
char name[10];
int num;
};
void f(char *name,int num)
{
struct STU s[2] = {{"SunDan",20044},{"Penghua",20045}};
num = s[0].num;
strcpy(name, s[0].name);
}
int main()
{
struct STU s[2] = {{"YangSan",20041},{"LiSiGuo",20042}},*p;
p = &s[1];
f(p-> name, p->num);
printf("%s %d\n", p-> name, p-> num);
}
程序运行后的输出结果是 [单选题] [必答题]
○ A)SunDan 20042
○ B)SunDan 20044
○ C)LiSiGuo 20042
○ D)YangSan 20041
答案：A
解析：向函数f()传参数时，第一个参数是一个指针类型，第二个参数是int型；
因此可以根据指针找到main函数中的结构体s[1].name的内存位置；
但是int的形参无法影响到实参。
- 若有以下说明和定义
union dt
{
int a;
char b;
double c;
}data;
以下叙述中错误的是______.
- A)data的每个成员起始地址都相同
- B)变量data所占内存字节数与成员c所占字节数相等
- C)程序段：data.a=5;printf(“%f\n”,data.c);输出结果为5.000000
- D)data可以作为函数的实参
答案：C
解析：int 类型通常只占用4个字节，而 double 类型需要8个字节。因此，将 5 赋值给 data.a 时，只有前4个字节被设置，而 double 类型的其余字节（在 union 内的剩余内存空间）可能包含不确定的值（通常是之前内存中的“垃圾”数据）。
当尝试以 %f 格式打印 data.c 时，printf 函数会尝试解释这8个字节作为 double 类型的值。但是，由于这些字节中的大部分并不表示一个有效的 double，所以结果将是未定义的，并且很可能不是 5.000000。
- 有以下程序
#include <stdio.h>
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};
int main()
{
struct NODE *p, *q, *r;
int sum = 0;
p =(struct NODE*)malloc(sizeof(struct NODE));
q =(struct NODE*)malloc(sizeof(struct NODE));
r =(struct NODE*)malloc(sizeof(struct NODE));
p-> num = 1;
q-> num = 2;
r-> num = 3;
p-> next = q;
q-> next = r;
r-> next = NULL;
sum += q-> next-> num;
sum += p-> num;
printf("%d\n", sum);
}
执行后的输出结果是_______.
- A) 3
- B) 4
- C) 5
- D) 6
答案：B
解析：
*p={1,q}
*q={2,r}
*r={3,NULL}
sum += q-> next-> num; => sum+=r->num;=>sum+=3;
sum += p-> num;=>sum+=1=4
- 若有下面的说明和定义：
struct test
{
int ml;
char m2;
float m3;
union uu
{
char ul[5];
int u2[2];
}ua;
}myaa;
则sizeof(struct test)的值是 [单选题] [必答题]
- A) 20
- B) 16
- C) 14
- D) 17
答案：A
解析：
首先int占四个字节，对齐数4，放在地址0处
然后放char一个字节，对齐数1，紧挨int放，位于地址4处
接着float占四个字节，对齐数4，从地址8处开始放
共用体占成员中内存最大的字节数，即4*2个字节，从地址12处开始放
4+4+4+8=20
- 以下程序的输出结果是
struct HAR
{
int x, y;
struct HAR *p;
}h[2];
int main()
{
h[0].x = 1;
h[0].y = 2;
h[1].x = 3;
h[1].y = 4;
h[0].p = h[1].p = h;
printf("%d%d\n",(h[0].p)-> x , (h[1].p)-> y);
}
- A) 12
- B) 23
- C) 14
- D) 32
答案：A
解析：
h[2]={{1,2,h},{3,4,h}}
h是结构体数组，指向结构体的第一个元素
- 以下程序的输出是
struct st
{
int x;
int *y;
}*p;
int dt[4]={10,20,30,40 };
struct st aa[4] = {50, &dt[0], 60, &dt[0], 60, &dt[0], 60, &dt[0],};
int main()
{
p = aa;
printf("%d\n",++(p->x));
}
- A) 10
- B) 11
- C) 51
- D) 60
答案：C
解析：p首先指向结构体数组aa的第一个元素，所以p->x=50，再自加1
- 在C语言中，函数的隐含存储类别是
- A auto
- B static
- C extern
- D 无存储类别
答案：C
解析：在C语言中，如果函数定义中没有明确指定存储类别，那么该函数的隐含存储类别是extern。这意味着该函数可以在其他文件中被调用，具有全局访问性。如果函数前面加上static关键字，则该函数只能被定义它的源文件中的其他代码访问，即它具有文件作用域，而不是外部链接。
- 在32位操作系统下，有下面的的结构体定义，则sizeof(struct Test)的值为（ ）
struct Test{
char a;
int b;
char c;
short d;
char e;
char f;
};
- A 10
- B 12
- C 16
- D 14
答案：C
解析：首先0地址存入一个char型，对齐数1
接着再4地址处存入一个int型，对齐数4
8地址处存入一个char型，
10地址处存入一个short型，对齐数2
11地址处存入一个char型
12地址处存入一个char型
因此最大对齐数是4，因此该结构体占16个字节。
