本文深入探讨C语言中指针的运用，包括基本指针操作、指针与数组、指针与字符串处理、以及指针在函数参数和返回值中的应用。通过多个实例，如数组元素输出、字符串复制与比较、矩阵转置等，展示如何有效利用指针解决复杂问题。
eg10.3输入a和b两个整数，按先大后小的顺序输出a和b
| #include<stdio.h> void swap(int *a, int *b); void swap(int *a, int *b){ void main(void){ swap(&m, &n); //等价于swap(p1,p2);
| #include<stdio.h> void swap(int *a, int *b); void swap(int *a, int *b){ //等价于swap(p1,p2);
| #include<stdio.h> void swap(int **a, int **b); void swap(int **a, int **b){ //swap(&(&m), &(&n)); //[Error]lvalue required as unary '&' operand //unary a.一元的
|
| 交换的是两个变量的值 | 交换的是两个指针的值 |
//eg10.3输入a和b两个整数，按先大后小的顺序输出a和b
/*
#include<stdio.h>
void swap(int *a, int *b);
void swap(int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void main(void){
int m, n;
int *p1 = &m, *p2 = &n;
printf("请输入两个整数：");
scanf("%d%d", &m, &n);
printf("这两个整数为：%d，%d\n\n", m, n);
swap(&m, &n);
printf("交换后的两个整数为：%d，%d\n", m, n);
printf("交换后两个指针指向的整数为：%d，%d\n", *p1, *p2);
}
*/
/*
#include<stdio.h>
void swap(int *a, int *b);
void swap(int *a, int *b){
int *tmp;
tmp = a;
a = b;
b = tmp;
}
void main(void){
int m, n;
int *p1 = &m, *p2 = &n;
printf("请输入两个整数：");
scanf("%d%d", &m, &n);
printf("这两个整数为：%d，%d\n\n", m, n);
swap(&m, &n);
printf("交换后的两个整数为：%d，%d\n", m, n);
printf("交换后两个指针指向的整数为：%d，%d\n", *p1, *p2);
}
*/
#include<stdio.h>
void swap(int **a, int **b);
void swap(int **a, int **b){
int *tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void main(void){
int m, n;
int *p1 = &m, *p2 = &n;
printf("请输入两个整数：");
scanf("%d%d", &m, &n);
printf("这两个整数为：%d，%d\n\n", m, n);
//swap(&(&m), &(&n)); //[Error]lvalue required as unary '&' operand //unary a.一元的
//swap(&&m, &&n); //[Error]label 'm' used but not defined [Error]label 'n' used but not defined
swap(&p1, &p2);
printf("交换后的两个整数为：%d，%d\n", m, n);
printf("交换后两个指针指向的整数为：%d，%d\n", *p1, *p2);
}
eg10.5输出数组中的全部元素
用for循环输出
| #include<stdio.h> void main(void){ | #include<stdio.h> void main(void){ | #include<stdio.h> void main(void){ | #include<stdio.h> void main(void){ p++; |
| 这个和下一个执行效率是相同的。C编译系统是将a[i]转换为*(a+i)处理的，即先计算地址元素。 | 比前两种方法快，用指针变量直接指向元素，不必每次都重新计算地址，像p++这样的自加操作是比较快的。 |
用while循环输出
| p = a; //*p++ <=> *p(++) 先得到p所指向的变量的值(即*p)，然后再使p+1=>p | p = a; while(p<a+10){ printf("%d ", *p); p++; } |
//1 2 3 4 5 6 7 8 9 0
/*
#include<stdio.h>
void main(void){
int a[10];
int i;
printf("请输入10个整数：");
for(i = 0; i < 10; i++){
scanf("%d", &a[i]);
}
printf("数组中的元素为：");
for(i = 0; i < 10; i++){
printf("%d ", a[i]);
}
printf("\n");
}
*/
/*
#include<stdio.h>
void main(void){
int a[10];
int i;
printf("请输入10个整数：");
for(i = 0; i < 10; i++){
scanf("%d", &a[i]);
}
printf("数组中的元素为：");
for(i = 0; i < 10; i++){
printf("%d ", *(a+i));
}
printf("\n");
}
*/
#include<stdio.h>
void main(void){
int a[10];
int i;
int *p;
printf("请输入10个整数：");
for(i = 0; i < 10; i++){
scanf("%d", &a[i]);
}
printf("数组中的元素为：");
for(p = a; p < (a+10); p++){
printf("%d ", *p);
}
printf("\n");
}eg10.7将数组a中n个整数按相反顺序存放
| void inv(int *a, int n){ | void inv(int *a, int n){ |
| 两种方法得到的结果相同，都可以实现题目要求功能 |
有一个实参数组，要想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下4种情况：
| void inv(int *a, int n){ ... }
void main(void){ ... | void inv(int a[], int n){ ... }
void main(void){ ... | void inv(int *a, int n){ ... }
void main(void){ int *p = a; ...
| void inv(int a[], int n){ ... }
void main(void){ int *p = a; ...
|
| 用数组名作函数的参数 fun(int arr[], int n) <=> fun(int *arr, int n) 实参数组名代表该数组首元素的地址，而形参是用来接收从实参传递过来的数组首元素地址的。因此，形参应该是一个指针变量(只有指针变量才能存放地址)。实际上，C编译都是将形参数组名作为指针变量来处理的。 在该函数被调用时，系统会建立一个指针变量arr，用来存放从主调函数传递过来的实参数组首元素的地址。 |
/*
#include<stdio.h>
void show(int a[], int n);
void inv(int *a, int n);
void inv(int *a, int n){
int i;
int tmp;
for(i = 0; i <= (n-1)/2; i++){
//for(i = 0; i < (n-1)/2; i++){ 不写=的话，最中间的那两个就没有交换
tmp = a[i];
a[i] = a[n-1-i];
a[n-1-i] = tmp;
}
printf("\n");
}
void show(int a[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", a[i]);
}
}
void main(void){
int a[10] = {3, 7, 9, 11, 0, 6, 7, 5, 4, 2};
printf("原数组中的元素为：");
show(a, 10);
printf("\n");
inv(a, 10);
printf("交换后数组中的元素为：");
show(a, 10);
}
*/
#include<stdio.h>
void show(int a[], int n);
void inv(int *a, int n);
void inv(int *a, int n){
int *p,*q;
int tmp;
for(p = a, q = a+n-1; p <= a+(n-1)/2; p++, q--){
tmp = *p;
*p = *q;
*q = tmp;
}
printf("\n");
}
void show(int a[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", a[i]);
}
}
void main(void){
int a[10] = {3, 7, 9, 11, 0, 6, 7, 5, 4, 2};
printf("原数组中的元素为：");
show(a, 10);
printf("\n");
inv(a, 10);
printf("交换后数组中的元素为：");
show(a, 10);
}eg10.11用指针变量输出二维数组元素的值
| #include<stdio.h> void main(void){
| #include<stdio.h> void main(void){
| #include<stdio.h> void main(void){
|
//这种方法首先就会出现一个回车，然后才会输出数值
#include<stdio.h>
void main(void){
int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
int *p;
for(p=a[0]; p < a[0]+12; p++){
if((p-a[0])%4 == 0){ //输出4个数据后换行
printf("\n");
}
printf("%4d", *p);
}
printf("\n");
}
/*
#include<stdio.h>
void main(void){
int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
int *p;
for(p=a[0]; p < a[0]+12; p++){
if((p+1-a[0])%4 == 0){ //输出4个数据后换行
printf("\n");
}
printf("%4d", *p);
}
printf("\n");
}
*/
/*
#include<stdio.h>
void main(void){
int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
int *p;
for(p=a[0]; p < a[0]+12; p++){
printf("%4d", *p);
if((p+1-a[0])%4 == 0){ //输出4个数据后换行
printf("\n");
}
}
printf("\n");
}
*/
eg10.12输出二维数组任一行任一列元素的值
| #include<stdio.h> void main(void){ | #include<stdio.h> void main(void){ |
| p是指向整型数据的，p+1所指向的元素是p所指向的元素的下一元素。 | p是指向一个包含m个元素的一维数组，p的增值以一维数组的长度为单位。 |
 |
/*
#include<stdio.h>
void main(void){
int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
int (*p)[4];
int i,j;
p = a;
printf("请输入行号和列号：");
scanf("%d%d", &i, &j);
printf("a[%d][%d]=%d\n", i, j, *(*(p+i)+j));
}
*/
#include<stdio.h>
void main(void){
int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};
int *p;
int i,j;
p = a[0];
printf("请输入行号和列号：");
scanf("%d%d", &i, &j);
printf("a[%d][%d]=%d\n", i, j, *(p+i*4+j));
}eg10.13有3个学生各学4门课，计算总平均分数以及第n个学生的成绩
多维数组名做函数参数
| 1.用指向变量的指针变量 | 2.用指向一维数组的指针变量 |
| float average(float *s, int n){ void main(void){ av = average(*score, 12); //*score, 即score[0]，即&score[0][0] | void search(float (*s)[4], int n){
void main(void){ |
#include<stdio.h>
float average(float *s, int n);
void search(float (*s)[4], int n, float s1[]);
void search(float (*s)[4], int n, float s1[]){
int i;
float (*p)[4];
for(i = 0, p = s+n; i < 4; i++){
//printf("%.2f ", *(*p+i));
s1[i] = *(*p+i);
//printf("%.2f ", s1[i]);
}
}
float average(float *s, int n){
float *p;
float sum = 0;
for(p = s; p < s+n; p++){
//for(p = s; p < s+n-1; p++){
sum += *p;
}
return sum*1.0/n;
}
void main(void){
float score[3][4] = {{65, 67, 70, 60}, {80, 87, 90, 81}, {90, 99, 100, 98}};
float av;
float se[4];
int m;
int i;
av = average(*score, 12);
printf("总的平均分为：%.2f\n", av);
printf("请输入要查找的学生的序号(不超过2)：");
scanf("%d", &m);
search(score, m, se);
printf("\n第%d个学生的成绩为：", m+1);
for(i = 0; i < 4; i++){
printf("%.2f ", se[i]);
}
}eg10.14在上题基础上，查找有一门以上课程不及格的学生，输出他们的全部课程的成绩
#include<stdio.h>
void searchNotQualified(float (*a)[4], int n);
void searchNotQualified(float (*a)[4], int n){
int i, j;
int flag;
for(i = 0; i < n; i++){
flag = 0;
for(j = 0; j < 4; j++){
if(*(*(a+i)+j) < 60){
flag=1;
}
}
if(flag == 1){
printf("序号为%d的学生成绩不及格，各科分数为：", i);
for(j = 0; j < 4; j++){
printf("%.2f ", *(*(a+i)+j));
}
printf("\n");
}
}
}
void main(void){
float score[3][4] = {{65, 57, 70, 60}, {80, 87, 90, 81}, {90, 99, 100, 98}};
searchNotQualified(score, 3);
}
eg10.15定义一个字符数组，对它初始化，然后输出该字符串
eg10.16定义字符指针
C语言中，可以用两种方法访问一个字符串
| (1)用字符数组存放一个字符串 | (2)用字符指针指向一个字符串 |
| #include<stdio.h> void main(void){ | void main(void){ char *string = "I love China!"; printf("%s\n", string); } |
| char *string = "I love China!"; <=> char *string； string = "I love China!"; | |
| 把"I love China!"的第一个字符的地址赋给指针变量string，string只能指向一个字符变量 | |
| printf(“%s…”, …)与puts(…)只有一点点差别： printf(“%s\n”, s); <=> puts(s); puts()函数输出字符串后，自动换行。 | %s是输出字符串时所用的格式符，在输出项中给出字符指针变量名string，则系统先输出它所指向的一个字符数据，然后自动使string加1，使之指向下一个字符，然后再输出一个字符……如此直到遇到字符串结束标志'\0'为止。 |
#include<stdio.h>
void main(void){
char string[] = "I love China!";
printf("%s\n", string);
} #include<stdio.h>
void main(void){
char *string = "I love China!";
printf("%s\n", string);
}eg10.17将字符串a复制为字符串b
eg10.18用指针变量处理eg10.17问题
对字符串中字符的存取，可以用下标方法，也可以用指针方法。
| 7.15字符串拷贝 | 下标法 | 和2等价 | 指针方法 |
| #include<stdio.h> #include<string.h> void main(void){ char str1[80] = {0}; char str2[80] = {0}; int index = -1; int i; printf("请输入第二串字符："); gets(str2); index = strlen(str2); printf("字符串结束标志下标为：%d\n",index); printf("拷贝前的第一串字符为："); puts(str1); for(i = 0; i < index+1; i++){ str1[i] = str2[i]; } printf("拷贝后的第一串字符为："); puts(str1); } | #include<stdio.h> #include<string.h> void main(void){ char str1[80] = {0}; char str2[80] = {0}; int i; printf("请输入第二串字符："); gets(str2); printf("拷贝前的第一串字符为："); puts(str1); for(i = 0; str2[i] != '\0'; i++){ str1[i] = str2[i]; } str1[i] = str2[i]; printf("拷贝后的第一串字符为："); puts(str1); } | #include<stdio.h> #include<string.h> void main(void){ char str1[80] = {0}; char str2[80] = {0}; int i; printf("请输入第二串字符："); gets(str2); printf("拷贝前的第一串字符为："); puts(str1); for(i = 0; *(str2+i) != '\0'; i++){ *(str1+i) = *(str2+i); } *(str1+i) = '\0'; printf("拷贝后的第一串字符为："); puts(str1); } | #include<stdio.h> #include<string.h> void main(void){ char str1[80] = {0}; char str2[80] = {0}; char *p1; char *p2; printf("请输入第二串字符："); gets(str2); printf("拷贝前的第一串字符为："); puts(str1); for(p1 = str1, p2 = str2; *p2 != '\0'; p1++, p2++){ *p1 = *p2; } *p1 = '\0'; printf("拷贝后的第一串字符为："); puts(str1); } |
/*
//7.15字符串拷贝，不要用strcpy函数
#include<stdio.h>
#include<string.h>
void main(void){
char str1[80] = {0};
char str2[80] = {0};
int index = -1;
int i;
printf("请输入第二串字符：");
gets(str2);
index = strlen(str2);
printf("字符串结束标志下标为：%d\n",index);
printf("拷贝前的第一串字符为：");
puts(str1);
for(i = 0; i < index+1; i++){
str1[i] = str2[i];
}
printf("拷贝后的第一串字符为：");
puts(str1);
}
*/
/*
//课本
#include<stdio.h>
#include<string.h>
void main(void){
char str1[80] = {0};
char str2[80] = {0};
int i;
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
for(i = 0; str2[i] != '\0'; i++){
str1[i] = str2[i];
}
str1[i] = str2[i]; //str1[i] = '\0'; 这样写也可以 //把最后的那个'\0'复制过去
printf("拷贝后的第一串字符为：");
puts(str1);
}
*/
//课本
#include<stdio.h>
#include<string.h>
void main(void){
char str1[80] = {0};
char str2[80] = {0};
int i;
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
for(i = 0; *(str2+i) != '\0'; i++){
*(str1+i) = *(str2+i);
}
*(str1+i) = '\0'; //str1[i] = '\0'; 这样写也可以 //把最后的那个'\0'复制过去
printf("拷贝后的第一串字符为：");
puts(str1);
}#include<stdio.h>
#include<string.h>
void main(void){
char str1[80] = {0};
char str2[80] = {0};
char *p1;
char *p2;
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
for(p1 = str1, p2 = str2; *p2 != '\0'; p1++, p2++){
*p1 = *p2;
}
*p1 = '\0';
printf("拷贝后的第一串字符为：");
puts(str1);
}eg10.19用函数调用实现字符串的复制
| 将一个字符串从一个函数传递到另一个函数，可以用地址传递的方法(即用字符数组名作参数)，也可以用指向字符的指针变量作参数。在被调用的函数中可以改变字符串的内容，在主调函数中可以得到改变了的字符串。 | ||||||||
| 归纳起来，作为函数参数，有以下几种情况：
|
//字符串2复制到字符串1
/*
#include<stdio.h>
#include<string.h>
void stringCopy(char from[], char to[]);
void stringCopy(char from[], char to[]){
int i = 0;
while(from[i] != '\0'){
to[i] = from[i];
i++;
}
to[i] = '\0';
}
void main(void){
char str1[80] = {0};
char str2[80] = {0};
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
stringCopy(str2, str1);
printf("拷贝后的第一串字符为：");
puts(str1);
}
*/
/*
#include<stdio.h>
#include<string.h>
void stringCopy(char from[], char to[]);
void stringCopy(char from[], char to[]){
int i = 0;
while(from[i] != '\0'){
to[i] = from[i];
i++;
}
to[i] = '\0';
}
void main(void){
char str1[80] = {0};
char str2[80] = {0};
char *p1 = str1;
char *p2 = str2;
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
stringCopy(p2, p1);
printf("拷贝后的第一串字符为：");
puts(str1);
}
*/
/*
#include<stdio.h>
#include<string.h>
void stringCopy(char *from, char *to);
void stringCopy(char *from, char *to){
while(*from != '\0'){
*to = *from;
from++;
to++;
}
*to = '\0';
}
void main(void){
char str1[80] = {0};
char str2[80] = {0};
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
stringCopy(str2, str1);
printf("拷贝后的第一串字符为：");
puts(str1);
}
*/
#include<stdio.h>
#include<string.h>
void stringCopy(char *from, char *to);
void stringCopy(char *from, char *to){
while(*from != '\0'){
*to = *from;
from++;
to++;
}
*to = '\0';
}
void main(void){
char str1[80] = {0};
char str2[80] = {0};
char *p1 = str1;
char *p2 = str2;
printf("请输入第二串字符：");
gets(str2);
printf("拷贝前的第一串字符为：");
puts(str1);
stringCopy(p2, p1);
printf("拷贝后的第一串字符为：");
puts(str1);
}本章习题均要求用指针处理
10.1(20)输入3个整数，按由小到大的顺序输出
// 6:55 - 7:15
#include<stdio.h>
void sort(int *a, int *b, int *c);
void swap(int *a, int *b);
void swap(int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void sort(int *a, int *b, int *c){ //按 a<b<c 排
if(*a > *b){
swap(a, b); //使a成为a b中较小的一个
}
if(*a > *c){
swap(a, c); //使a成为a c中较小的一个
} //所以，a是三者中最小的一个
if(*b > *c){
swap(b, c); //使b成为b c中较小的一个
}
}
void main(void){
int a, b, c;
int a1, b1, c1;
printf("请输入3个整数：");
scanf("%d%d%d", &a, &b, &c);
printf("\n这3个整数为：%d %d %d\n", a, b, c);
a1 = a;
b1 = b;
c1 = c;
sort(&a1, &b1, &c1);
printf("\n按由小到大的顺序排序为：%d %d %d\n", a1, b1, c1);
}
10.2(45)输入3个字符串，按由小到大的顺序输出
| void swap(char *a, char *b){ //char *tmp = a; *tmp = *a; *a = *b; *b = *tmp; } | void swap(char *a, char *b){ char tmp[ARRAY_SIZE]; //char *tmp = a; *tmp = *a; *a = *b; *b = *tmp; } |
 |  |
| 这样子的函数其实只能交换每个字符串的第一个字符，但tmp的初值实在是无处安放，要是真的想交换第一个字符，就要先让tmp指向这三个之外的一个字符串，这样才可以达到目的。 | 定义tmp为一个字符数组，而不是指针变量，就可以了 |
| void swap(char *a, char *b){ char tmp[ARRAY_SIZE]; //char *tmp; *tmp = *a; *a = *b; *b = *tmp; } | void swap(char *a, char *b){ char tmp[ARRAY_SIZE]; //char *tmp; tmp = a; a = b; b = tmp; } | void swap(char *a, char *b){ char tmp[ARRAY_SIZE]; //char *tmp; strcpy(tmp, a); strcpy(a, b); strcpy(b, tmp); } |
|  |  |
| 这样只能交换每个字符串的第一个字符 | 这样子交换的是指针的值，但是指针的值并不会通过函数传递出来，我们的目的是通过指针的指向改变内存中字符串的值。 | 这才是正解 |
// 7:20 - 8:05
/*
I study very hard.
C language is very interesting.
He is a professor.
*/
#include<stdio.h>
#include<string.h>
#define ARRAY_SIZE 80
void swap(char *a, char *b);
/*
void swap(char *a, char *b){
char tmp[ARRAY_SIZE]; //char *tmp;
*tmp = *a;
*a = *b;
*b = *tmp;
}
*/
/*
void swap(char *a, char *b){
char *tmp;
tmp = a;
a = b;
b = tmp;
}
*/
void swap(char *a, char *b){
char tmp[ARRAY_SIZE]; //char *tmp;
strcpy(tmp, a);
strcpy(a, b);
strcpy(b, tmp);
}
void main(void){
char s1[ARRAY_SIZE];
char s2[ARRAY_SIZE];
char s3[ARRAY_SIZE];
char *p1 = s1;
char *p2 = s2;
char *p3 = s3;
printf("请输入3个字符串：\n");
gets(p1);
gets(p2);
gets(p3);
if(strcmp(p1, p2) > 0){
swap(p1, p2);
}
printf("\n按由小到大的顺序排序为：\n%s\n%s\n%s\n", p1, p2, p3);
if(strcmp(p1, p3) > 0){
swap(p1, p3);
}
printf("\n按由小到大的顺序排序为：\n%s\n%s\n%s\n", p1, p2, p3);
if(strcmp(p2, p3) > 0){
swap(p2, p3);
}
printf("\n按由小到大的顺序排序为：\n%s\n%s\n%s\n", p1, p2, p3);
}10.3(30)输入10个整数，将其中最小的数与第一个数对换，把最大的数与最后一个数对换
忘记用指针了
/*
10.3输入10个整数，将其中最小的数与第一个数对换，把最大的数与最后一个数对换
写3个函数：
1)输入10个数
2)进行处理
3)输出10个数
*/
// 8:30 - 9:00
//32 24 56 78 1 98 36 44 29 6
#include<stdio.h>
void initial(int num[], int n);
void show(int num[], int n);
void fun(int num[], int n);
void fun(int num[], int n){
int min = num[0];
int max = num[0];
int minIndex = 0;
int maxIndex = 0;
int i;
for(i = 0; i < n; i++){
if(num[i] < min){
min = num[i];
minIndex = i;
}
if(num[i] > max){
max = num[i];
maxIndex = i;
}
}
printf("min=%d, minIndex=%d, max=%d, maxIndex=%d\n", min, minIndex, max, maxIndex);
num[minIndex] = num[0];
num[0] = min;
num[maxIndex] = num[n-1];
num[n-1] = max;
}
void show(int num[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", num[i]);
}
printf("\n");
}
void initial(int num[], int n){
int i;
for(i = 0; i < n; i++){
scanf("%d", &num[i]);
}
}
#include<stdio.h>
void main(void){
int num[10];
printf("请输入10个整数：");
initial(num, 10);
printf("这10个整数为：");
show(num, 10);
fun(num, 10);
printf("经过变换之后的10个整数为；");
show(num, 10);
}10.4(20)有n个整数，使前面各数顺序向后移m个位置，最后m个数变成最前面m个数
// 5:27 - 5:47
/*
8
12 43 65 67 8 2 7 11
4
*/
#include<stdio.h>
void initial(int num[], int n);
void show(int num[], int n);
void move(int num[], int n, int m);
void move(int num[], int n, int m){
int tmp[m];
int *p;
int *q;
for(p = num+n-m, q = tmp; p < num+n; p++, q++){
*q = *p;
}
printf("这%d个数为：",m);
show(tmp, m);
//前面的数往后移
for(p = num; p < num+n-m; p++){
*(p+m) = *p;
}
//把后面的移到前面
for(p = num, q = tmp; p < num+m; p++, q++){
*p = *q;
}
}
void show(int num[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", num[i]);
}
printf("\n");
}
void initial(int num[], int n){
int i;
for(i = 0; i < n; i++){
scanf("%d", &num[i]);
}
}
void main(void){
int num[100];
int n;
int m;
printf("请输入要输入整数的个数(不超过100)：");
scanf("%d", &n);
printf("请输入这%d个整数：", n);
initial(num, n);
printf("请输入要移动的个数：");
scanf("%d", &m);
move(num, n, m);
printf("移动后数组的值为：");
show(num, n);
}10.5(50)有n个人围成一圈，顺序排号。从第一个人开始报数(从1到3报数)，凡报到3的人退出圈子，问最后留下的是原来第几号的那位(棒棒哒)
// 5:55 - 6:45
/*
8 7
10
*/
#include<stdio.h>
void initial(int num[], int n);
void show(int num[], int n);
int move(int num[], int n);
int move(int num[], int n){
int *p = num;
int m = 1;
int *q;
while(n > 1){ //while(当数组里大于一个元素时){
if(m == 3){
printf("\n删除的人是：%d\n", *p);
for(q = p+1; q < num+n; q++){ //删除报到3的人
*(q-1) = *q;
}
printf("删除之后数组的元素有：");
n--; //删除一个，总数就减1
show(num, n);
m = 1;
}else{
p++;
m++;
}
if(p == num+n){
p = num;
}
}
}
void show(int num[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", num[i]);
}
printf("\n");
}
void initial(int num[], int n){
int i;
for(i = 0; i < n; i++){
num[i] = i+1;
}
}
void main(void){
int num[100];
int n;
printf("请输入要输入整数的个数(不超过100)：");
scanf("%d", &n);
initial(num, n);
printf("\n这%d个整数为：", n);
show(num, n);
move(num, n);
}10.6(5)写一函数，求一个字符串的长度
//10.6写一函数，求一个字符串的长度。
//在main函数中输入字符串，并输出其长度
//China 5
// 7:00 - 7:05
#include<stdio.h>
#include<string.h>
int stringLength(char s[]);
int stringLength(char s[]){
//方法1：用字符串处理函数
//return strlen(s);
//方法2：不是要用指针嘛，那就用呗
char *p = s;
int i = 0;
while(*p != '\0'){
i++;
p++;
}
return i;
}
void main(void){
char str[80];
int length;
printf("请输入一个字符串：");
gets(str);
length = stringLength(str);
printf("字符串的长度为：%d\n", length);
} 10.7(10)有一字符串，包含n个字符。写一函数，将此字符串中从第m个字符开始的全部字符复制成为另一个字符串
// 7:15 - 7:25
//reading-room 9 room
#include<stdio.h>
#include<string.h>
void stringPartCopy(char str[], int m, char s[]);
void stringPartCopy(char str[], int m, char s[]){
char *p;
char *q;
for(p = str+m-1, q = s; *p != '\0'; p++, q++){
*q = *p;
}
*q = '\0';
}
void main(void){
char str[80];
char s[80];
int m;
printf("请输入一个字符串：");
gets(str);
printf("请输入要复制字符的位置：");
scanf("%d", &m);
stringPartCopy(str, m, s);
printf("复制后的字符串为：%s\n", s);
}
10.8输入一行文字，找出其中大写字母、小写字母、空格、数字以及其他字符各有多少？(前面写过好几遍，这个就不写了)
10.9(25)写一函数，将一个3x3的整型矩阵转置
// 7:35 - 8:00
//1 2 3 4 5 6 7 8 9
#include<stdio.h>
void inputData(int *a, int n);
void showData(int (*a)[3], int row);
void convert(int *p, int row, int col);
void swap(int *a, int *b);
void swap(int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void convert(int *p, int row, int col){
int i;
int j;
for(i = 0; i < row; i++){
for(j = i+1; j < col; j++){
swap(p+i*3+j, p+j*3+i);
}
}
}
void showData(int (*a)[3], int row){
int (*p)[3];
int j;
for(p = a; p < a+row; p++){ //遍历行数
for(j = 0; j < 3; j++){
printf("%d ", *(*p+j));
}
printf("\n");
}
}
void inputData(int *a, int n){
int *p;
for(p = a; p < a+n; p++){
scanf("%d", p);
}
}
void main(void){
int a[3][3] = {0};
printf("请输入一个3x3的整数数组：");
inputData(*a, 9);
printf("\n这个整型数组的元素有：\n");
showData(a, 3);
convert(*a, 3, 3);
printf("\n转置后整型数组的元素有：\n");
showData(a, 3);
}10.10将一个5x5的矩阵中最大的元素放在中心，4个角分别放4个最小的元素
/*
10.10将一个5x5的矩阵中最大的元素放在中心，4个角分别放4个最小的元素
(顺序为从左到右、从上到下顺序依次从小到大存放)
*/
/*
35 34 33 32 31
30 29 28 27 26
25 24 23 22 21
20 19 18 17 16
15 14 13 12 11
*/
#include<stdio.h>
#define ROW 5
#define COL 5
void inputData(int *a);
void showData(int (*a)[COL]);
void fun(int *a);
void swap(int *a, int *b);
void swap(int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void fun(int *a){
int i;
int j;
int *p = a;
int *pmax = a;
int *pmin = a;
//找最大值和最小值
for(i = 0; i < ROW; i++){
for(j = 0; j < COL; j++, p++){
if(*p > *pmax){
pmax = p;
}
if(*p < *pmin){
pmin = p;
}
}
}
printf("\n最大值为：%d，最小值为：%d\n", *pmax, *pmin);
swap(a+ROW/2*COL+COL/2, pmax);
swap(a, pmin);
//找次小值
p = a;
pmin = p+1;
for(i = 0; i < ROW; i++){
for(j = 0; j < COL; j++, p++){
if(p != a){
if(*p < *pmin){
pmin = p;
}
}
}
}
printf("次小值为：%d\n", *pmin);
swap(a+COL-1, pmin);
//找第三小值
p = a;
pmin = p+1;
for(i = 0; i < ROW; i++){
for(j = 0; j < COL; j++, p++){
if(p != a && p != a+COL-1){
if(*p < *pmin){
pmin = p;
}
}
}
}
printf("第三小值为：%d\n", *pmin);
swap(a+(ROW-1)*COL, pmin);
//找第四小值
p = a;
pmin = p+1;
for(i = 0; i < ROW; i++){
for(j = 0; j < COL; j++, p++){
if(p != a && p != a+COL-1 && p != a+(ROW-1)*COL){
if(*p < *pmin){
pmin = p;
}
}
}
}
printf("第四小值为：%d\n", *pmin);
swap(a+(ROW-1)*COL+(COL-1), pmin);
}
void showData(int (*a)[COL]){
int (*p)[COL];
int j;
for(p = a; p < a+ROW; p++){ //遍历行数
for(j = 0; j < COL; j++){
printf("%d ", *(*p+j));
}
printf("\n");
}
}
void inputData(int *a){
int *p;
for(p = a; p < a+ROW*COL; p++){
scanf("%d", p);
}
}
void main(void){
int a[ROW][COL] = {0};
printf("请输入一个%dx%d的整数数组：\n", ROW, COL);
inputData(*a);
printf("\n这个整型数组的元素有：\n");
showData(a);
fun(*a);
printf("\n处理后整型数组的元素有：\n");
showData(a);
} 10.11(65)在主函数中输入10个等长的字符串，用另一函数对它们排序，然后在主函数输出这10个已经排好序的字符串
//10.11在主函数中输入10个等长的字符串，用另一函数对它们排序，然后在主函数输出这10个已经排好序的字符串
// 6:10 - 7:15
/* 10.11的测试用例
China
Japan
Korea
Egypt
Nepal
Burma
Ghana
Sudan
Italy
Libya
*/
/*
China
Japan
Ejipa
Egypt
Nepal
Burma
Ghana
Sudan
Italy
Libya
*/
/* 10.12的测试用例
China
Japan
Yemen
Pakistan
Mexico
Korea
Brazil
Iceland
Canada
Mongolia
*/
#include<stdio.h>
#include<string.h>
void stringSort(char (*a)[20], int row);
void stringSwap(char a[], char b[]);
void stringShow(char (*a)[20], int row);
void stringShow(char (*a)[20], int row){
int i;
int j;
char (*p)[20];
for(i = 0, p = a; i < row; i++, p++){
printf("No:%2d: %s\n", i+1, *p);
}
}
void stringSwap(char a[], char b[]){
char tmp[20];
strcpy(tmp, a);
strcpy(a, b);
strcpy(b, tmp);
}
/*
//自己傻啦吧唧地在那比较字符串，还在想怎么把这些字符都遍历一遍
//真是傻呀，人家有专门的字符串比较函数呀
void stringSort(char (*a)[20], int row){
char (*p)[20];
int i;
int j;
int k;
char s[10]; //存放每个字符串相同序号的字符
char (*q)[20];
//for(j = 0; j < strlen(*a); j++){ //
for(i = 0; i < row-1; i++){//for(p = a; p < a+row; p++){
for(k = 0, p = a; k < row-1-i; k++, p++){
if(*(*p) > *(*(p+1))){//if(*(*p+j) > *(*(p+1)+j)){
stringSwap(*p, *(p+1));
}
}
//看看有没有相同的字符
for(i = 0, q = a; i < row; i++, q++){
s[i] = **q;
}
printf("排好序的字符为：");
show(s, 10);
}
//}
}
*/
void stringSort(char (*a)[20], int row){
char (*p)[20];
int i;
int k;
for(i = 0; i < row-1; i++){//for(p = a; p < a+row; p++){
for(k = 0, p = a; k < row-1-i; k++, p++){
if(strcmp(*p, *(p+1)) > 0){ // if(*(*p) > *(*(p+1))){//if(*(*p+j) > *(*(p+1)+j)){
stringSwap(*p, *(p+1));
}
}
}
}
void main(void){
int i = 0;
char a[10][20];
printf("请输入10个等长的字符串：\n");
while(i < 10){
printf("No.%2d: ", i+1);
gets(a[i]);
i++;
}
printf("输入的字符串为：\n");
stringShow(a, 10);
stringSort(a, 10);
printf("排序后的字符串为：\n");
stringShow(a, 10);
}eg10.27使用指向指针的指针
#include<stdio.h>
void main(void){
char *name[] = {"Follow me", "BASIC", "The Great Wall", "FORTRAN", "Computer Design"};
char **p;
int i;
for(i = 0; i < 5; i++){
p = name+i;
printf("%s\n", *p);
}
}eg10.28指针数组的元素指向整型数组
#include<stdio.h>
void main(void){
int a[5] = {1, 3, 5, 7, 9};
int *num[5] = {&a[0], &a[1], &a[2], &a[3], &a[4]};
int **p;
int i;
p = num;
for(i = 0; i < 5; i++){
printf("%d ", **p);
p++;
}
printf("\n");
}10.12用指针数组处理上一题目，字符串不等长
优先级：()>[]>*
| 用指针数组作为参数
void stringSort(char *a[], int row);
void main(void){ int i = 0; stringSort(p, 10); } |
/* 10.12的测试用例
China
Japan
Yemen
Pakistan
Mexico
Korea
Brazil
Iceland
Canada
Mongolia
*/
#include<stdio.h>
#include<string.h>
void stringSort(char *a[], int row);
void stringSwap(char a[], char b[]);
void stringShow(char (*a)[20], int row);
void stringShow(char (*a)[20], int row){
int i;
char (*p)[20];
for(i = 0, p = a; i < row; i++, p++){
printf("No:%2d: %s\n", i+1, *p);
}
}
void stringSwap(char a[], char b[]){
char tmp[20];
strcpy(tmp, a);
strcpy(a, b);
strcpy(b, tmp);
}
void stringSort(char *a[], int row){
int i;
int k;
for(i = 0; i < row-1; i++){//for(p = a; p < a+row; p++){
for(k = 0; k < row-1-i; k++){
if(strcmp(a[k], a[k+1]) > 0){ // if(*(*p) > *(*(p+1))){//if(*(*p+j) > *(*(p+1)+j)){
stringSwap(a[k], a[k+1]);
}
}
}
}
void main(void){
int i = 0;
char a[10][20];
char *p[10];
for(i = 0; i < 10; i++){
p[i] = a[i];
}
i = 0;
printf("请输入10个不等长的字符串：\n");
while(i < 10){
printf("No.%2d: ", i+1);
gets(a[i]);
i++;
}
printf("输入的字符串为：\n");
stringShow(a, 10);
stringSort(p, 10);
printf("排序后的字符串为：\n");
stringShow(a, 10);
} eg10.22求a和b中的最大值(指向函数的指针)
函数的调用
| 可以通过函数名调用 | 也可以通过函数指针调用(即用指向函数的指针变量调用) |
| #include<stdio.h>
int max(int a, int b);
int max(int a, int b){
void main(void){ | #include<stdio.h>
int max(int a, int b);
int max(int a, int b){
void main(void){ |
| int (*p)(int, int); //定义 用来定义p是一个指向函数的指针变量，它不是固定指向哪一个函数的，而只是表示定义了这样一个类型的变量，它是专门用来存放函数的入口地址的。在程序中把哪一个函数的地址赋给它，它就指向哪一个函数。在一个程序中，一个指针变量可以先后指向同类型的不同函数。 *p两侧的括号不可省略，表示p先与*结合，是指针变量，然后再与后面的()结合，表示此指针变量指向函数。
p = max; //赋值 在给函数指针变量赋值时，只需给出函数名而不必给出参数，因为这是将函数的地址赋给p，不涉及实参与形参的问题。 将函数max的人口地址赋给指针变量p 这时，p是指向函数max的指针变量 调用*p就是调用max函数 (注)p是指向函数的指针变量，它只能指向函数的入口地址而不可能指向函数中的某一条指令处。对指向函数的指针变量，像p+n、p++、p--等运算都是无意义的。
c = (*p)(a, b); //调用 <=>c = max(a, b); 用函数指针变量调用函数时，只需将(*p)代替函数名即可，在(*p)后面的括号中根据需要写上实参。 |
#include<stdio.h>
int max(int a, int b);
int max(int a, int b){
return (a>b) ? a : b;
}
void main(void){
int a, b, c;
printf("请输入两个整数：");
scanf("%d%d", &a, &b);
c = max(a, b);
printf("%d和%d中的最大值是：%d\n", a, b, c);
}#include<stdio.h>
int max(int a, int b);
int max(int a, int b){
return (a>b) ? a : b;
}
void main(void){
int a, b, c;
int (*p)(int, int); //p是一个指向函数的指针
printf("请输入两个整数：");
scanf("%d%d", &a, &b);
p = max;
c = (*p)(a, b);
printf("%d和%d中的最大值是：%d\n", a, b, c);
}eg10.23有一个函数process，在调用它的时候，每次实现不同的功能(用指向函数的指针作函数参数)
| int max(int a, int b);
void main(void){ |
/*
eg10.23有一个函数process，在调用它的时候，每次实现不同的功能
输入a和b两个数
第一次调用process时找出a和b中大者
第二次找出其中小者
第三次求a与b之和
*/
#include<stdio.h>
int max(int a, int b);
int min(int a, int b);
int add(int a, int b);
void process(int (*p)(int, int), int x, int y);
void process(int (*p)(int, int), int x, int y){
int result;
result = (*p)(x, y);
printf("%d\n", result);
}
int add(int a, int b){
return a+b;
}
int min(int a, int b){
return (a<b) ? a : b;
}
int max(int a, int b){
return (a>b) ? a : b;
}
void main(void){
int a, b, c;
printf("请输入两个整数：");
scanf("%d%d", &a, &b);
printf("%d和%d中的最大值是：", a, b);
process(max, a, b);
printf("%d和%d中的最小值是：", a, b);
process(min, a, b);
printf("%d和%d之和是：", a, b);
process(add, a, b);
} 10.13编写一个用矩形法求定积分的通用函数(用指向函数的指针作函数参数)
#include<stdio.h>
#include<math.h>
void integral(float a, float b, float (*fun)(float), float n);
float f1(float x);
float f2(float x);
float f3(float x);
float f3(float x){
return exp(x);
}
float f2(float x){
return cos(x);
}
float f1(float x){
return sin(x);
}
void integral(float a, float b, float (*fun)(float), float n){
float dx = (b-a)*1.0/n;
float sum=0;
float x;
for(x = a+dx; x <= b; x+=dx){ //for(x = a; x < b; x+=dx){
sum+=(*fun)(x)*dx; //sum+=fun(x)*dx;
}
printf("%f\n", sum);
}
void main(void){
float a;
float b;
float n = 20;
printf("请输入积分上下限(第1个应小于第2个)：");
scanf("%f%f", &a, &b);
printf("sin(x)在(%.2f, %.2f)之间的积分值为：", a, b);
integral(a, b, f1, n);
printf("cos(x)在(%.2f, %.2f)之间的积分值为：", a, b);
integral(a, b, f2, n);
printf("exp(x)在(%.2f, %.2f)之间的积分值为：", a, b);
integral(a, b, f3, n);
} eg10.24有若干个学生的成绩(每个学生有4门课程)，要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现(返回指针值的函数)
//eg10.24有若干个学生的成绩(每个学生有4门课程)，要求在用户输入
//学生序号以后，能输出该学生的全部成绩。用指针函数来实现
#include<stdio.h>
float *search(float (*p)[4], int n);
void show(float (*p)[4], int n);
void show(float (*p)[4], int n){
int i;
for(i = 0; i < 4; i++){
printf("%.2f ", *(*(p+n)+i));
}
printf("\n");
}
float *search(float (*p)[4], int n){
return *(p+n);
}
void main(void){
float score[][4] = {{60, 70 , 80, 90}, {56, 89, 67, 88}, {34, 78, 90, 66}};
int num;
float *p;
printf("请输入序号(不大于3)：");
scanf("%d", &num);
p = search(score, num-1);
printf("该学生的各科成绩为：");
show(score, num-1);
}eg10.25对上例中的学生，找出其中不及格课程的学生及其学生号
//思考；返回的指针只能返回一个不及格的学生，万一有多个学生该怎么办？
//课本：在主函数中对各个学生进行循环，分别判断其是否及格
#include<stdio.h>
typedef unsigned char boolean;
#define TRUE 1
#define FALSE 0
boolean search(float (*p)[4], int n);
void show(float (*p)[4], int n);
void show(float (*p)[4], int n){
int i;
for(i = 0; i < 4; i++){
printf("%.2f ", *(*(p+n)+i));
}
printf("\n");
}
//思考；返回的指针只能返回一个不及格的学生，万一有多个学生该怎么办？
//课本：在主函数中对各个学生进行循环，分别判断其是否及格
boolean search(float (*p)[4], int n){
int i;
for(i = 0; i < 4; i++){
if(*(*(p+n)+i) < 60){
return TRUE;
}
}
return FALSE;
}
void main(void){
float score[][4] = {{60, 70 , 80, 90}, {56, 89, 67, 88}, {34, 78, 90, 66}};
float (*p)[4] = score;
int i;
boolean m;
for(i = 0; i < 3; i++){
m = search(score, i);
if(m == 1){ //不及格
printf("%d号学生不及格！成绩为：", i+1);
show(p, i);
}
}
}10.14将n个数按输入时的逆序排列，用函数实现
和之前的做法差不多，唯一的区别就是这个用指针定位到要交换的两个元素，然后利用指针进行交换
10.15(100)一个班的4个学生，5门课，进行以下操作
/*
10.15一个班的4个学生，5门课，进行以下操作:
(1)求第一门课的平均分
(2)找出两门以上课程不及格的学生，输出他们的学号和全部课程成绩及平均成绩
(3)找出平均成绩在90分以上或全部课程成绩在85分以上的学生
7:50 - 8:40 输入数据
12:20 - 12:30 (1)
12:30 - 13:00 (2)
13:00 - 13:10 (3)
*/
/*
English
Computer Science
Math
Physics
Chemistry
英语
计算机
数学
物理
化学
英语 计算机 数学 物理 化学
English
Computer
Math
Physics
Chemistry
34 56 88 99 89
77 88 99 67 78
99 90 87 86 89
78 89 99 56 77
*/
#include<stdio.h>
typedef unsigned char boolean;
#define TRUE 1
#define FALSE 0
void inputCourse(char (*p)[20], int row); //row表示有几门课程
void outputCourse(char (*p)[20], int row);
void inputScore(float (*p)[5], int row); //row表示有几个学生
void outputScore(float (*pS)[5], int rowS, char (*pC)[20], int rowC);
float averageScoreOfTheFirstCourse(float (*p)[5], int row);
float averageScoreOfEachStudent(float (*p)[5], int n);
void notUpToStandardOfTwoCourses(float (*pS)[5], int rowS, char (*pC)[20], int rowC);
void outputScoreOfOneStudent(float (*pS)[5], int n, char (*pC)[20], int rowC);
boolean allScoresAreUpTo85(float (*pS)[5], int n);
void goodStudent(float (*pS)[5], int rowS, char (*pC)[20], int rowC);
void goodStudent(float (*pS)[5], int rowS, char (*pC)[20], int rowC){
int i;
for(i = 0; i < rowS; i++){
if(averageScoreOfEachStudent(pS, i) >= 90 || allScoresAreUpTo85(pS, i) == 1){
outputScoreOfOneStudent(pS, i, pC, rowC);
printf("平均成绩为：%.2f\n", averageScoreOfEachStudent(pS, i));
}
}
}
boolean allScoresAreUpTo85(float (*p)[5], int n){
int i;
for(i = 0; i < 5; i++){
if(*(*(p+n)+i) < 85){
return FALSE;
}
}
return TRUE;
}
void outputScoreOfOneStudent(float (*pS)[5], int n, char (*pC)[20], int rowC){
int i;
int j;
printf(" ");
outputCourse(pC, rowC);
printf("No.%d： ", n+1);
for(j = 0; j < 5; j++){
printf("%-9.2f", *(*(pS+n)+j));
}
printf("\n");
}
void notUpToStandardOfTwoCourses(float (*pS)[5], int rowS, char (*pC)[20], int rowC){
int i;
int j;
int count = 0;
for(i = 0; i < rowS; i++){
for(j = 0; j < 5; j++){
if(*(*(pS+i)+j) < 60){
count++;
}
}
if(count >= 2){
outputScoreOfOneStudent(pS, i, pC, rowC);
printf("平均成绩为：%.2f\n", averageScoreOfEachStudent(pS, i));
}
count = 0;
}
}
float averageScoreOfEachStudent(float (*p)[5], int n){
int i;
float sum = 0;
for(i = 0; i < 5; i++){
sum+=*(*(p+n)+i);
}
return sum/5;
}
float averageScoreOfTheFirstCourse(float (*p)[5], int row){
int i;
float sum = 0;
for(i = 0; i < row; i++){
sum+=*(*(p+i));
}
return sum/row;
}
void outputScore(float (*pS)[5], int rowS, char (*pC)[20], int rowC){
int i;
int j;
printf(" ");
outputCourse(pC, rowC);
for(i = 0; i < rowS; i++){
printf("No.%d： ", i+1);
for(j = 0; j < 5; j++){
printf("%-9.2f", *(*(pS+i)+j));
}
printf("\n");
}
}
void inputScore(float (*p)[5], int row){
int i;
int j;
for(i = 0; i < row; i++){
printf("No.%d：", i+1);
for(j = 0; j < 5; j++){
scanf("%f", *(p+i)+j);
}
}
}
void outputCourse(char (*p)[20], int row){
int i;
for(i = 0; i < row; i++){
printf("%-8s ", p+i);
}
printf("\n");
}
void inputCourse(char (*p)[20], int row){
int i;
for(i = 0; i < row; i++){
//scanf("%s", p+i);
//本来想的说用scanf，这样输入时可以在一行输入，但是如果课程名称有两个单词就坏了
//如果课程名称用中文输入就不会出现这个问题了
//为了通用还是用英文吧
gets(*(p+i));
}
}
void main(void){
char course[5][20];
char (*pcourse)[20];
float score[4][5];
float (*pscore)[5];
pcourse = course;
pscore = score;
printf("请输入课程名称：\n");
inputCourse(pcourse, 5);
//printf("输入的课程名称为：");
//outputCourse(pcourse, 5);
printf("\n请输入各个学生的成绩(按照之前输入的顺序输入)：\n\t");
outputCourse(pcourse, 5);
inputScore(pscore, 4);
printf("\n各个学生的成绩为：\n");
outputScore(pscore, 4, pcourse, 5);
printf("\n第一门课程 %s的平均成绩为：%.2f\n", *pcourse, averageScoreOfTheFirstCourse(pscore, 4));
printf("\n\n*******有两门以上课程不及格的同学*******\n");
notUpToStandardOfTwoCourses(pscore, 4, pcourse, 5);
printf("\n\n*******成绩优良者*******\n");
goodStudent(pscore, 4, pcourse, 5);
}
10.16(60)输入一个字符串，内有数字和非数字字符，将其中连续的数字作为一个整数，依次存放到数组a中
//16:45 - 17:45
//a123x456 7689+89=321/ab23
//a123x4 7689+89=321/ab23
#include<stdio.h>
#include<string.h>
void fun(char *str);
void show(int a[], int n);
void show(int a[], int n){
int i;
for(i = 0; i < n; i++){
printf("%d ", a[i]);;
}
}
void fun(char *str){
int i;
char tmp[80];
//int count = 0;
int pre = 0;
int n = 0;
int a[50] = {0};
printf("连续的数字字符有：\n");
for(i = 0; i < strlen(str); i++){ //遍历字符串
if(str[i] >= '0' && str[i] <= '9'){ //说明当前字符是数字字符
if(pre == 1){ //说明前一个是数字字符
//count++;
a[n] = 10*a[n]+str[i]-'0';
//printf("%c\n", str[i-1]);
}else{ //说明前一个不是数字字符
//count = 1;
a[n] = str[i]-'0';
}
pre = 1; //为下一次做准备
}else{ //说明当前字符不是数字字符
if(pre == 1){ //说明前一个字符是数字字符
//printf("%c\n", str[i-1]);
//count = 0;
if(a[n] < 10){
a[n] = 0;
}else{
n++;
}
}
pre = 0;
}
//printf("pre=%d\n\n", pre);
//printf("count=%d\n", count);
//printf("n=%d\n", n);
//printf("a[%d]=%d\n", n, a[n]);
}
printf("这些数为：");
show(a, n+1);
}
void main(void){
char str[80];
printf("请输入一串字符：");
gets(str); //scanf("%s", str);
printf("这串字符为：%s\n", str);
fun(str);
}
10.17自己写一个函数，实现两个字符串的比较
/*
10.17自己写一个函数，实现两个字符串的比较
设p1指向字符串s1，p2指向字符串s2.
要求当s1=s2时，返回值为0；
若s1不等于s2，返回它们二者第一个不同字符的ASCII码值
如果s1>s2，则输出正值，反之，输出负值
*/
#include<stdio.h>
#include<string.h>
int stringCmp(char *p1, char *p2);
int stringCmp(char *p1, char *p2){
int i;
int length;
length = strlen(p1) > strlen(p2) ? strlen(p2) : strlen(p1);
for(i = 0; i < length; i++){
if(*(p1+i) != *(p2+i)){
return (*(p1+i) - *(p2+i));
}else{
continue;
}
}
return 0;
}
void main(void){
char s1[80];
char s2[80];
char *p1 = s1;
char *p2 = s2;
printf("请输入两个字符串：\n");
gets(p1);
gets(p2);
printf("两个字符串的差值为：%d\n", stringCmp(p1, p2));
} 10.18编一程序，输入月份号，输出该月的英文月名(要求用指针数组处理)
//要求用指针数组处理
#include<stdio.h>
void main(void){
char *a[12] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
char **p = a;
int month;
printf("请输入月份号：");
scanf("%d", &month);
printf("%d月对应的英文名为：%s\n", month, *(p+month-1));
}
10.20用指向指针的指针的方法对5个字符串排序并输出
| 指针数组的元素指向字符串 （1） char *a[12] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; （2） char *a[ ] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; （3）用户输入字符串 char str[5][20]; |
/*
China
America
India
Philippines
Canada
*/
/*
//自己：自己傻啦吧唧的，没有给字符串开辟空，怪不得输不进去
//课本：先给字符串开辟空间，输入字符串。然后用指针数组指向字符串。再用指针指向指针数组
#include<stdio.h>
void inputString(char **p, int n);
void outputString(char **p, int n);
void outputString(char **p, int n){
int i;
for(i = 0; i < n; i++){
printf("%s\n", (*(p+i)));
}
}
void inputString(char **p, int n){
int i;
for(i = 0; i < n; i++){
gets(*(p+i));
}
}
void main(void){
char *a[5];
char **p;
int i;
printf("请输入5个字符串：\n");
//inputString(p,5);
for(i = 0; i < 5; i++){
gets(*(a+i));
}
printf("这5个字符串为：\n");
outputString(p,5);
}
*/
/*
//这种方法也可以实现，只是这个没有涉及到指向指针的指针
#include<stdio.h>
#include<string.h>
void inputString(char *p[], int n);
void outputString(char *p[], int n);
void sort(char *p[], int n);
void swapString(char *p1, char *p2);
void swapString(char *p1, char *p2){
char tmp[20];
strcpy(tmp, p1);
strcpy(p1, p2);
strcpy(p2, tmp);
}
void sort(char *p[], int n){
int i;
int j;
char min[20];
int m;
for(i = 0; i < n-1; i++){
strcpy(min,p[i]);
m = i;
for(j = i+1; j < n; j++){
if(strcmp(p[j], min) < 0){
strcpy(min, p[j]);
m = j;
//printf("m=%d\n", m);
}
}
swapString(p[i], p[m]);//swapString(p[i], min); //strcpy(p[i], min);
// outputString(p ,n);
// printf("\n");
}
}
void outputString(char *p[], int n){
int i;
for(i = 0; i < n; i++){
printf("%s\n", p[i]);
}
}
void inputString(char *p[], int n){
int i;
for(i = 0; i < n; i++){
gets(p[i]);
}
}
void main(void){
char str[5][20];
char *pstr[5];
char **p;
int i;
// pstr = str; 这样不对
for(i = 0; i < 5; i++){
pstr[i] = str[i];
}
p = pstr;
printf("请输入5个字符串：\n");
inputString(pstr,5);
printf("这5个字符串为：\n");
outputString(pstr,5);
printf("\n排序后的字符串为：\n");
sort(pstr, 5);
outputString(pstr,5);
}
*/
#include<stdio.h>
#include<string.h>
void inputString(char **p, int n);
void outputString(char **p, int n);
void sort(char **p, int n);
void swapString(char *p1, char *p2);
void swapString(char *p1, char *p2){
char tmp[20];
strcpy(tmp, p1);
strcpy(p1, p2);
strcpy(p2, tmp);
}
void sort(char **p, int n){
int i;
int j;
char min[20];
int m;
for(i = 0; i < n-1; i++){
strcpy(min,p[i]);
m = i;
for(j = i+1; j < n; j++){
if(strcmp(p[j], min) < 0){
strcpy(min, p[j]);
m = j;
//printf("m=%d\n", m);
}
}
swapString(p[i], p[m]);//swapString(p[i], min); //strcpy(p[i], min);
// outputString(p ,n);
// printf("\n");
}
}
void outputString(char **p, int n){
int i;
for(i = 0; i < n; i++){
printf("%s\n", p[i]);
}
}
void inputString(char **p, int n){
int i;
for(i = 0; i < n; i++){
gets(p[i]);
}
}
void main(void){
char str[5][20];
char *pstr[5];
char **p;
int i;
// pstr = str; 这样不对
for(i = 0; i < 5; i++){
pstr[i] = str[i];
}
p = pstr;
printf("请输入5个字符串：\n");
inputString(p,5);
printf("这5个字符串为：\n");
outputString(p,5);
printf("\n排序后的字符串为：\n");
sort(p, 5);
outputString(p,5);
}10.21用指向指针的指针的方法对n个整数排序并输出
| 指针数组的元素指向整型数组 （1） int a[5] = {1, 3, 5, 7, 9}; int a[10]; |
/*
10.21用指向指针的指针的方法对n个整数排序并输出
要求将排序单独写成一个函数
n个整数在主函数中输入，最后在主函数中输出
*/
//9 4 2 6 1 5 3 0 8 7
#include<stdio.h>
void sort(int **p, int n);
void swap(int *a, int *b);
void swap(int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void sort(int **p, int n){
int i;
int j;
int min; //找最小值
int m; //最小值的下标
for(i = 0; i < n-1; i++){
min = *p[i];
m = i;
for(j = i+1; j < n; j++){
if(*p[j] < min){
min = *p[j];
m = j;
//printf("m=%d\n", m);
}
}
swap(p[i], p[m]);
}
}
void main(void){
int a[10];
int *pa[10] = {&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9]};
int **p = pa;
int i;
printf("请输入10个整数：");
for(i = 0; i < 10; i++){
scanf("%d", &a[i]);
}
sort(p, 10);
printf("排序后的10个数字为：");
for(i = 0; i < 10; i++){
printf("%d,", *(p[i]));
}
printf("\n");
}
扫一扫
3381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
