PTA浙大版《C语言程序设计（第3版）》题目集.2

习题4-10 猴子吃桃问题

#include  
 
int main(){  
	int n,m=1;
	scanf("%d",&n);
	for(int i=1;i

习题4-11 兔子繁衍问题

#include   
 
int main(){  
	int n,a=1,b=1,i;
	scanf("%d",&n);
	if(n==1){
		printf("1");
	}else{
		for(i=3;(a+b)

习题6-7 简单计算器

#include  
 
int main(){  
	char c;
	int re=0,t,flag=0;
	scanf("%d%c",&re,&c);
	
	while(c!='=' && flag==0){
		switch(c){
			case '+':
				scanf("%d",&t);
				re+=t;
				break;
			case '-':
				scanf("%d",&t);
				re-=t;
				break;
			case '*':
				scanf("%d",&t);
				re*=t;
				break;
			case '/':
				scanf("%d",&t);
				if(t==0){
					flag=1;
					break;
				}else{
					re/=t;
					break;
				}
			default:
				flag=1;	
				break;
		}
		scanf("%c",&c);
	}
	
	if(flag==1){
		printf("ERROR");
	}else{
		printf("%d",re);
	}
    return 0;  
 } 

习题6-8 统计一行文本的单词个数

#include
#include

int main() {
    char str[1000];
    gets(str);
    
    int count = 0;
    for (int i = 0; i < strlen(str); i++) {
        // 所谓 “单词” 是指连续不含空格的字符串，各单词之间用空格分隔
        if (str[i] != ' ' && (str[i + 1] == ' ' || str[i + 1] == '\0')) {
            count++;
        }
    }

    printf("%d", count);

    return 0;
}

练习7-2 求最大值及其下标

#include
#include

int main() {
	int n;
	scanf("%d",&n);
	
    int a[100];
    for(int i=0;i a[maxValIndex] ? i : maxValIndex;
	}
	
    printf("%d %d", a[maxValIndex],maxValIndex);

    return 0;
}

//三元运算符的格式:condition ? expression_if_true : expression_if_false
//如果 condition 为真（true），则整个表达式的结果是 expression_if_true；
//如果 condition 为假（false），则是 expression_if_false。

练习7-3 将数组中的数逆序存放

#include

int main() {
	int n;
	scanf("%d",&n);
	
	int a[100];
	for(int i=0;i

练习7-4 找出不是两个数组共有的元素

#include

int main(void) {
    int M;
    int num1[20];
    scanf("%d", &M);
    for (int i = 0; i < M; i++) {
        scanf("%d", &num1[i]);
    }

    int N;
    int num2[20];
    scanf("%d", &N);
    for (int j = 0; j < N; j++) {
        scanf("%d", &num2[j]);
    }

    int num3[40];
    int index = -1;

    // 找出 num1 中特有的元素，即在 num1 中存在但 num2 中不存在的元素
    for (int i = 0; i < M; i++) {
        // 记录 num1[i] 在 num2[] 中是否存在：[1]不存在 [0]存在
        int flag = 1;
        for (int j = 0; j < N; j++) {
            if (num1[i] == num2[j]) {
                flag = 0;
                break;
            }
        }

        if (flag == 1) {
            num3[++index] = num1[i];
        }
    }

    // 找出 num2 中特有的元素，即在 num2 中存在但 num1 中不存在的元素
    for (int i = 0; i < N; i++) {
        // 记录 num2[i] 在 num1[] 中是否存在：[1]不存在 [0]存在
        int flag = 1;
        for (int j = 0; j < M; j++) {
            if (num2[i] == num1[j]) {
                flag = 0;
                break;
            }
        }

        if (flag == 1) {
            num3[++index] = num2[i];
        }
    }

    // 去除 num3[] 中的重复元素
    for (int i = 0; i <= index; i++) {
        for (int j = 0; j <= index; j++) {
            // 同一个元素，继续去重
            if (i == j) {
                continue;
            }
            if (num3[i] == num3[j]) {
                // 后续元素前移
                for (int k = j; k < index; k++) {
                    num3[k] = num3[k + 1];
                }
                // 数组长度减 1
                index--;
            }
        }
    }

    for (int i = 0; i <= index; i++) {
        printf("%d", num3[i]);
        // 数字间以空格分隔，但行末不得有多余的空格
        if (i != index) {
            printf(" ");
        }
    }

    return 0;
}

练习7-7 矩阵运算

#include

int main(void) {
    int n;
    scanf("%d",&n);
    
    int a[10][10];
    for(int i=0;i

练习7-8 方阵循环右移

#include
#include

int main(void) {
    int m,n;
    scanf("%d %d",&m,&n);
    
    int a[6][6];
    for(int i=0;i

练习7-9 计算天数

#include

int main(void) {
    int a,b,c;
	scanf("%d/%d/%d",&a,&b,&c); 
	
	int sum1=0,sum2=-1;
	int array[12]={31,29,31,30,31,30,31,31,30,31,30,31};
	for(int i=0;i

练习7-10 查找指定字符

#include
#include

int main(void) {
	char s=(char)getchar();
	getchar();
	
    char b[81];
    gets(b);
    
    int i,index=-1;
    for(i=0;b[i]!='\0';i++){
    	if(s==b[i]){
    		index=i;
		}
	}
		
		if(index==-1){
			printf("Not Found");
		}else{
			printf("index=%d",index);
	}
	
    return 0;
}

知识点：getchar()

getchar() ，其格式和基本用法如下：
1.读取单个字符
#include 
int main() {
    char ch;
    ch = getchar(); // 读取一个字符
    printf("The character is: %c\n", ch);
    return 0;
}

2.处理换行符
#include 
int main() {
    char ch;
    printf("Enter a character: ");
    ch = getchar(); // 读取一个字符
    printf("You entered: %c\n", ch);
    
    // 吸收换行符
    while (getchar() != '\n');
    
    printf("Press any key to exit.\n");
    getchar(); // 等待用户按下任意键
    return 0;
}
//在这个示例中，程序读取一个字符，然后使用一个循环来吸收用户输入的换行符，直到遇到换行符为止。这样可以确保在下一次使用 getchar() 时不会因为之前的换行符而立即返回。

练习7-11 字符串逆序

#include
#include

int main(void) {
	char a[81];
    gets(a); 
    
    char t;
	for(int i=0,j=(int)strlen(a)-1;i

知识点：

字符串要#include开头；
获取字符串长度：int length=strlen(数组名)
char a[80],因字符串以“\0”结尾，所以实际存储79个字符；以此，要存储80个，就要写成char a[81]
注意：int a[80]是能存储80个数的。

因为数组名是指向数组首元素的地址；所以用scanf获取时，不需要加&。
获取数组长度：int length = sizeof(array) / sizeof(array[0]);

习题7-1 选择法排序

#include
#include

int main(void) {
	int n;
	scanf("%d",&n);
	
	int a[10];
	for(int i=0;i

习题7-2 求一批整数中出现最多的个位数字

#include 

int main() {
    int N;
    scanf("%d", &N); // 读取整数的数量

    int count[10] = {0}; // 用于统计0到9每个数字出现的次数

    for (int i = 0; i < N; i++) {
        int num;
        scanf("%d", &num); // 读取每个整数

        if (num == 0) { // 特殊处理0
            count[0]++;
            continue;
        }

        while (num > 0) {
            int digit = num % 10; // 获取个位数字
            count[digit]++; // 增加对应数字的计数
            num /= 10; // 移除个位数字
        }
    }

    int maxCount = 0; // 最大的出现次数
    for (int i = 0; i < 10; i++) {
        if (count[i] > maxCount) {
            maxCount = count[i]; // 更新最大出现次数
        }
    }

    printf("%d:", maxCount); // 输出最大出现次数

    for (int i = 0; i < 10; i++) {
        if (count[i] == maxCount) {
            printf(" %d", i); // 输出出现次数最多的数字
        }
    }

    return 0;
}

代码二：
#include

int main(void) {
    int N;
    scanf("%d", &N);

    int array[1000];
    for (int i = 0; i < N; i++) {
        scanf("%d", &array[i]);
    }

    // 记录每个数字出现的次数
    int countDigit[10] = {0};
    // 依次统计输入的各个数的各位数字出现的次数
    for (int i = 0; i < N; i++) {
        int number = array[i];
        // 如果输入的整数为 0，则 0 的计数增 1，继续处理下一个数字
        if (number == 0) {
            countDigit[0]++;
            continue;
        }

        while (number != 0) {
            switch (number % 10) {
                case 0:
                    countDigit[0]++;
                    break;
                case 1:
                    countDigit[1]++;
                    break;
                case 2:
                    countDigit[2]++;
                    break;
                case 3:
                    countDigit[3]++;
                    break;
                case 4:
                    countDigit[4]++;
                    break;
                case 5:
                    countDigit[5]++;
                    break;
                case 6:
                    countDigit[6]++;
                    break;
                case 7:
                    countDigit[7]++;
                    break;
                case 8:
                    countDigit[8]++;
                    break;
                case 9:
                    countDigit[9]++;
                    break;
                default:
                    break;
            }
            number /= 10;
        }
    }

    // 出现次数最多的数字的出现次数，假设为数字 0，共出现了 countDigit[0] 次
    int maxCount = countDigit[0];
    for (int i = 1; i < 10; i++) {
        maxCount = countDigit[i] > maxCount ? countDigit[i] : maxCount;
    }
    // 输出出现次数最多的数字的出现次数
    printf("%d:", maxCount);

    // 从计数数组中查找，看是否有多个数字均出现 maxCount 次
    for (int i = 0; i < 10; i++) {
        if (countDigit[i] == maxCount) {
            printf(" %d", i);
        }
    }

    return 0;
}

习题7-3 判断上三角矩阵

#include 

int main() {
	int T;
	scanf("%d",&T);
	
	
	for(int i=1;i<=T;i++){
		int n;
		scanf("%d",&n);
		
		int a[10][10];
		for(int i=0;i=i){
						break;
					}
					if(a[i][j]!=0){
						u=0;
						goto here;
					} 
				}
			}
			
		here:
			if(u==1){
				printf("YES\n");
			}else{
				printf("NO\n");
			}		
	}
		
    return 0;
}

习题7-4 求矩阵各行元素之和

#include 

int main() {
	int m, n;
    scanf("%d%d", &m, &n);

    int matrix[6][6];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);            
        }
    }
    
    int sumRow = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            sumRow += matrix[i][j];
        }
        printf("%d\n", sumRow);
        sumRow=0;
    }
    
    return 0;
}

习题7-5 找鞍点

#include 

int main() {
	int n;
    scanf("%d",&n);

    int a[6][6];
    for(int i=0;i=max){
				max=a[i][j];
				col=j;
			}
		}
		
		int ismin=1;
		for(int i=0;i

习题7-6 统计大写辅音字母

#include 
#include

int main() {
	char a[81];
	gets(a);
    
    int cnt=0;
    int length=strlen(a);
    for(int i=0;i='A' && a[i]<='Z'){
    		if (a[i] != 'A' && a[i] != 'E' && a[i] != 'I' && a[i] != 'O' && a[i] != 'U') {
            cnt++;
     	   }
		}    	
	}
	printf("%d",cnt);
	
    return 0;
}

习题7-7 字符串替换

#include

int main(void) {
    char s[81];
    gets(s);

    for (int i = 0; s[i] != '\0'; i++) {
        // 将 A~Z 依次替换成 Z~A, 其 ASCII 码之和是 65 + 90 = 155
        if (s[i] >= 'A' && s[i] <= 'Z') {
            s[i] = 155 - s[i];
        }
    }

    puts(s);

    return 0;
}

习题7-8 字符串转换成十进制整数

#include 
#include  // 提供字符分类函数，如isxdigit
#include  // 提供strtol函数
#include  // 提供strncat函数

int main() {
    char input[100]; // 假设输入的字符串不超过99个字符，加上一个空字符'\0'
    scanf("%99s", input); // 读取以#结束的字符串，最大长度为99

    char hexStr[100] = ""; // 用于存储有效的十六进制字符
    int isNegative = 0; // 标记是否为负数
    int hexStarted = 0; // 标记是否已经遇到第一个十六进制字符

    for (int i = 0; input[i] != '\0' && input[i] != '#'; i++) {
        char c = input[i];
        if (c == '-') {
            if (!hexStarted) {
                isNegative = 1; // 如果在第一个十六进制字符之前遇到'-'，标记为负数
            }
        } else if (isxdigit(c)) { // 检查是否为十六进制字符
            hexStarted = 1; // 遇到第一个十六进制字符
            strncat(hexStr, &c, 1); // 将有效的十六进制字符添加到hexStr
        }
    }

    // 将十六进制字符串转换为十进制整数
    long decimal = strtol(hexStr, NULL, 16);

    // 根据符号输出结果
    if (isNegative) {
        printf("%ld\n", -decimal); // 如果是负数，输出负的十进制值
    } else {
        printf("%ld\n", decimal); // 否则输出正的十进制值
    }

    return 0;
}

知识点

检查一个字符是否是一个十六进制数字：isxdigit(字符名)，在  头文件中

! 是逻辑非运算符
具体解释：如果有一个布尔值 A，那么 !A 就是 A 的逻辑非。
例子：如果 A 是 true，那么 !A 就是 false；如果 A 是 false，那么 !A 就是 true。
代码：
#include 
int main() {
	int a=10;
    int A=0;
	if(!A){// 使用逻辑非运算符!检查A是否为0
		printf("%d",a);
	}
    return 0;
}

strncat函数，将一个字符串追加到另一个字符串的末尾，但它只追加指定数量的字符；在  头文件中。
1.原型：char *strncat(char *dest, const char *src, size_t n);
2.参数说明：
dest：指向目的字符串的指针，即要追加到的字符串。
src：指向源字符串的指针，即要追加的字符串。
n：指定追加的最大字符数。
3.返回值：
成功时返回 dest 指针。
如果发生错误，返回 NULL。
4.使用 strncat 函数时需要注意以下几点：
dest 必须以空字符（'\0'）结尾。
src 可以包含空字符，strncat 会将这些字符也复制过去。
如果 n 大于或等于 src 剩余的长度，strncat 会将 src 的所有剩余字符复制到 dest。
如果 n 为0，strncat 不会追加任何字符，但仍然会返回 dest。
dest 必须有足够的空间来存储追加的字符串，否则可能会导致缓冲区溢出。
5.简单示例：
#include 
#include 

int main() {
    char dest[100] = "Hello, ";
    char src[] = "World!";
    size_t n = 5; // 只追加前5个字符

    strncat(dest, src, n);
    printf("Result: %s\n", dest); // 输出: Hello, Wor

    return 0;
}

strtol函数，将字符串转换为长整型（long int）数值，在  头文件中。
原型：long int strtol(const char *str, char **endptr, int base);
参数说明：
 `str`：指向待转换字符串的指针。
 `endptr`：可选参数，指向一个字符指针的指针。如果提供了这个参数，`strtol` 函数会设置这个指针指向字符串中第一个无法转换为数字的字符。如果转换成功，`endptr` 会指向第一个无效字符；如果转换失败，`endptr` 会指向原始字符串。
 `base`：转换时使用的进制基数，可以是2到36之间的任何整数，或者是0。如果 `base` 为0，函数会根据字符串的前缀自动确定基数（例如，"0x" 表示十六进制，"0" 表示八进制）。
返回值：
- 成功时返回转换后的长整型数值。
- 如果发生溢出，返回 `LONG_MAX` 或 `LONG_MIN`（取决于符号）。
- 如果没有数字可以转换，返回0。
简单示例：
#include 
#include 

int main() {
    const char *str = "1234";
    char *endptr;
    long int value = strtol(str, &endptr, 10); // 将字符串转换为十进制长整型数值

    if (endptr == str) {
        printf("No digits were found\n");
    } else {
        printf("The converted value is %ld\n", value);
    }

    return 0;
}
示例中，`strtol` 函数将字符串 `"1234"` 转换为十进制长整型数值 `1234`。`endptr` 会指向字符串的末尾，因为整个字符串都是有效的数字。程序输出将是：

```
The converted value is 1234
```

`strtol` 函数是处理字符串到数值转换时的一个非常有用的工具，特别是在需要处理不同进制数值时。

习题8-7 字符串排序

#include
#include

int main(void) {
    char str[5][81];
    for (int i = 0; i < 5; i++) {
        scanf("%s", str[i]);
    }

    // 选择排序法对字符串进行排序
    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 5; j++) {
            if (strcmp(str[i], str[j]) > 0) {
                char temp[81];
                strcpy(temp, str[i]);
                strcpy(str[i], str[j]);
                strcpy(str[j], temp);
            }
        }
    }

    printf("After sorted:\n");
    for (int i = 0; i < 5; i++) {
        printf("%s\n", str[i]);
    }

    return 0;
}

知识点

strcmp函数，用于比较两个字符串，在  头文件中。
原型如下：int strcmp(const char *str1, const char *str2);
参数说明：
str1：指向第一个字符串的指针。
str2：指向第二个字符串的指针。
返回值：
如果 str1 小于 str2，则返回值小于0。
如果 str1 等于 str2，则返回值等于0。
如果 str1 大于 str2，则返回值大于0。
strcmp 函数是按字典顺序进行比较的，这意味着它会从两个字符串的第一个字符开始比较，如果字符不同，则比较它们的ASCII值来决定大小关系。如果第一个字符相同，则比较第二个字符，依此类推。如果两个字符串的某个对应位置上的字符不同，比较就结束了，返回值表明哪个字符串在字典顺序上更大。如果两个字符串完全相同，或者一个字符串是另一个字符串的前缀，则比较会进行到字符串的末尾。
简单例子：
#include 
#include 

int main() {
    const char *str1 = "Apple";
    const char *str2 = "apple";

    int result = strcmp(str1, str2);

    if (result < 0) {
        printf("'%s' is less than '%s'\n", str1, str2);
    } else if (result > 0) {
        printf("'%s' is greater than '%s'\n", str1, str2);
    } else {
        printf("'%s' is equal to '%s'\n", str1, str2);
    }

    return 0;
}
//输出结果为'Apple' is less than 'apple'
大写字母 'A' 的ASCII值小于 str2 中的小写字母 'a' 的ASCII值。
请注意，strcmp 是区分大小写的，所以在这个例子中大写的 "Apple" 被认为是小于小写的 "apple"。如果需要进行不区分大小写的比较，可以使用 strcasecmp 或 _stricmp（在不同的平台和编译器中名称可能不同）。

strcpy函数，用于将一个字符串复制到另一个字符串中，在  头文件中。
原型：char *strcpy(char *dest, const char *src);
参数说明：
dest：指向目的字符串的指针，即复制到的目标位置。
src：指向源字符串的指针，即要复制的字符串。
返回值：
成功时返回 dest 指针。
strcpy 函数会从 src 指向的位置开始复制字符，包括空字符（'\0'），直到遇到 src 字符串的终止符。然后，它会继续在 dest 上复制这个终止符，以确保 dest 也是一个以空字符结尾的字符串。
使用 strcpy 时需要注意以下几点：
dest 必须有足够的空间来存储源字符串 src，包括终止的空字符。
src 必须是一个以空字符结尾的字符串。
dest 和 src 不能重叠，否则可能会导致数据覆盖或未定义的行为。
简单示例：
#include 
#include 

int main() {
    char src[] = "Hello, World!";
    char dest[20]; // 确保有足够的空间来存储src字符串

    strcpy(dest, src);

    printf("Source: %s\n", src);
    printf("Destination: %s\n", dest);

    return 0;
}
//输出：Source: Hello, World!
Destination: Hello, World!
请注意，使用 strcpy 时要特别小心，因为它不检查目标缓冲区的大小，这可能导致缓冲区溢出。为了避免这种风险，可以使用 strncpy 函数，它允许指定最大复制的字符数，从而可以防止溢出

习题8-10 输出学生成绩

#include 
#include

int main() {
	int n;
	scanf("%d",&n);
	
	// 动态分配内存
	double *p = (double *) malloc(sizeof(double) * n);
	// 内存分配失败的处理
	if(p==NULL){
		return 1;
	}
	
	// 数组名为数组首地址，指针变量 p 为分配到的内存的首地址，故可如操作数组般操作指针
	for(int i=0;imax?p[i]:max;
		sum+=p[i];
	}
	
	printf("average = %.2lf\nmax = %.2lf\nmin = %.2lf", sum / n, max, min);
    free(p);
	
    return 0;
}

习题9-1 时间换算

#include 

int main() {
	int h,m,s,n;
	scanf("%d:%d:%d",&h,&m,&s);
	scanf("%d",&n);
	
	s+=n;
	if(s>=60){
		m++;
		s-=60;
	}
	
	if(m>=60){
		h++;
		m-=60;
	}
	
	h= h==24 ? 0 : h;
	printf("%02d:%02d:%02d",h,m,s);
	
    return 0;
}

知识点

%.2lf:输出两位小数
%02d:输出两个数，如果数字的位数不足以达到指定的宽度时，左边的空位将用 0 来填充。例子：如果整数是 1，那么使用 %02d 格式化输出将是 01；如果整数是 10，则直接输出 10。

习题9-3 平面向量加法

#include 
#include 

int main() {
	double x1,y1,x2,y2;
	scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
	
	//小数部分输出一位小数，四舍五入处理
	double x=fabs(x1+x2)<0.05 ? fabs(x1+x2) : x1+x2;
	double y=fabs(y1+y2)<0.05 ? fabs(y1+y2) : y1+y2;
	
	printf("(%.1f,%.1f)\n",x,y);
	
    return 0;
}

知识点

fabs函数，在  头文件中。

原型：
double fabs(double x);

参数说明：
x：要计算绝对值的浮点数。

返回值：
返回 x 的绝对值。

习题9-4 查找书籍

#include 
#include 

typedef struct{
	char name[31];
	double price;
}Book;

int main(void) {
	int n;
	scanf("%d",&n);
	getchar();
    
    Book book[10];
    for(int i=0;ibook[max].price ? i : max;
	}
	
	printf("%.2lf,%s\n",book[max].price,book[max].name);
	printf("%.2lf,%s\n",book[min].price,book[min].name);

    return 0; 
}

知识点

字符串输入获取时，不用加&

结构体（struct）
是一种复合数据类型，它允许你将多个不同或相同类型的变量组合成一个单一的逻辑单元。

1.结构体定义：
以 struct 关键字开始，后跟结构体的名称（可选），然后是在花括号 {} 中定义的一系列变量声明。这些变量被称为结构体的成员。例：
struct Student {
    int id;
    char name[50];
    float score;
};
在这个例子中，定义了一个名为 Student 的结构体，它包含三个成员：一个 int 类型的 id，一个 char 数组 name 和一个 float 类型的 score。



2.使用结构体
定义结构体后，你可以创建结构体变量，并访问其成员。例：
struct Student student1;  // 创建一个Student类型的变量student1

student1.id = 1;         // 访问并赋值给student1的id成员
strcpy(student1.name, "Alice");  // 使用strcpy函数复制字符串到student1的name成员
student1.score = 95.5;    // 赋值给student1的score成员




3.初始化结构体
你可以在声明结构体变量时初始化它：
struct Student student2 = {2, "Bob", 88.0};  // 初始化student2




4.结构体数组
你可以声明结构体数组来存储多个结构体实例。例：
struct Student students[3] = {
    {1, "Alice", 95.5},
    {2, "Bob", 88.0},
    {3, "Charlie", 90.0}
};




5.结构体指针
你可以使用指针来访问和操作结构体。例：
struct Student *ptr = &student1;  // ptr指向student1

ptr->id = 4;  // 使用箭头操作符访问ptr指向的结构体的id成员
strcpy(ptr->name, "David");  // 复制字符串到ptr指向的结构体的name成员
ptr->score = 92.0;  // 赋值给ptr指向的结构体的score成员




6.结构体和函数
你可以将结构体作为参数传递给函数，或者作为函数的返回值。例：
#include   // 包含标准输入输出库，用于打印函数
#include   // 包含字符串处理库，用于字符串复制函数strcpy

// 定义一个结构体来存储学生信息
typedef struct {
    int id;           // 学生的ID号
    char name[50];    // 学生的名字，假设最大长度为49个字符加上一个结束符'\0'
    float score;      // 学生的成绩
} Student;

// 函数声明
void printStudent(const Student s);  // 声明一个打印学生信息的函数
Student createStudent(int id, const char* name, float score);  // 声明一个创建学生信息的函数

int main() {
    // 创建一个学生信息
    Student student = createStudent(1, "John Doe", 88.5);  // 使用createStudent函数创建一个学生实例
    
    // 打印学生信息
    printStudent(student);  // 调用printStudent函数打印学生信息
    
    return 0;  // 程序正常结束
}

// 定义函数来打印学生信息
void printStudent(const Student s) {
    printf("Student ID: %d\n", s.id);  // 打印学生ID
    printf("Student Name: %s\n", s.name);  // 打印学生姓名
    printf("Student Score: %.2f\n", s.score);  // 打印学生成绩，保留两位小数
}

// 定义函数来创建学生信息
Student createStudent(int id, const char* name, float score) {
    Student s;  // 创建一个Student类型的变量s
    s.id = id;  // 将传入的id赋值给s的id成员
    strcpy(s.name, name);  // 使用strcpy函数将传入的name字符串复制到s的name成员
    s.score = score;  // 将传入的score赋值给s的score成员
    return s;  // 返回创建好的Student实例
}

宏定义

在C语言中，宏定义（Macro Definition）是一种预处理器指令，它允许你定义一个符号常量，使得在编译之前，预处理器可以对代码中的所有宏定义进行替换。
宏定义通常用于定义常量值、创建可多次使用的代码片段等。(不推荐使用函数样宏定义，易出现多次求值现象导致结果不准确)

基本语法如下：
#define identifier value
或者，对于没有值的标识符定义：
#define identifier

示例
1.定义常量：
#define MAX_SIZE 100
这里，MAX_SIZE 被定义为 100。在代码中任何出现 MAX_SIZE 的地方都会被预处理器替换为 100。

2.条件编译：
#include 
// 定义宏DEBUG，并赋值为1
#define DEBUG 1

int main() {
    int variable = 10;  // 声明并初始化变量variable

#if DEBUG
    // 如果宏DEBUG被定义，则编译并执行下面的代码
    printf("Debugging information: variable value = %d\n", variable);
#endif

    return 0;
}
由于 DEBUG 被定义，printf 语句会被执行，输出如下：
Debugging information: variable value = 10

3.函数样宏定义：
#define SQUARE(x) ((x) * (x))
这里定义了一个宏 SQUARE，它接受一个参数 x 并返回 x 的平方。在代码中使用 SQUARE(5) 会被替换为 (5) * (5)。

注意事项:
宏替换发生在编译之前：宏定义的替换是在编译之前进行的，这意味着宏替换不会进行类型检查，也不会受到作用域的限制。
宏与函数的区别：虽然宏可以模拟函数的行为，但它们与函数调用不同。宏在预处理阶段进行文本替换，不涉及函数调用的开销，但也可能导致一些意想不到的问题，比如宏参数的多次求值。
避免使用宏定义来定义函数：由于宏定义的函数在预处理阶段进行替换，可能会导致参数被多次求值，从而引发错误。在可能的情况下，推荐使用内联函数来替代函数样宏定义。
宏名通常全部大写：这是一种约定，用于区分宏和普通的变量或函数名。
宏定义是C语言中一个强大的特性，但应该谨慎使用，特别是在定义函数样宏时。正确使用宏定义可以提高代码的灵活性和可维护性。

习题9-5 通讯录排序

#include 

typedef struct{
	char name[10];
	int birthday;
	char number[17];
}Person;

int main(void) {
	int n;
	scanf("%d",&n);
	//吸收换行符 
	getchar();
    
    Person person[11];
    //要从1开始，因为0被后面拿去临时存储了 
    for(int i=1;i<=n;i++){ 
    	scanf("%s %d %s",&person[i].name,&person[i].birthday,&person[i].number);
    	getchar();
	}
	
	// 从余下 n-i 个人中挑选比 i 的年龄大的人，交换其值
	//选择排序方法 
	for(int i=1;iperson[j].birthday){
				person[0]=person[j];
				person[j]=person[i];
				person[i]=person[0];
			}
		}
	}
	
	for(int i=1;i<=n;i++){
		 printf("%s %d %s\n", person[i].name, person[i].birthday, person[i].number);
	}
	
    return 0; 
}

知识点

数学中的“不超过”通常意味着“小于等于”
编程中的“不超过”通常意味着“小于”