目录
3.[Error] expected primary-expression before ']' token
4.[Error] expected primary-expression before ']' token
5.[Error] 'str3' does not name a type
6.字符串的输入用了scanf不知道怎么输入，结果是用gets函数。发现了自己再字符串有关函数的不熟悉。需要立马学习：
7.我以为不能用字符串比较函数，得自己写，结果写错了。 哈哈哈。真是啥也不会的计算机学灰。
例题
第一类 通过指针变量访问整型（简单的说就是通过地址找变量）
【例8.1】
通过指针变量访问整型变量。
我的解法：
我的解题思路：先定义一个整型变量，然后在定义一个指针变量，然后给整型变量赋初值，随后取其地址赋值给指针变量，最后再通过printf函数引用。
源代码：
#include<stdio.h>
int main()
{
int *p;
int n;
p=&n;
n=7;
printf("%d",*p);
return 0;
}运行结果：
反思：
1.学到了什么？
知识：我本人初步了解了指针有什么用了。但是仍不知道为什么要有指针，本来变量还有数组就可以为什么还要引入指针，还是说指针地址本来就先于前者存在了？
书写格式：标准答案用的是pointer_1； 疑问为什么有_
int *pointer_1和引用时pointer_1的不同之处：前者是指定义指针变量pointer_1
思维：
方法：如何通过指针即地址来访问整型变量
2.犯了什么错？
3.推广？
通过指针即地址访问各个类型变量：改变类型名
4.疑问？
为什么同样一个*pointer_1却有两种不同意义
第二类 运用指针交换最大最小值问题
【例8.20】
输入a和b两个整数，按先大后小的顺序输出a和b。
我的解法：
我的解题思路：设置两个整型变量，然后设置两个指针变量，输入两个值把它们分别放在两个整型变量中，然后比较二者，然后交换两指针的值。
源代码：
#include<stdio.h>
int main()
{
int a,b,*pointer_1,*pointer_2,*p;
scanf("%d %d",&a,&b);
pointer_1=&a;
pointer_2=&b;
if(a<b)
{
p=pointer_1;
pointer_1=pointer_2;
pointer_2=p;
}
printf("%d %d",a,b);
return 0;
}运行结果：
看到这个结果我笑死了。
正确解法：
反思：
1.学到了什么？
方法：间接交换数值法——指针法
思维：
2.犯了什么错？
1.函数参数的错误设置
3.推广？
4.疑问？
改进：
源代码：
#include<stdio.h>
int main()
{
int a,b,*pointer_1,*pointer_2,*p;
scanf("%d %d",&a,&b);
pointer_1=&a;
pointer_2=&b;
if(a<b)
{
p=pointer_1;
pointer_1=pointer_2;
pointer_2=p;
}
printf("%d %d\n",a,b);
printf("%d %d",*pointer_1,*pointer_2);
return 0;
}
运行结果：
第四类 运用指针交换最大最小值问题改进之函数实现
【例8.3】
题目要求同例8.2，现用函数处理，并且用指针作为函数参数。
我的解法：
我的解题思路：
首先先定义两个整型变量a,b，然后分别输入a，b的值，然后分别传输二者地址入指针变量，然后再用指针变量传给函数；
源代码：
#include<stdio.h>
int main()
{
int a,b,*pointer_1,*pointer_2;
scanf("%d %d",&a,&b);
pointer_1=&a;
pointer_2=&b;
if(a<b)
{
Exchange(*pointer_1,*pointer_2);
}
printf("%d %d",*pointer_1,*pointer_2);
return 0;
}
Exchange(int *p,int *q)
{
int r;
r=p;
p=q;
q=r;
}程序运行结果：
为什么会出现这种情况呢我们看看标准答案
正确解法：
反思：
1.学到了什么？
方法：函数直接数值交换法
思维：
2.犯了什么错？
1.错误的认为穿指针就是直接传*pointer_1,实则要传的是pointer_1,二者并不一样，前者是指针变量所指向的内容，而后者是指针即地址。
2.函数内部时候值交换的时候错误的认为穿的是指针即地址，实则是直接通过已知的指针直接改内存里的内容。
3.推广？
4.疑问？
第五类 错误的 运用指针交换最大最小值问题改进之函数实现
问题就出在红色区域：
第六类 三个整数排序问题
【例8.5】
输入三个整数a,b,c,要求从大到小的顺序将它们输出。
我的解法：
我的解题思路：
首先新定义个变量c和指针变量，然后判断当a<b并且a<c并且b<c,
源代码：
#include<stdio.h>
int main()
{
int a,b,c,*pointer_1,*pointer_2,*pointer_3;
int Exchange(int *p,int *q,int *r);
scanf("%d %d %d",&a,&b,&c);
pointer_1=&a;
pointer_2=&b;
pointer_3=&c;
if(a<b&&a<c&&b<c)//if语句怎么判断问题
{
Exchange(pointer_1,pointer_2,pointer_3);//
}
printf("%d %d %d",*pointer_1,*pointer_2,*pointer_3);
return 0;
}
int Exchange(int *p,int *q,int *r)
{
int s;
s=*p;
*p=*r;
*r=*p;
}正确解法：
反思：
1.学到了什么？
方法：（1）三个参数交换位置（2）函数的嵌套可以重复使用之前使用过的函数
思维：
思想：一物重用的思想。优点：在很多时候解决问题我们用先前就解决问题
2.犯了什么错？
1.没有任何思路。
2.主要问题是对判断语句放在函数内还是函数外的问题，还有怎么判断的问题。
3.推广？
4.疑问？
第七类 通过指针引用数组
【例8.7】
有一个整型数组a,有十个元素，要求输出数组中全部元素。
解题思路：
我的思路首先
我的源代码：
#include<stdio.h>
int main()
{
int a[10];
printf("请输入10个数字\n");
for(int i=0;i<9;i++)
{
scanf("%d",a[i]);
}
for(int i=0;i<9;i++)
{
printf("%d\n",a[i]);
}
return 0;
}运行结果：
什么都没有
正确解法：
1.下标法
2.通过数组元素计算
3.通过指针变量指向数组元素 
反思：
1.学到了什么？
方法：1.第三种方法用指针变量直接指向元素，不必每次重新计算地址
思维：
思想：
知识：
2.犯了什么错？
1.没有任何思路。
2.主要问题是对判断语句放在函数内还是函数外的问题，还有怎么判断的问题。
3.推广？
4.疑问？
第八类 指针易错的地方
这段程序有问题吗？
#include<stdio.h>
int main()
{
int a[10],*p;
p=a;
printf("请输入10个数字\n");
for(int i=0;i<=9;i++)
{
scanf("%d",p++);
}
for(int i=0;i<=9;i++,p++)
{
printf("%d\n",*p);
}
return 0;
}运行结果：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
第八类 逆序输出数组
我的解题思路：
首先先按顺序初始化，输出结果，然后在逆序输入另一个数组，在输出这个数组的结果。
我的源代码：
#include<stdio.h>
int main()
{
int a[10],b[10],*p,i=0;
p=
for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
for(p=a;i<(a+10);p++)
{
printf("%d\n",*p);
}
for(p=a+9;i>=a;p--)
{
b[i]
}
return 0;
}卡住了
正确的解题思路：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
第九类 运用指针改进8.8
我的解题思路：
首先定义个指针变量存取数组首地址，然后读这个指针变量，其他几乎一样。
我的源代码：
第十类 运用指针给整数排序
我的解题思路：
首先定义一个数组，然后指针获取该地址，然后经过冒泡排序比较，输出到另一个数组。
源代码：
#include<stdio.h>
int main()
{
int a[10],*p,i=0,j=0;
*p=a[0];
a[10]={2001,07,24,2004,03,25,1314,520,1049,4005};
for(j=1;j<10;j++)
{
for(i=p;i<p+10;p++)//某个一个元素其中一趟
{
if(*p>*(p+1))
{
int temp=0;
temp=*p;
*p=*(p+1);
*(p+1)=temp;
}
}
}//这就涉及到排序选择的问题 第二个问题
return 0;
} 正确答案：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
第十一类 运用指针输出二维数组探索存储规律
我的解题思路：
二维指针：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十二类 指向多维数组的指针变量
我的解法：
#include<stdio.h>
int main()
{
int a[3][4]={1,3,5,7,9,11,13,15,17,19,23};
int *p;
for(p=a[0];p<a[0]+12;p++)
{
if((p-a[0])%4==0)//控制行数
{
printf("\n");
}
printf("%4d",*p);
}
printf("\n");
return 0;
} 正确解法：
第十三类 输出二维数组任意一行任一一列
标准答案：
第十三类 用指向数组的指针作函数参数
正确答案：
程序分析：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十四类 查找一门可不及格的学生
我的解法：
正确解法：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十五类 通过指针指向字符串
正确解法：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十六类 节约空间的指针复制法
正确的解题思路：
程序：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十七类 用函数调用实现字符串的复制
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十八类 如何改变指针变量的值
正确答案：
源代码：
#include<stdio.h>
int main()
{
char *a="I love China!";
a=a+7;
printf("%s",a);
return 0;
}程序分析： 
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第十九类 用函数指针变量调用函数
正确解法：
法一：函数名调用函数
2.指针调用
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第二十类 指向函数的指针变量的实例
我的解题思路：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第二十一类 用指向函数的指针指向参数
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第二十二类 用指针函数输出学生成绩
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第二十三类 指针数组的运用——字符串排序
我的思路：
通过两个for循环遍历一遍两个字符串然后判断是否交换位置，整体用冒泡排序法，
源代码：
正确思路：
1.学到了什么？
方法：（1）通过指针数组指向一堆字符串（2）字符串比较函数（3）两种实现输出的方法（下标法，指针法）（4）*(name+i++)法表示可以省略在while函数中的p++
思维：指针的思维——直接调取空间；
思想：（1）函数的思想——原来输出也能写成函数
知识：（1）字符串特性：字符串不能直接比较。
思路：
首先我写这个程序时其实第一个问题是因为函数参数不知道如何设立问题，我认为既然字符串是数组，我就把它们都写进四个字符数组里面，但是问题紧接就来了我不知道怎么接收它们近函数里面。
思维导图：
2.犯了什么错？
（1）我在if比较结构中我就是他写的错误示范，这直接显示了我对字符串的特性还没有充分了解，字符串不能直接比较，这样只能比较第一个字符的大小。
3.推广？
4.疑问？
（1）为什么要用指针数组？
（2）
（3）
5.疑问的解答
（1）因为如果你不用指针数组那么就得用二维数组存放这些数据，而二维数组的使用就避免不了列数要提前定义，又由于二维数组每行列数相等，我们为保证每一行的信息都充分录入存储空间我们都会取最长的字符串作为空间列数的长度，可是不是所有字符串都有这么长，所以肯定会残留无用的空间，最终导致空间的大量浪费，采用指针数组就可以不定义他的内存容量，让系统自动分配。
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.下标法和指针法比较：下标法（数组法）实现输出直观，这个指针法实现效率高；
第二十四类 指向指针的指针应用——输出字符串
正确思路：
运行结果：
程序分析：
反思：
1.学到了什么？
方法：（1）通过指针的指针来输出
思维：酒店房间门钥匙的钥匙思维
思想：
知识：
指针的指针
2.犯了什么错？
没犯错因为这里直接看答案【g】
3.推广？
4.疑问？
（1）为什么输出时不直接用**p
（2）
5.反映了什么？
（1）
（2）
6.结论：
第二十五类 指向指针的指针——输出整型数组
一、信息
二、分析
首
我的思路：
首先要定义个整型数组然后赋好值，然后定义个指针数组，然后定义个指针的指针然后将整型数组的地址赋给指针数组，然后再通过指针的指针输出。
我的解法：
我的源代码：
#include<stdio.h>
int main()
{
int a1[10]={0,1,2,3,4,5,6,7,8,9};
int *p1[10],**p2;
*p1[0]=&a1[0];
*p2=p1[0];
for(int i=0;i<10;i++)
{
printf("%d",*p2);
*p2++;
}
return 0;
}运行结果：
正确解法：
程序分析：
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第二十六类 动态数组的实现和应用
【例8.30】
建立个动态数组，输入五个学生的成绩，另外用一个函数检查其中有无低于60分的，输出不合格的成绩。
我的解法：
一、信息
(1)建立动态数组
(2)输入五个学生的成绩
(3)还要有一个函数来检查分数60分
(4)输出不合格的成绩
二、分析
1.解决第一个问题
在动态分配有关的函数中只有calloc可以分配数组
用calloc 首先要知道怎么写
void *calloc(unsigned n,unsigned size);
1.2从上面引出的问题
改用什么类型呢？int型？但是分数有时候有小数因此用double型
n直接输入就可以了
size怎么办呢？会自动变为
2.
正确解法：
源代码：
#include<stdio.h>//标志函数库
#include<stdlib.h>//这个函数库里包含了动态内存分配所需的malloc函数pl
int main()
{
void check(int *);//检查有无低于60分的函数声名
int *pl,i；//pl是int型指针
pl=(int *)malloc(5*sizeof(int));//开辟动态内存区，将地址转换为int *型，然后放在pl中
for(i=0;i<5;i++)
{
scanf("%d",pl+i);//教会我如何输，在头地址输入
}
check(pl);
return 0;
}
void check(int *p)
{
int i;
printf("They are fail:");
for(i=0;i<5;i++)
{
if(p[i]<60)
{
printf("%d",p[i]);
printf("\n");
}
}
反思：
1.学到了什么？
方法：动态内存分配
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
8.9 有关指针的小结
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）选择排序部分看不懂
（2）函数掌握不成熟
5.反映了什么？
（1）说明了选择排序部分有漏洞
（2）函数部分有问题，前面的章节有问题
6.结论：
第八章习题
1.输出三个整数由从小到大输出。
我的解题思路：
首先分两种情况第一种统一写在一个主函数中，第二种写多一个副函数；
先说第一种先定义整型三个变量还有整型三个指针然后赋值用选择结构if来比较
第二种就是先定义个函数然后主函数声明并应用，副函数部分和上面一致；
我的源代码：
#include<stdio.h>
int main()
{
int a,b,c,temp=0;//三个数
int *p,*q,*r;
p=&a,q=&b,r=&c;//给指针赋初值
printf("请输入三个数:");
scanf("%d %d %d",*p,*q,*r);
if(*p>*q)
{
temp=*p;
*p=*q;
*q=temp;
if(*q>*r)
{
temp=*q;
*q=*r;
*r=q;
}
}
if(*p>*r)
{
if()
}
return 0;
}遇到了问题：
如何通过选择结构来排序，这暴露了我排序问题的不足，是用选择排序还是冒泡排序呢？冒泡排序我也不会。if语句我面对的最大问题就是情况列举不完整，比如if语句要想包括所以情况就得多写很多步骤，而且平常人的思维都是先全部比较完再交换但是这个不同。此外if函数嵌套究竟有什么用也不清楚。
正确答案：
解题思路：
采取副函数，冒泡排序方法，通过三个if语句来判断；
源代码：
#include<stdio.h>
int main()
{
void swap(int *p1,int *p2);
int n1,n2,n3;
int *p1,*p2,*p3;
printf("input three integer n1,n2,n3:");
scanf("%d %d %d",&n1,&n2,&n3);
p1=&n1;
p2=&n2;
p3=&n3;
if(n1>n2)
{
swap(p1,p2);
}
if(n1>n3)
{
swap(p1,p3);
}
if(n2>n3)
{
swap(p2,p3);
}
printf("Now,the order is:%d %d %d\n",n1,n2,n3);
return 0;
}
void swap(int *p1,int *p2)
{
int p;
p=*p1;
*p1=*p2;
*p2=p;
}运行结果：
反思：
1.学到了什么？
方法：冒泡排序法，通过if语句或者选择结构一一比较
思维：三个数大小比较思维
思想：函数的思想
知识：指针排序方法
2.犯了什么错？
（1）错误的认为先比较后排序和一边比较一边排序结果不同；为什么是相同的呢？
3.推广？
多种排序方法：
4.疑问？
（1）“错误的认为先比较后排序和一边比较一边排序结果不同；”为什么会有这种情况发生呢？
（2）为什么是相同的呢？我还没想到满意的答案，不过我认为只要比较过程中每个元素都两两比较了就能排序和比较的顺序无关而且也不会重复。百度也找不到答案。
（3）是否还有其他排序方法？
6.结论：
6 冒泡排序（BubbleSort）
冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。它是O(n^2)的算法。
2.输入三个字符串由小到大顺序输出
我的解题思路：
首先定义三个字符串和三个指针，然后定义两个函数分别用来比较和排序。最后得到答案
源代码：
#include<stdio.h>
int main()
{
int strcmp(*p1,*p2);
void swap(int *p1,int *p2);
int char str1[],str2[],str3[];
int *p1,*p2,*p3;
str1[]={'I'' ''am'};
str2[]={'F''U''C''K'' ''Y''O''U''!'};
str3[]={'g''i''r''l'};
*p1=str1;
*p2=str2;
*p3=str3;
if(strcmp(str1,str2)>0)
{
swap(str1,str2); //怎么交换位置呢？
}
if(strcmp(str1,str3)>0)
{
swap(str1,str3);
}
if(strcmp(str2,str3)>0)
{
swap(str2,str3);
}
printf("%s %s %s",str1,str2,str3);//从哪获取数据呢？ 疑问二数组能直接读吗？
return 0;
}
int strcmp(*p1,*p2)
{
int i,j,dif=0,sum=0;
while(*p1!='\0'||*p2!='\0')
{
dif=*p1-*p2;
sum=sum+dif;
}
return sum;
}
int swap(*p1,*p2);
{
int temp;
temp=*p1;
*p1=*p2;
*p2=*p1;
}
运行结果：
为什么会这样呢？
发现参数类型有问题又改了一遍结果
源代码：
#include<stdio.h>
int main()
{
void swap(char *p1,char *p2);
int strcmp(char *p1,char *p2);
int char str1[],str2[],str3[];
int *p1,*p2,*p3;
str1[]={'I'' ''am'};
str2[]={'F''U''C''K'' ''Y''O''U''!'};
str3[]={'g''i''r''l'};
*p1=str1;
*p2=str2;
*p3=str3;
if(strcmp(str1,str2)>0)
{
swap(str1,str2); //怎么交换位置呢？
}
if(strcmp(str1,str3)>0)
{
swap(str1,str3);
}
if(strcmp(str2,str3)>0)
{
swap(str2,str3);
}
printf("%s %s %s",str1,str2,str3);//从哪获取数据呢？ 疑问二数组能直接读吗？
return 0;
}
int strcmp(char *p1,char *p2)
{
int i,j,dif=0,sum=0;
while(*p1!='\0'||*p2!='\0')
{
dif=*p1-*p2;
sum=sum+dif;
}
return sum;
}
int swap(*p1,*p2);
{
int temp;
temp=*p1;
*p1=*p2;
*p2=*p1;
}运行结果：
正确的答案：
解题思路：
首先自己写一个swap交换函数，参数是指针，定义三个字符串，通过gets输入字符串，然后用if选择结构比较然后冒泡排序，最后输出答案。
源代码：
#include<stdio.h>
#include<string.h>
int main()
{
void swap(char *,char *);
char str1[20],str2[31],str3[20];
printf("input three line\n");
gets(str1);
gets(str2);
gets(str3);
if(strcmp(str1,str2)>0)
{
swap(str1,str2);
}
if(strcmp(str1,str3)>0)
{
swap(str2,str3);
}
printf("Now the order is:\n");
printf("%s\n%s\n%s\n",str1,str2,str3);
return 0;
}
void swap(char *p1,char *p2)
{
char p[20];
strcpy(p,p1);
strcpy(p1,p2);
strcpy(p2,p);
}运行结果：
注意：输入的字符串不要超过数组长度。
反思：
1.学到了什么？
方法：冒泡排序法，通过if语句或者选择结构一一比较
思维：三个数大小比较思维
思想：函数的思想
知识：
1.新的错误类型：[Error] two or more data types in declaration of 'str1'
问题原因：函数参数中间少了逗号
2. [Error] 'str1' was not declared in this scope
“was not declared in this scope”是说你这里出现了一个错误信息，一般都是在编译的时候遇到的。就是说你写的标识符在它出现的地方是未被定义的。
一般可能有这些原因导致这种错误：
1，忘记定义。
写代码的时候疏忽，以至于一些变量直接使用但没有定义。只要对应定义相应的函数或变量就好了。
2，拼写错误。
写代码的时候打错了字符。看一下是不是哪个字母写错了，对应修改就行。
3，作用域不正确。
在超出变量和函数的作用域部分使用了该变量或函数。这时候得通过定义位置，要么增加声明的手段，加大变量的作用域使其包含引用位置。
2.犯了什么错？
3.[Error] expected primary-expression before ']' token
讲的是“结构体数组”的报错，访问，赋值等等。
原因：
在加了typedef的结构体中，数组stu[10]被当作别名。
解决办法：删除typedef。或使用下面详述的方法定义结构体数组。
4.[Error] expected primary-expression before ']' token
字面上的意思就是“ 】”前面缺少了一个“}”
5.[Error] 'str3' does not name a type
XXX应该是一种用户定义的数据类型，而由于没有声明或者拼写错误或者与关键词重名，导致编译有错，出现类型错误。
在一个源文件中，要声明或定义一个类的指针时，必须在使用前声明或定义该类，因此下面的代码会报错：class A{public: B *b;};class B{public: A *a;};int main(){ return 0;}12345678910111213141516
报错为“error: ‘B’ does not name a type”，就是因为在A类中使用B *b之前没有声明或定义B类，如果在第一行加上一句前置声明（forward declaration）“class B;”，就不会有这样的问题了。
而在头文件互相包含时，也会引发“error: ‘xxx’ does not name a type”，其报错原因和上面的代码是相同的，请看下面的代码：a.h：
#ifndef A_H_INCLUDED#define A_H_INCLUDED#include "b.h"class A{public: B *b;};#endif // A_H_INCLUDED123456789101112
b.h：#ifndef B_H_INCLUDED#define B_H_INCLUDED#include "a.h"class B{public: A *a;};#endif // B_H_INCLUDED123456789101112
main.cpp：#include "a.h"#include "b.h"int main(){ return 0;}1234567
编译就会报错：“error: ‘A’ does not name a type”。
预处理命令为“gcc -E -o a.i a.h”：
# 1 "a.h"# 1 "<built-in>"# 1 "<command-line>"# 1 "a.h"# 1 "b.h" 1# 1 "a.h" 1# 5，"b.h" 2class B{public： A *a;};
# 5 "a.h" 2class A{public： B *b;};1234567891011121314151617181920212223242526。
6.字符串的输入用了scanf不知道怎么输入，结果是用gets函数。发现了自己再字符串有关函数的不熟悉。需要立马学习：
解决情况我用脑图创立了和字符串有关的思维导图如下：
7.我以为不能用字符串比较函数，得自己写，结果写错了。 哈哈哈。真是啥也不会的计算机学灰。
4.疑问？
（1）首先字符串怎么比较？
（2）我以为不能用字符串比较函数。不过话说回来为什么会错呢？错在哪呢？
（3）为什么字符串输出时候不用puts函数，其次puts函数和printf函数有什么区别。
6.结论：
6 冒泡排序（BubbleSort）
冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。它是O(n^2)的算法。
7.疑问的解答
1.字符串比较方法：
（1）可以用字符串比较函数
说明：
（2）自己构造函数
3.puts函数和printf函数区别
本人比较懒，对此我特地在csdn上查找了有关资料滑稽。
发现它们两个函数有相同也有不同。
一.一致性
puts();可以顺序输出作为实参的字符串，并在结尾换行。当只需要输出一个字符串且换行时，puts(“字符串”)与printf（“字符串\n”）高度一致。如一下代码输出结果一样
puts("AB");
printf("AB\n");
puts("A"); //这里的A为字符串
printf（"A\n"）;
如果想用put输出单个字符，则用putchar('A') 注意：单引号
需要换行且不用进行格式转化输出时，建议使用puts()函数。
二.差异性
puts():仅有一个实参，函数只能输出字符串，不能输出值或执行格式转换
printf():书写格式为：
printf("<格式化字符串>", <参量表>);
格式化字符串包括两部分内容:
一部分是正常字符, 这些字符将按原样输出;
另一部分是格式化规定字符, 以"%"开始, 后跟一个或几个规定字符,用来确定输出内容格式。
可以有多个实参，可以输出多个变量，例子如下：
printf("a=%d", a);
————————————————
版权声明：本文为CSDN博主「CPRCPR01」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_40437351/article/details/127117840
特此感谢该csdn博主。已注明出处。
3.
我的解题思路：
先定义一个空间为10到的整型数组，写三个函数，处理函数就是比较大小得到max和min，这里我有几种思路，第一种就是对1-10个数比较大小，有两种方法第一种选择排序法，个人认为这是我已知最快的方法，第二种冒泡排序法两种思路。
我的源代码：
#include<stdio.h>
int main()
{
void swap(int *p1,int *p2);//交换函数
int input(int *a[10]);
int output(int *a,int *b);
int a[10],*p1;
p=a[0];
input(p);
output(p);
return 0;
}
void swap(int *p1,int *p2)
{
int temp;
temp=*p1;
*p1=*p2;
*p2=temp;
}
int input(int *a[10])
{
int i;
printf("please enter 10 number:");
for(i=0;i<10;i++)
{
scanf("%d",a[i]);//引用这里究竟该用指针还是其他的部分
}
}
int output(int *a,int *b)
{
int i;
for(i=0;i<10;i++)
{
printf("%4d",)
}
}遇到的问题：
1.函数参数选择问题
2.函数怎么实现操作
3.要写max和min函数吗？
4.如果要要函数的嵌套吗？
正确答案：
解题思路：
答案首先定义了三个函数，分别是输入函数、输出函数、处理函数minmax函数，首先定义了一个容量为10的数组和我的思路一致，但是它的交换函数和我不一样。
源代码：（抄错了狗头）
#include<stdio.h>
int main()
{
void input(int *);
void max_min_value(int *);
void output(int *);
int number[10];
input(number);//调用输入10个数的函数
max_min_value(number);//调用交换函数
output(number);//调用输出函数
return 0;
}
void input(int *number)//输入十个数的函数
{
int i;
printf("input 10 numbers:");
for(i=0;i<10;i++)
{
scanf("%d",&number[i]);
}
}
void max_min_value(int *number)//交换函数
{
int *max,*min,*p,temp;
max=min=number;//开始时使max和min都指向第一个数
for(p=number;p<number+10;p++)
{
if(*p>*max)
{
max=p;//若p指向的数大于max指向的数，就使max指向p指向的大数
}
else if(*p<*min)
{
min=p;//若p指向的数小于min指向的数，就使得min指向p指向的小数
}
}
temp=number[0];number[0]=*min;*min=temp;//将最小数和第一个数交换
if(max==number)
{
max=min;//如果max和number相等，表示第一个数是最大数，这使得max指向当前最大数
}
temp=number[9];number[9]=*min;*min=temp;//将最大数与最后一个数交换
}
void output(int *number)//输出函数
{
int *p;
printf("Now,they are: ");
for(p=number;p<number+10;p++)
{
printf("%d",*p);
}
printf("\n");
}运行结果：
结果发现抄错了，这是为什么吗？
我抄的时候首先循环初始值没加一，其次最重要的是黄色部分我写成了min
源代码：
#include<stdio.h>
int main()
{
void input(int *);
void max_min_value(int *);
void output(int *);
int number[10];
input(number);//调用输入10个数的函数
max_min_value(number);//调用交换函数
output(number);//调用输出函数
return 0;
}
void input(int *number)//输入十个数的函数
{
int i;
printf("input 10 numbers:");
for(i=0;i<10;i++)
{
scanf("%d",&number[i]);
}
}
void max_min_value(int *number)//交换函数
{
int *max,*min,*p,temp;
max=min=number;//开始时使max和min都指向第一个数
for(p=number+1;p<number+10;p++)
{
if(*p>*max)
{
max=p;//若p指向的数大于max指向的数，就使max指向p指向的大数
}
else if(*p<*min)
{
min=p;//若p指向的数小于min指向的数，就使得min指向p指向的小数
}
}
temp=number[0];number[0]=*min;*min=temp;//将最小数和第一个数交换
if(max==number)
{
max=min;//如果max和number相等，表示第一个数是最大数，这使得max指向当前最大数
}
temp=number[9];number[9]=*max;*max=temp;//将最大数与最后一个数交换
}
void output(int *number)//输出函数
{
int *p;
printf("Now,they are: ");
for(p=number;p<number+10;p++)
{
printf(" %d",*p);
}
printf("\n");
}运行结果：
程序分析：
注意：此处由第二种方法就是放弃同时找最大最小值，而是先找最小值后找最大值。
反思：
1.学到了什么？
方法：
思维：
思想：
知识：
2.犯了什么错？
3.推广？
4.疑问？
（1）
（2）
（3）
6.结论：
4.
我的思路：
首先子函数中设立个动态数组1，然后经过读取m生产空间大小为m的数组，最后把前面n-m个元素p++，然后再把数组赋值给前m个元素。
反思：
正确的解法：
解题思路：
采取递归调用模拟过程：
源代码：
#include<stdio.h>
int main()
{
void move(int [20],int,int);
int number[20],n,m,i;
printf("How many number?");
scanf("%d",&n);
printf("input %d numbers:\n",n);
for(i=0;i<n;i++)
{
scanf("%d",&number[i]);//输入n个数
}
printf("How many place you want move?");
scanf("%d",&m);
move(number,n,m);//调用move函数
printf("Now,they are:\n");
for(i=0;i<n;i++)
{
printf("%d ",number[i]);
}
printf("%d ",number[i]);
printf("\n");
return 0;
}
void move(int array[20],int n,int m)//循环后移一次函数
{
int *p,array_end;
array_end=*(array+n-1);
for(p=array+n-1;p>array;p--)
{
*p=*(p-1);
}
*array=array_end;
m--;
if(m>0)
{
move(array,n,m);//递归调用，当循环次数m减至
}
}运行结果：
1.学到了什么？
方法：递归调用
思维：
思想：
知识：
动态内存分配：
思维导图：
2.犯了什么错？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）为什么要用递归？
（3）
5.疑问的解答
6.结论：
7.感悟
首先这道题的答案给我很深的震撼，原来排序还能用递归调用，
5.海盗问题地翻版我称之为圆圈幸存问题
我的思路；
给n个人编号我个人觉得是数组，如果能被三整除那么把元素变为0，然后重新编号，等等怎么实现呢？好吧我现在毫无头绪【狗头】
正确地思路：
源代码：
#include<stdio.h>
int main()
{
int i,k,m,n,num[50],*p;
printf("\ninput number of person:n=");
scanf("%d",&n);
p=num;
for(i=0;i<n;i++)
{
*(p+i)=i+1;//以1至n为每个人排序
}
i=0;//i为每次循环时的计数变量
k=0;//k为按1，2，3报数时的计数变量
m=0;//m为退出人数
while(m<n-1)//当退出人数比n-1少时(未退出人数大于1时)执行循环条件
{
if(*(p+i)!=0)
{
k++;
}
if(k==3)//对退出的人的编号置为0
{
*(p+i)=0;
k=0;
m++;
}
i++;
if(i==n)
{
i=0;//报数到尾后，i恢复为0；
}
}
while(*p==0)
{
p++;
}
printf("The last one is NO.%d\n",*p);
return 0;
} 1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）switch函数不会更好吗
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
6.求字符串长度函数
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
7.任意起点复制字符串
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
8.统计字符个数
1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
9.矩阵的转置
1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
10.矩阵的数据操控和排序
我的解法：
我的思路：首先定义个二维数组，然后通过比较函数比较找出最大值，然后找倒数四个最小值，分别和原位置元素作交换
我的分析：
我的源代码：
#include<stdio.h>
int main()
{
int i,j,a1[5][5];//暴露了第一个问题二维数组如何初始化？
printf("Please enter the date:");
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
scanf("%d",a[i][j]);
}
}
sort(a[0][0]);//这里又暴露了函数参数的选取和数组如何传递给函数的问题，和指针弄混淆了
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
printf("%d\t",a[i][j]);
}
}
return 0;
}
void sort(*)//这个参数问题同样出现在
{
int max;
for(i=0;i<5;i++)//选择何种排序方法对于max可以用选择排序，但是倒数四个用什么排序呢？
{
for(j=0;j<5;j++)
{
if(max<a[i][j])
{
max=a[i][j];
}
}
}
} 正确的源代码：
#include<stdio.h>
int main()
{
void change(int *p);
int a[5][5],*p,i,j;
printf("input matrix:\n");//提示输入二维数组个元素
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
scanf("%d",&a[i][j]);
}
}
p=&a[0][0];//使p指向0行0列
change(p);
printf("Now matrix:\n");
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
printf("%d",a[i][j]);
}
printf("\n");
}
return 0;
}
void change(int *p)//交换函数
{
int i,j,temp;
int *pmax,*pmin;
pmax=p;
pmin=p;
for(i=0;i<5;i++)//找最大值和最小值的地址，并赋给pmax,pmin
{
for(j=i;j<5;j++)
{
if(*pmax<*(p+5*i+j))
{
pmax=p+5*i+j;
}
if(*pmin>*(p+5*i+j))
{
pmin=p+5*i+j;
}
}
}
temp=*(p+12);
*(p+12)=*pmax;
temp=*p;
*p=*pmin;
*pmin=temp;
pmin=p+1;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
if(((p+5*i+j)!=p)&&(*pmin>*(p+5*i+j)))
{
temp=*pmin;
}
}
}
temp=*pmin;
*pmin=*(p+4);
*(p+4)=temp;
pmin=p+1;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
if(((p+5*i+j)!=(p+4)&&((p+5*i+j)!=p)&&(*pmin>*(p+5*i+j))))
{
pmin=p+5*i+j;
}
}
}
temp=*pmin;
*pmin=*(p+20);
*(p+20)=temp;
pmin=p+1;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
if(((p+5*i+j!=p)&&((p+5*i+j!=(p+4)&&(*pmin>*(p+5*i+j))))))
{
pmin=p+5*i+j;
}
}
}
temp=*pmin;
*pmin=*(p+20);
*(p+20)=temp;
pmin=p+1;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
if(((p+5*i+j)!=p)&&((p+5*i+j)!=(p+4)&&((p+5*i+j)!=(p+20)))&&(*pmin>*(p+5*i+j)))
{
temp=*pmin;
}
}
}
*pmin=*(p+24);
*(p+24)=temp;
} 
1.学到了什么？
方法：
思维：
思想：
知识：双指针 取多个最小值
思路：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
11.字符串排序输出函数法
我的解法：
#include<stdio.h>
int main()
{
int i,j,k;
char str1[10][20],*p[10],swap(char *p);
printf("Please enter the str\n");
for(i=0;i<10;i++)
{
scanf("%d",&str1[i][20]);
}
for(k=0;k<10;k++)
{
p[k]=&str1[k][20];
}
swap(p[0]);
printf("The order is:")
for(j=0;j<10;j++)
{
printf("%s\t",str1[i][20]);
}
return 0;
}
char swap(char *p)
{
if()
}写代码遇到的问题：
(1)如何写交换函数呢，主要是选择冒泡排序还是其他排序？
(2)函数类型选哪个？
正确的做法：
法一 用字符二维数组
思路：
源代码：
#include<stdio.h>
#include<string.h>
int main()
{
void sort(char s[][6]);
int i;
char str[10][6];
printf("input 10 string:\n");
for(i=0;i<10;i++)
{
scanf("%s",str[i]);
}
sort(str);
printf("Now the sequence is:\n");
for(i=0;i<10;i++)
{
printf("%s\n",str[i]);
}
return 0;
}
void sort(char s[10][6])
{
int i,j;
char *p,temp[10];
p=temp;
for(i=0;i<9;i++)
{
for(j=0;j<9-i;j++)
{
if(strcmp(s[i],s[j+1])>0)
{
strcpy(p,s[j]);
strcpy(s[j],s[+j+1]);
strcpy(s[j+1],p);
}
}
}
}法二 用指向一维数组的指针作函数参数
#include<stdio.h>
#include<string.h>
int main()
{
void sort(char (*p)[6]);
int i;
char str[10][6];
char (*p)[6];
printf("input 10 string:\n");
for(i=0;i<10;i++)
{
printf("%s\n");
}
return 0;
}
void sort(char (*s)[6])
{
int i,j;
char temp[6],*t=temp;
for(i=0;i<9;i++)//双重循环
{
for(j=0;j<9-i;j++)
{
if(strcmp(s[i],s[j+1])>0)
{
strcpy(t,s[j]);
strcpy(s[j],s[+j+1]);
strcpy(s[j+1],t);
}
}
}
}1.学到了什么？
方法：
(1)双重循环冒泡排序法，如果只用选择语句要写45个if而这里通过一层循环和二层循环的关系入手，即随着循环次数增加二层循环减少
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
累加和的模拟：启发我二重循环可以用来模拟累加和
此外对冒泡排序法的多次比较得到的答案
12.
我的解法：
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
13.矩形法求积分
我的解法：
1.学到了什么？
方法：矩形法求积分
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
14.逆序排列
我的解法：
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
15.
正确做法：
1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
16统计字符串中的数字
正确的解法：
源代码：
1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
17.自己写一个字符串比较函数
正确的方法：
1.学到了什么？
方法：
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）这里的return返回怎么返回所有字符的呢？没有循环啊
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
18.指针数组的应用——字符串暑促
正确的解法：
1.学到了什么？
方法：(1)指针数组的使用
思维：通过数字和指针结合的输出能创建数字和字符串的联系
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）指针数组有什么用
（2）
（3）
5.疑问的解答
（1）指针数组有时可以避免使用二维数组来存储一堆字符串，方便，简言之就是适用于引用一堆字符串
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
19.独自编写new和free函数
我的解法：
我的思路：
正确的解法：
（1）New函数
源代码：
#include<stdio.h>
#define NEWSIZE 1000
char newbuf[NEWSIZE];//定义字符数组
char *newp=newbuf;//定义指针变量newp,指向可存储取的始端
char *new(int n)//定义开辟存储区的函数new，开辟存储区后返回指针
{
if(newp+n<=newbuf+NEWSIZE)
{
newp+=n;//newp指向存储区的末尾
return(newp-n);
}
else
return(NULL);//当存储区不分配时，返回一个空指针
} （2）Free函数
思路：
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
20.指针的指针输出字符串法
正确的解题思路：
源代码：
#include<stdio.h>
#include<string.h>
#define LINEMAX 20//定义字符串的最大长度
int main()
{
void sort(char **p);
int i;
char **p,*pstr[5],str[5][LINEMAX];
for(i=0;i<5;i++)
{
pstr[i]=str[i];//将第i个字符串的首地址赋予指针数组pstr的第i个元素
}
printf("input 5 string:\n");
for(i=0;i<5;i++)
{
scanf("%s",pstr[i]);
}
p=pstr;
sort(p);
printf("\nstring sorted:\n");
for(i=0;i<5;i++)
{
printf("%s\n",pstr[i]);
}
return 0;
}
void sort(char **p)
{
int i,j;
char *temp;
for(i=0;i<5;i++)
{
for(j=i+1;j<5;j++)
{
if(strcmp(*(p+i),*(p+j))>0)
{
temp=*(p+i);
*(p+i)=*(p+j);
*(p+j)=temp;
}
}
}
} 运行结果：
1.学到了什么？
方法：(1)重拾标志变量法（2）N-S图地流程怎么画重新复习了一遍（3）学到了如何用循环和指针编号
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
没有思路，说明了什么呢？
现在我还有什么不足呢？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
21.指针的指针之排序问题
正确的解题思路：
源代码：
#include<stdio.h>
int main()
{
void sort(int **p,int n);
int i,n,date[20],**p,*pstr[20];
printf("input n:\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
pstr[i]=&date[i];//将第i个整数的地址赋予指针数组pstr的第i个元素
}
printf("input %d integer number:",n);
for(i=0;i<n;i++)
{
scanf("%d",pstr[i]);
}
p=pstr;
sort(p,n);
printf("Now the sequence is:\n");
for(i=0;i<n;i++)
{
printf("%d ",*pstr[i]);
}
printf("\n");
return 0;
}
void sort(int **p,int n)
{
int i,j,*temp;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(**(p+i)>**(p+j))
{
temp=*(p+i);
*(p+i)=*(p+j);
*(p+j)=temp;
}
}
}
}运行结果：
程序分析：
1.学到了什么？
方法：（1）用指针的指针来给变量排序
思维：
思想：
知识：
思路：
动态内存分配：
思维导图：
2.犯了什么错？
3.推广？
4.疑问？
（1）可不可以用动态数组？
（2）为什么要用指针的指针有什么好处又有什么坏处？
（3）
5.疑问的解答
6.结论：
7.感悟
1.先说说学到了如何用循环和指针编号，我的想法是把for(i=0,p=num;i<n;i++,p++)*p=i+1;
但是他的代码使得for循环里面的变量趋于简洁。
2.其次我刚开始想用动态数组实现但是后来看答案发现其实一般数组也能实现
3.
806
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
