错题本之＜结构体＞

1. 以下叙述中正确的是________.

• A)预处理命令行必须位于源文件的开头
• B)在源文件的一行上可以有多条预处理命令
• C)宏名必须用大写字母表示
• D)宏替换不占用程序的运行时间

答案：D
解析：
A：在C、C++等编程语言中，预处理指令（如#include、#define、#if等）
通常被放在源文件的开头，但这并不是强制性的
B：在C和C++等编程语言中，通常不建议在一行上放置多条预处理命令，
因为这样做可能会导致编译器解析错误或意外的行为
C：宏名并不必须用大写字母表示。在C和C++等编程语言中，
宏名（通过#define指令定义的）可以使用任何有效的标识符名称
D：宏替换（Macro Substitution）是在编译器的预处理阶段进行的，
而不是在程序运行时。因此，宏替换本身不占用程序的运行时间。

2. 若指针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：类型的大小

3. 请读程序:

#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的第一个元素。

4. 以下程序的输出结果是______.

#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.

5. 有以下程序段
   typedef struct NODE
   {
   int num;
   struct NODE *next;
   } OLD;
   以下叙述中正确的是 [单选题] [必答题]
   ○ A)以上的说明形式非法
   ○ B)NODE是一个结构体类型
   ○ C)OLD是一个结构体类型
   ○ D)OLD是一个结构体变量

答案：C
解析：struct NODE才是结构体类型

6. 有以下程序

#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的形参无法影响到实参。

7. 若有以下说明和定义

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。

8. 有以下程序

#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

9. 若有下面的说明和定义：

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

10. 以下程序的输出结果是

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是结构体数组，指向结构体的第一个元素

11. 以下程序的输出是

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

12. 在C语言中，函数的隐含存储类别是

• A auto
• B static
• C extern
• D 无存储类别

答案：C
解析：在C语言中，如果函数定义中没有明确指定存储类别，那么该函数的隐含存储类别是extern。这意味着该函数可以在其他文件中被调用，具有全局访问性。如果函数前面加上static关键字，则该函数只能被定义它的源文件中的其他代码访问，即它具有文件作用域，而不是外部链接。

13. 在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个字节。

14. 字符 ‘0’ 的 ASCII 码的十进制数为 48 ,且数组的第 0 个元素在低位

# include
int main()
{ 
    union 
    { 
        int  i[2];    
        long k;    
        char c[4];    
    }
    r, *s = &r;
    s-> i[0] = 0x 39;
    s-> i[1] = 0x 38;
    printf（" %c \n ", s- > c[0] ）     
} 

则该程序的输出结果是 ______.

• A) 39
• B) 9
• C) 38
• D) 8

答案：B
解析：体重共用体类型共占了8个字节，其中前四个字节存放了0x39，后四个字节存放了0x38。因此取c[0]应该取到第0个字节的数字，即0x39，随后以%c的格式打印，0x39的十进制是57，57-48=9，因此应该输出字符’9’

15. 有以下程序：

# include
union pw
{ 
    int i;   
    char  ch[2];  
} a;
int main()
{ 
    a.ch[0] = 13;   
    a.ch[1] = 0;   
    printf("%d\n",a.i);  
}

程序的输出结果是（注意： ch[0] 在低字节，ch[1] 在高字节。）

• A) 13
• B) 14
• C) 208
• D) 209

答案：A
解析：共用体共占四个字节，第一个字节存放13，第二个字节存放0，此共用体变量为全局变量，存放在常量区，后两个未初始化的字节应为0，故当以%d格式打印int型数据时应当为13.

16. 设有以下语句：

struct st 
{    
    int n; 
    struct st *next;
};
static struct st a[3]  = { 5,&a[1],7,&a[2],9, '\0'}, *p;
p = &a[0];

则表达式___________的值是6。 [单选题] [必答题]

• p + + ->n
• B) p->n + +
• C) (*p).n + +
• D) + + p->n

答案：D
解析：
p+±>n，后置的++，因此指向的应该是5
p->n++，++优先级高于->，此条语句违法
(*p).n++，*p是取值，常量无法自加，此语句违法
++p->n，先执行p->n再执行++

17. 有以下程序

#  define  f(x)  (x * x)
main()
{  
        int i1,i2;
        i1 = f(8) / f(4);  
        i2 = f(4 + 4) / f( 2 + 2);
        printf("%d,%d\n",i1,i2);
}

程序运行后的输出结果是 [单选题] [必答题]

• A) 64, 28
• B) 4, 4
• C) 4, 3
• D) 64, 64

答案：C
解析：
i1 = (8*8)/(4*4) = 64/16 = 4
i2 = (4+4*4+4)/(2+2*2+2) = 24/8 = 3

18. 有以下程序

int main()
{  
        char a[7] = "a0\0a0\0";  
        int i, j;
        i = sizeof(a);  
        j = strlen(a);
        printf("%d %d\n",i,j);
}

程序运行后的输出结果是______.

• A)2 2
• B)7 6
• C)7 2
• D)6 2

答案：C
解析：sizeof会计算变量占用的内存空间大小，char数组共有7个元素，故占7字节；
strlen计算时遇到’\0’会结束，所以遇到第一个\0时就结束了，故为2.

19. 有以下程序

int main()
{  
    union    
    {  
   	    unsigned  int  n;
        unsigned  char  c;
    }u1;
    u1.c  ='A';
    printf("%c\n", u1.n);
}

执行后输出结果是 [单选题] [必答题]
○ A) 产生语法错
○ B） 随机值
○ C） A(正确答案)
○ D） 65

答案：A
解析：

20. 以下程序的输出结果是 ________.

union  myun
{  
	struct
    {      
       int x, y, z;  
    }u;
    int k;
}a;
int main()
{  
    a.u.x = 4;    
    a.u.y = 5;  
    a.u.z = 6;
    a.k = 0;
    printf("%d\n",a.u.x);
}  

• A) 4
• B) 5
• C) 6
• D) 0

答案：D
解析：myun为共用体，两个成员的起始位置相同，因此a.k赋值会覆盖掉a.u.x的值

21. 以下程序的输出是

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，再执行++，即51