C语言和数据结构与算法（99）

2.数据类型（22道）

2.1 用变量a给出下面的定义

（1） 一个整型数：int a;

（2） 一个指向整型数的指针（一重指针）：int *a;

（3） 一个指向指针的指针，它指向的指针是指向一个整型数（二重指针）：int **a;

（4） 一个有10个整型数的数组：int a[10];

（5） 一个有10个指针的数组，该指针是指向一个整型数的（指针数组）：int *a[10];

（6） 一个指向有10个整型数数组的指针（数组指针）：int (*a)[10];

（7） 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（函数指针）：int (*a)(int);

（8） 一个有10个指针的数组，该指针是指向一个函数的指针，该函数有一个整型参数并返回一个整型数（函数指针数组）：int (*a[10])(int);

 

2.2  以下代码输出什么结果，为什么？

void foo(void)

{

    unsigned int a = 6; //无符号整型

    int b = -20;//有符号整型

    (a + b > 6) ? printf(">6\n") : printf("<=6\n");

}

答案：输出“>6”，因为a+b是一个无符号整型，结果为无符号整型，所以不可能小于0，所以输出“>6”。

    解析：

        这段代码考察的是C语言中的整型提升问题，当有符号整型和无符号整型进行运算时，有符号整型会被提升为无符号整型，然后再进行运算。

        注意：正数的补码是其本身，负数的补码是其反码+1，所以-20的补码为0xffffffe4，无符号整型的最大值为0xffffffff，所以a+b的结果为0xffffffea，即4294967276，大于6，所以输出“>6”。

 

2.3 写出float和“零值”比较的语句。

if(x > -0.000001 && x < 0.000001)

{

    printf("x is zero\n");

}

    解析：

        因为计算机在处理浮点数时，会有精度损失，所以不能直接用==来判断浮点数是否为0，而是要判断浮点数是否在一个范围内，且不能将浮点型用“==”或者“!=”比较，应该用“>”或者“<”比较，

        例如上面的代码，就是判断x是否在-0.000001到0.000001之间，如果是，则认为x为0。

 

2.4 以下代码有什么错误？

#include<stdio.h>

void main()

{

    char *s = "AAA";

    s[0] = 'B';

    printf("%s\n",s);

}

答案：“AAA”是一段字符串常量，s是指针，指向这个字符串常量，所以声明s的时候就有问题，应该是const char* s = "AAA"；然后又因为是常量，所以对s[0]的赋值操作是不合法的。

 

2.5 下面代码输出的是什么？

#include<stdio.h>

void main()

{

    int *a = (int *)2;

    printf("%d\n",a + 3);

}

答案：输出14

    解析：

        a是一个指针，指向地址为2的地方，然后a+3，就是指向地址为2+3*4=14的地方，所以输出14。

 

2.6 下面代码运行后会是什么规律？

#include<stdio.h>

#define N 500

void main()

{

    unsigned char count;///范围 unsigned char 0~255  

    for (count = 0; count < N ;count++)

    {

        printf("---%d---\n",count);

    }

}

答案：进入不断打印count值的死循环。

    解析：

        因为unsigned char的范围是0~255，所以count++之后，count的值会一直在0~255之间循环，所以会进入死循环。

 

2.7 下面函数的返回值是？

int foo(void)

{

    int i;

    char c = 0x80;//char c 范围是-128~127，0x80是-128，所以c=-128

    i = c;

    if(i > 0)

        return 1;

    return 2;

}

答案：返回值为2

    解析：

        因为c是一个char型变量，范围是-128~127，0x80是-128，所以c=-128，然后i=c，所以i也是-128，然后i>0，所以返回值为2。

 

2.8 结构体内存对齐原则？

答案：

    （1）第一个成员的首地址（地址偏移量）为0。

    （2） 成员对齐：以4字节对齐为例，如果自身类型小于4字节，则成员的首地址是自身类型大小的整数倍；如果自身类型大于4字节，则成员的首地址是4的整数倍。

    若有内嵌结构体，则内嵌结构体的首地址也要对齐，只不过自身类型大小用内嵌结构体的最大成员类型大小来表示，数组可以拆分看做n个数组元素，不用整体看作一个类型。

    （3）最后结构体对齐：以4字节为列，如果结构体中最大的成员类型小于4字节，则大小补齐为结构体中最大成员类型的整数倍；如果结构体中最大的成员类型大于4字节，则大小补齐为4的整数倍，内嵌结构体也要补齐。

    注意：32位编译器，一般对齐方式是4字节。

例子1：    

#include <stdio.h>

struct MyStruct {

    char a;     // 1字节

    int b;      // 4字节，需要对齐到4的倍数

    char c;     // 1字节

    short d;    // 2字节，需要对齐到2的倍数

};

int main()

{

    printf("sizeof(MyStruct)=%lu\n", sizeof(struct MyStruct));//sizeof(struct MyStruct)=12

    return 0;

}

例子2内嵌结构体

struct InnerStruct {

   int x;       // 4字节

   char y;      // 1字节

};



struct OuterStruct {

   char a;      // 1字节

   struct InnerStruct b; // 8字节，需要对齐到4的倍数

   short c;     // 2字节，需要对齐到2的倍数

};



int main()

{

    printf("sizeof(InnerStruct)=%lu\n", sizeof(struct InnerStruct));//sizeof(InnerStruct)=8

    printf("sizeof(OuterStruct)=%lu\n", sizeof(struct OuterStruct));//sizeof(OuterStruct)=16

    return 0;

}

2.9 结构体内存对齐的原因？

答案：

    （1）平台原因（移植原因）：不是所有硬件平台都能访问任意地址上的任意数据。

    （2） 性能问题：数据结构（尤其是栈） 应该尽可能的在自然边界上对齐，因为访问未对齐的内存，处理器需要做两次内存访问，而访问对齐的内存只需要一次。

2.10 给定的位域结构体，它在内存中占用多少字节？（32位编译器）？

struct A

{

    char t : 4;  //4位

    char k : 5;  //4位

    unsigned short i : 8; //8位

    unsigned long m;    //4字节

}

答案：根据结构体内存对齐原则，共占用8字节。

    解析：

        因为位域是按照位来分配内存的，所以位域的大小不能超过一个字节，所以t和k都是4位，所以占用一个字节，i是8位，所以占用一个字节，m是4字节，所以共占用8字节。

 

2.11 在32位系统中，有如下结构体，那么sizeof(fun)的数组是？

#pragma pack(1) //指定按1字节对齐

struct fun

{

    int i; //4字节

    double d; //8字节

    char c; //1字节

};

答案：13

    解析：

        因为#pragma pack(1)指定了按1字节对齐，所以结构体中的成员都是按照1字节对齐的，所以sizeof(fun) = 4 + 8 + 1 = 13。

2.12 数组元素首地址和数组地址的异同？

解析：

    （1）异：数组元素首地址是数组元素的首地址，例如int a[10],a的值是数组元素首元素地址，所有a+1就是第二个元素的地址；数组地址是数组的首地址，

    int类型占用4个字节，所以两者相差4。而&a是数组地址，所有&a+1就是向后移动（10*4）个单位，所以两者相差40。

    （2）同：数组元素首地址和数组地址的值是相等的。

 

2.13 以下代码输出什么结果？

#include<stdio.h>

void main()

{

    int a[5] = {1,2,3,4,5};

    int *ptr = (int *)(&a + 1);

    printf("%d,%d",*(a + 1),*(ptr - 1));

}

答案：2,5

    解析：

    首先，a是一个数组，a+1指向数组的下一个元素，即a[1]。因此，*(a+1)输出2。

    接下来看ptr。&a表示数组a的地址，&a+1则表示数组a后面一个整型的地址。

    因为a是5个整型的数组，因此&a+1指向的是a[5]的地址。将&a+1强制转换为指向整型的指针int*，可以得到ptr的值。

    因为ptr指向a[5]的地址，因此*(ptr-1)指向a[4]，输出5。

    因此代码输出2,5。

 

2.14 判断下面表达式是否正确

char str[2][3] = {"a","b"}; //正确，str是一个可存放两个字符串的二维数组，每个字符串长度为3，所以str[0] = "a",str[1] = "b"

char srt[2][3] = { {1,2}，{3,4},{5,6} }; //错误，行列不匹配。

char str[] = {"a","b"}; //错误,字符数组不能存放两个字符串。

char str[2] = {"a","b"}; //错误，字符数组不能存放两个字符串。

2.15 查看下面代码，p[6]等于多少？

int a[10] = {1,2,3,4,5,6,7,8,9,0};

int *p = &a[1];

答案：等于8

    解析：

        p是一个指针，指向a[1]，即2，然后p+6，就是指向a[7]，即7，所以p[6] = 8。

 

2.16 以下代码输出什么结果？

#include<stdio.h>

void main()

{

    char *srt[] = {"ab","cd","ef","gh","ij","kl"};//指针数组

    char *t;

    t = (str + 4)[-1];

    printf("%s\n",t);

}

答案：输出“gh”。

    解析：

        str是一个指针数组，每个元素都是一个指向字符的指针，所以str[0] = "ab",str[1] = "cd",str[2] = "ef",str[3] = "gh",str[4] = "ij",str[5] = "kl"。然后t = (str + 4)[-1]，str+4指向str[4]，即"ij"，然后(str + 4)[-1]，即str[3]，所以t = "gh"。

2.17 变长数组是什么？

答案：变长数组是C99标准中的一个新特性，它允许在定义数组时使用变量作为其长度，例如：

#include<stdio.h>

void main()

{

    int n;

    sanf("%d",&n);

    int a[n];

}

    解析：

        变长数组的长度是可以改变的，但是变长数组的长度必须是一个常量，例如上面的代码，n是一个变量，所以a[n]是一个变长数组，但是n是一个常量，所以a[n]是一个变长数组。

 

2.18 bool类型包含于哪个头文件？

答案：stdbool.h

注意：C89标准中没有bool类型，C99标准中才有bool类型，所以C89标准中没有stdbool.h头文件，C99标准中才有stdbool.h头文件。

C89需要自己定义。

#define TREU 1

#define FALSE 0

typedef int bool;

bool res = TRUE;

2.19 结构体struct和联合体union的区别？

（1）两者最大的区别在于内存的使用。

（2）结构体成员拥有自己的内存，各自使用互不干扰，遵循内存对齐原则。

（3）联合体所有成员共用一块内存，修改一个成员会影响其他成员，并且只有一位成员可以得到这块内存的使用权。一个联合体变量的总长度应至少能

容纳最大成员的变量，且需要进行内存对齐。

例子：

#include <stdio.h>

#include <string.h>



// 结构体

struct person {

    char name[50];

    int age;

    float salary;

};



// 联合体

union data {

    int num;

    float score;

    char grade;

};



int main() {

    // 使用结构体

    struct person p1;

    strcpy(p1.name, "Tom");

    p1.age = 30;

    p1.salary = 5000.5;

    printf("Name: %s\n", p1.name);

    printf("Age: %d\n", p1.age);

    printf("Salary: %.2f\n", p1.salary);



    printf("\n");



    // 使用联合体

    union data d1;

    d1.num = 10;

    printf("Num: %d\n", d1.num);

    d1.score = 90.5;

    printf("Score: %.2f\n", d1.score);

    d1.grade = 'A';

    printf("Grade: %c\n", d1.grade);



    return 0;

}

输出结果：

Name: Tom

Age: 30

Salary: 5000.50

Num: 10

Score: 90.50

Grade: A

    解析:这个示例定义了一个结构体person，其中包含了姓名、年龄和薪水等属性。同时，还定义了一个联合体dta，其中包含了整数、浮点数和字符等属性。在mai()函数中，分别初始化了一个结构体对象和一个联合体对象，并输出了它们的属性值。需要注意的是，在联合体中，使用了不同类型的数据成员，但是在输出时只输出了最后一次赋值的数据成员的值。这是因为联合体所有的成员在内存中是共享同一块空间的，赋值一种类型后，其他类型的值就被覆盖了。

2.20 给了一个地址a,分别强转类型为：int变量，int指针，数组指针，指针数组，函数指针。

答案：

    （1）int变量：int a

    （2）int指针：(int *)a

    （3）数组指针：(int (*)[10])a

    （4）指针数组：(int *[10])a

    （5）函数指针：(void (*)(int))a

 

2.21 执行完下面代码，c的值是多少？

unsigned int a = 1; //无符号整型

int b = 0;//有符号整型  在内存中补码依然是0

int c = 0;//有符号整型

c = a + b > 0 ? 1 : 2;

答案：c = 1

    解析：

        a是一个无符号整型，b是一个有符号整型，a+b是一个无符号整型，所以a+b>0为真，所以c = 1。

 

2.22 C语言中不同数据类型之间的赋值规则？

    （1）整数与整数之间（char，short，int，long）：

        ①长度相等：内存中的数据不变，只是按照不同的编码来解析。

        ②长赋值给短：截取低位，然后按短整型的数据类型解析。

        ③短赋值给长：如果都是无符号数，短整型高位补0；如果都是有符号数，短整型高位补符号，

        如果一个有符号数，一个无符号数，那么先将短整数进行位数扩展，过程保持数据变，然后按照长整数的数据类型解析数据。

例子1：

char c = 'A';

int i = 65;

c = i; // i是int类型，可以将其自动转换为char类型

    （2）整数与浮点之间

        ①整数转浮点数：小数部分为0，整数部分与整数相等。

        ②浮点数转整数：截取整数部分。

例子2：

int i = 3;

float f = 3.14;

i = f; // f是float类型，将会被截断成3

f = i; // i是整数类型，将会自动转换为3.0

    （3）float与double之间

        ①float转double：不会丢失精度。

        ②double转float：会丢失精度。

注意：整数在内存中都是以补码的形式存储的。

例子3：

float f = 3.14;

double d = 3.14;

f = d; // d是double类型，可以将其自动转换为float类型