c语言学习重点笔记数组函数.doc

数组

-3-29 22：40
一维数组定义和一维数组引用
内存中一串持续存储单元（变量），叫数组。指针移动和比较只有在一串持续数组中才故意义。
当数组中每个变量只带一种下标时，为一维数组。
定义一种一维数组：
类型名 数组名【常量表达式】 如：int a[8];
阐明： ①定义一种一维整型名为a数组。
②方括号中规定此数组有8个元素，（a【0】-a【7】），不存在a【8】这个元素。
③a数组中每个元素均为整型，且每个元素只能存储整型。
④每个元素只有一种下标，且第一种元素下标总为0。
⑤c编译程序，为a数组开辟8个持续存储单元。
3）在定义数组语句中，可以有各种数组阐明符；它们用逗号隔开。
例：double a【22】，v【100】，u【5】，a，b，c； 注：双精度型 每个单元占用8个字节存储空间。此外，也可以和普通变量一起定义。

用逗号分隔开。

-3-23 10：29
一维数组元素引用2
1）
引用形式：数组名 【下标表达式】可以是：常量，变量，表达式。
如：double x【8】 则 x【0】 x【j】 x【i+k】均合法
2）
（1）一种数组元素事实上就是一种变量名，代表内存中一种存储单元。咱们可以把数组元素看做一种变量名来解决。
（2）一种数组不能整体引用，数组名中存储是一种地址常量，它代表整个数组首地址。当学习指针时，引用变量地址，就是变量中第一种字节地址。数组首地址也是它第一种元素第一种字节地址，即它首地址。
数组首地址存储在数组名中。因此说，数组名就代表一种地址。数组名是一种地址值。
（3）在引用数组元素时，数组元素下标表达式必要是整数，下标表达式下限为0.系统并不自动检查数组元素下标与否越界，因而编程时要注意。
如：double a,b；int c[10];
a=2.0;b=3.0;
则a[i]；是不合法。

给数组赋初值时，如果所赋初值少于元素个数时，背面元素补为0，字符补为’\0’
可以通过赋初值来定义一种数组大小。如：int a[]={0,0,0,0,0}； 相称于：a[5]={0};

一维数组初始化
void main()
{
int i,j,a[30];
for (i=0,j=1;i<30;i++,j+=2)
a[i]=j;
for (i=0;i<30;i++)
{
if (i%10==0) printf(“\n”)； /*i等于10，到了十，输入回车。由于0-9就是十个*/
printf(“%d，”,a[i]);
}
for (i=29;i>=0;i--)
{
printf(“%d，”,a[i]);
if (i%10==0) printf(“\n”); /*先输出第i=20这个元素，再输入回车。*/
}
getch();
} //10月14日14:43:15 上次是怎么做啊，错了那么多。

1一维数组和数组元素地址
1）数组和指针比较
（1）指针变量地址：指向内存中一种存储单元第一种字节地址。数组名地址值，就是该数组第一种元素第一种字节地址。
（2）指针变量有基类型，相称于数组类型名。
（3）指针变量地址值不可变化，即指针变量指向存储单元地址值是固定，不可变化，如int *p，a；p=&a；则变量a地址是不可变化。也不可给数组名地址重新赋值。如数组名为a数组：a=&x；或a++等给数组名重新赋值都是错误。一旦定义，a永远指向a数组首地址。
（4）虽然不可变化a内容（地址），但可以对数组名加一种整数办法，来依次表达该数组中不同元素地址。如：
a 代表 &a【0】数组首地址，也是a[0]地址 //首地址
a+1 代表 &a【1】数组元素a[1]地址 //在指针中，1代表一种存储单元
a+2 代表 &a【2】...... //注意：不是a=a+1，而是 a+1

例：
main()
{
int a[10],*p,x,k;
for(k=0;k<10;k++) p=a+k； //a是数组首地址，p=a+k；则遍历了数组中每个元素
for (k=0;k<10;k++) scanf("%d",a+k)； //输入每个元素值
for (k=0;k<10;k++) printf("%d\n",a[k])； //打印每个元素值
getch();
}

p=&a[0]；等价于 p=a；

如下语句等价：
for(p=a,k=0;k<10;k++) p++;//将数组a首地址赋给指针p，k从0到9，p++将遍历数组中每个元素地址。依次指向数组 a1，a2，a3......a9.
for(p=a,k=0;k<10;k++) {scanf("%d",p);p++;}
for(p=a,k=0;k<10;k++) scanf("%d",p++);//什么 自加自减运算符，当++在背面时，当前表达式值不变，元素加1.
for(p=a;p-a<10;p++) scanf(“%d”,p);

.4.2
通过数组首地址 指针 带下标指针引用一维数组元素。
引用一维数组中某一种元素办法：
* ：求当前地址内容 & ：求当前内容地址
1 a【i】
2 *&a【i】 //*在定义语句时代表定义一种指针变量，当在执行语句某些时代表间址运算符，引用一种指针变量指向地址内容。&叫求地址运算符，求当前内容地址。因此*和&就像乘号和除号同样，互相抵消了。
3 *（a+i）：在数组名地址上，加上i个存储单元。代表第（i+1）个元素，用间址运算符引用它，即等价于a[i]
4 当（p=a；||p=&a【0】） 则 *（p+i）等价于a[i]
5 当(p=a;||p=&a[0]) 则 p[i] 等价于 a[i] //方括号不但表达数组元素记号,也是一种运算符.

总结:引用一维数组元素 a[i] 四种办法： a[i] *(a+i) 若p=a，则 p[i] *(p+i)
表达a[i]地址办法：&a[i] a+i pi 都表达当前数组第i个元素地址。
如下代表什么:
*(P--) a[i--] *--p a[--i]
注:自加自减运算,p-- 等价于:m=p-- m=p p=p-1 //先赋值,（先取值）再变化
--p 等价于:m=--p p=p-1 m=p //先变化,再赋值。（再取值）

数组名a和指向数组指针p区别.前者不可变,不可运算,后者可以赋值,运算.
a++ 是个赋值表达式

3)逐个输出a数组中元素值.
for(k=0;k<10;k++) printf("%4d",*(a+k));
for(k=0;k<10;k++) printf("%4d",a[k]);
for(p=a,k=0;k<10;k++) printf("%4d",*(p+k));
for(p=a,k=0;k<10;k++) printf("%4d",p[k]);
for(p=a,k=0;k<10;k++) {printf("%4d",*p);p++} //p++,即依次指向每一种元素。

函数之间对一维数组和数组元素引用及一维数组实例1

1数组元素作为实参
在调用函数时，数组元素可以作为实参传送给形参，每个数组元素事实上代表内存中一种存储单元和普通变量同样，相应形参必要是类型相似变量。
2数组名作实参
如果用数组元素作实参话，数组元素值，可以传送给形参中相似类型一种变量，在函数中只能对该变量进行操作，而不能直接引用相应数组元素。（只能变化形参值，而不能变化实参即数组元素值）。数组名也可以作为实参传送，相应形参就应当是一种指针变量来引用调用函数中相应数组元素，从而达到对调用函数中相应数组元素进行操作目。但数组名自身是一种地址值，因而，相应形参就应当是一种指针变量。（该指针变量指向主调函数中数组首地址）该指针变量就可以来引用主调函数中相应任何一种数组元素，从而达到对主调函数中相应数组元素进行操作目。引用办法：
a【i】；*(a+i);p【i】；*（p+i）
例：编写程序，通过函数给数组输入若干不不大于等于0整数，用负数作为输入结束标志；调用函数输出该数组中数据。
#define M 100
int arrin(int *a)
{
int i=0;
scanf("%d",&a[i]);
while(a[i]>=0)
{
i++;
scanf("%d",&a[i]);
}
return i;
}
arrout(int *a,int n)
{
int i;
for(i=0;iin(a);
arrout(a,n);
getch();
}

10月16日8:46:45 自己做(修改后)
#define M 100
int main(void)
{
int a[M] ，n;
n=input(a);
output(a,n);
getch();
}
int input(int *a)
{
int i=0;
scanf("%d",a+i);
while(*(a+i)>=0)
{
i++;
scanf("%d",a+i);
}
return i;
}
int output(int *a,int n)
{
int i;
for(i=0;ianf("%d",a+i);
while(*(a+i)>=0)
{
i++;
scanf("%d",a+i);
if(a[i]<0) {a[i]=0;break；} /*作为结束标志负数赋值为0然后结束*/？
还是有诸多问题啊。
}
}
int output(int *a)
{
int i;
for(i=0;i 2一种数组形式 3直接用数组名。（三者形式不同，但其实质还是一种指针）
a(int *a) a(int a[]) a(int a[M])
*（a+i）等价于 a[i] 都表达数组中第i个元素
上面形参中数组a[]或a[ M]，都指向实参中数组首地址，它们只是与实参数组形式上相似，但在被调用函数中并未为形参开辟一串存储单元，它们本质还是指针。只是用数组形式引用而已。
函数之间对一维数组和一维数组元素引用及一维数组实例2

当数组元素地址作为实参时，由于是地址值，因此相应形参也应当是基类型相似指针变量，或数组名加空括号，或数组。
例题：编写函数，对具备10个元素char类型数组，从下标为4元素开始，所有设立‘*’，保持前四个元素内容不变。
fun(char *a,int n)
{
int i;
for(i=0;ia,10);
getch();
}

10月18日0:20:09 自己重做。
char charb(char *);
int main()
{
int i;
char a[10]={'a','b','c','d','e','f','g','h','i','j'};
for(i=0;i<10;i++)
{
printf("%c,",a[i]);
}
printf("\n");
charb(a);
for(i=0;i<10;i++)
{
printf("c,",a[i]);
}
getch();

}
char charb(char *ch)
{
int i;
for(i=4;i<10;i++)
{
ch[i]='*';
}
}
10月18日0:23:51 参照金文教师程序后，又修改。
char charb(char *);
void arrout(int ,int,char *a);
int main()
{
int i;
char a[10]={'a','b','c','d','e','f','g','h','i','j'};
arrout(0,10,a);
printf("\n");
charb(a);
arrout(0,10,a);
getch();
}
void arrout(int x,int y,char *a)
{
int i;
for(i=x;i把相似功能模块，例如，输出做成一种函数。 ……此程序不是用数组元素地址做实参，而是用数组名作实参。（程序功能实既有各种办法。）
数组名作实参时相应形参： a *a a[] a[10]
数组元素地址做实参时相应形参：&a[4] *a a[] a[6] ? 还要再理解

函数之间对一维数组和一维数组元素引用及一维数组实例3

4函数指针形参以及在在函数体中定义数组和主调函数体中数组区别
例：如下程序，形参a指向w数组，被调函数体内定义了一种数组b，被调函数把b数组起始地址作为函数值返回，企图使指针p指向函数体内b

数组开头。

#define N 10 //定义符号常量，10
int *fun(int a[N],int n)
{
int b[N];
......
return b;
}
main()
{
int w[N],*p;
......
p=fun(w,N);
......
}
//任何函数，在被调用执行后，为其开辟存储单元就会被释放掉。试图返回一种已经被释放掉数组首地址，是没有成果。
注：
1）函数fun中，形参a可以写成三种形式：a[N],a[],*a；它是一种指针变量，在调用fun函数时，系统只为形参a开辟一种存储单元，并把main函数中w数组首地址存进去，使它指向w数组地址。
2）函数fun函数体定义了一种b数组，在调用fun函数时，系统为它开辟了一串持续存储单元，它是一种地址常量。？
3）在fun函数执行完毕后，系统释放a和b所占存储单元，而b值作为fun函数返回值，指针p将不指向任何对象而成为“无向指针”
。

函数之间对一维数组和一维数组元素引用及一维数组实例4

10月18日21:49:53 又从互联网上学了一招：a%=4-1 等价于 a=a%(4-1) 即 a=a%3 即 a=2

1编写程序，定义一种具有15个元素数组，并编写数组分别完毕如下操作。
1）调用库函数中随机函数给所有元素赋以0-50之间随机数；
2）输出数组元素中值
3）按顺序对每隔三个数求一种和数，并传回主函数
4）最后输出所有求出和值。

#include "stdlib.h"
#include "stdio.h"
getrand(int *a,int n)
{
int i;
for(i=0;iint n)
{
int i,j,sum;
for(i=0,j=0,sum=0;i

#include
main()
{
int i,a,b,h,sum=0;
for(i=0;i<10;i++)
{
randomize();//随机数种子初始化函数
a=random(5);
b=random(5);
sum=a+b;
printf("%d+%d=",a,b);
scanf("%d",&h);
while(sum!=h)
{
printf("cuole\n");
printf("%d+%d=",a,b);
scanf("%d",&h);
}
printf("duile\n");
}
getch();
}

10月19日12:32:46 自己做，和金文教师程序很不同，但也完毕了题目规定功能，究竟哪个更好某些呢？
#include "stdio.h"
int main()
{
int i,j,a[15],b[5],k=0;
srand((unsigned)time(NULL))； //采用时间作为 随机种子
for(i=0;i<15;i++)
{
a[i]=rand()%51； //（y-x+1）+x 取x-y之间随机数公式。
}
arrout(a,15);
printf("\n");
for(j=0;j<15;j+=3)
{
b[k]=sanshuhe(a[j],a[j+1],a[j+2]);
k++;
}
arrout(b,5);
getch();

}
int arrout(int *a,int n)
{
int i;
for(i=0;iint n)
{
int i;
for(i=0;i
fun(a,b,5);
arrout(b,5);
getch();
} //why??? 第二天晚上，搞定了！

对的解法：
arrout(int *a,int n)
{
int i;
for(i=0;i t=a[i];a[i]=a[j];a[j]=t;
i++;
j--;
} //这个算法较好啊。运算才6次。看来一种程序算法真是很重要啊，差别太大了。
}
main()
{
int a[5]={1,2,3,4,5};
arrout(a,5);
fun(a,5);
arrout(a,5);
getch();
}

10月19日15:40:27 自己做。
int main()
{
int t,i,j,a[5]={1,2,3,4,5};
arrout(a);
for(i=4;i>0;i--)
{
for(j=0;jrintf("\n");
}

函数之间对一维数组和一维数组元素引用及一维数组实例6 4.9

已知数组中值在0-9范畴内，记录每个整数个数。

#include
getdate(int *a,int n)
{
int i;

for(i=0;i);
}
printf("\n");
}
fun(int *a,int *b,int n)
{
int i;
for(i=0;i10);
getch();
}

函数之间对一维数组和一维数组元素引用及一维数组实例7 4.9

已知存储在a数组中数不相重，在a数组中查找和x值相似元素位置。若找到了，输出该值和该值在a数组中位置，若没找到，输出相应信

息。

一自己做
fun(int *a,int n)
{
int i;
for(i=0;i<5;i++)
{
if(n==a[i])
printf("%d,%d\n",a[i],i);
if(i>5) printf("no");
}

}
main()
{
int a[5]={1,2,3,4,5},n=6;
fun(a,n);
getch();
}

二看视频后模仿做

int getin(int *a)
{
int i,n;
do
{printf("please input >1 and <30 number:");scanf("%d",&n);} while(n<1||n>30);
for(i=0;iint *a,int x,int n)
{
int i,p;
for(i=0;i=n) p=-1;
else p=i;
return p;
}

main()
{
int a[30],x,n,p;
n=getin(a);
scanf("%d",&x);
p=fun(a,x,n);
if(p!=-1) printf("x=%d,p=%d\n",x,p);
else printf("NO");
getch();
}

10月19日22:36:38 自己又做了一遍，和金文教师程序比起来，还是差了不少啊。
int arrout(int *a,int n)
{
int i;
for(i=0;ireak;}

}
if(i>=n) printf("NO");

}
int main()
{
int n,x,a[5]={1,2,3,4,5};
arrout(a,5);
scanf("%d",&x);
search(a,x,5);
getch();
}

函数之间对一维数组和一维数组元素引用及一维数组实例8 4.10

w数组中存储着n个数据，编写函数实现删除下标为k元素中值

arrout(int *a,int n)
{
int i;
for(i=0;i
printf("%d，",a[i]);
printf("\n");
}
int getn(n)
{
int i;
do{printf("please input xiabiao:");
scanf("%d",&i);} while(i<0||i>30);
return i;
}
int arrdel(int *a,int n,int m)
{
int i;
for(i=n;iturn m-1;
}
main()
{

int w[30]={1,2,3,4,5,6,7,8,9,10}，n,k;
arrout(w,30);
n=getn(30);
k=arrdel(w,n,30);
arrout(w,k);
getch();
}

10月20日15:19:47 自己做。感觉和金文教师程序各有千秋吧，O(∩_∩)O。
int main()
{
int x,n,a[30];
n=getarr(a);
arrin(a,n);
arrout(a,n);
printf("shu ru xia biao:\n");
scanf("%d",&x);
del(a,x,n);
arrout(a,n-1);
getch();
}
int getarr(int *a)
{
int i;
do
{
printf("shu ru array chang du:\n");
scanf("%d",&i);
}
while(i<0||i>30);
return i;
}
int arrin(int *a,int n)
{
int i;
for(i=0;i1];
}
}

函数之间对一维数组和一维数组元素引用及一维数组实例9 4.9

用选取法对数组中数进行排序（按从小到大顺序）

自己做：40分钟

#include
void arrout(int *a,int n)
{
int i;
for(i=0;i {
for(i=j+1;i<5;i++)
{
if(a[i]5);
search(a);
arrout(a,5);
getch();
} //是有问题，网上说这叫定向排序法，效率不高，真正直接选取排序法尚有一种小小改进，据说是循环次数不变，但交

换次数变少了。

修改后直接选取排序法：

#include
void arrout(int *a,int n)
{
int i;
for(i=0;it *a)
{
int i,j,temp,p,m=0,n=0;
for(j=0;j<4;j++)
{
p=j;
for(i=j+1;i<5;i++)
{
if(a[i]p];a[p]=temp;*/
n++;
}
}
printf("xun huan ci shu：%d\n",n);
printf("jiao huan ci shu：%d\n",m);
}
void main()
{
int a[5]={8,1,1,1,8};
arrout(a,5);
search(a);
arrout(a,5);
getch();
}
/*此程序不对，但我又是半年没有接触C语言了，因此生疏了，还没看出