c语言数组实训

c语言数组实训（精选11篇）

c语言数组实训 第1篇

今天同学遇到一个在C语言中全局数组和局部数组的问题，卡了许久，我也没有第一时间看出问题，现在把问题梳理一下，并给出解决方案，

问题描述：

在全局声明的数组与在局部声明的数组有着不同的效果。

首先来看一个程序：

#include

#include

#define MAX 10

char a[MAX];

int main()

{

int i;

char b[MAX];

char *c=(char *)malloc(MAX * sizeof(char));

printf(“ Array a: ”);

for(i=0;i

printf(“%d ”,a[i]);

printf(“ Array b: ”);

for(i=0;i

printf(“%d ”,b[i]);

printf(“ Array c: ”);

for(i=0;i

printf(“%d ”,c[i]);

printf(“ Done”);

free(c);

return 1;

}

编译运行结果：

程序主要功能是打印字符数组的Ascii码。可以发现全局数组a和动态生成的数组c有着相同的结果，而局部声明的数组b确被分配了随机的数值，也许这就是问题的所在。

解决方案：

#include

#include

#define MAX 10

char a[MAX]={0};

int main()

{

int i;

char b[MAX]={0};

char *c=(char *)malloc(MAX * sizeof(char));

printf(“ Array a: ”);

for(i=0;i

printf(“%d ”,a[i]);

printf(“ Array b: ”);

for(i=0;i

printf(“%d ”,b[i]);

printf(“ Array c: ”);

for(i=0;i

printf(“%d ”,c[i]);

printf(“ Done”);

free(c);

return 1;

}

运行结果：

在数组的初始化中，假设初始化的数值个数小于数组的大小，则全部用0来填充，

这里通过初始化一个值，就可以给数组一个确定的结果。

（在不同系统和不同的编译器可能会出现不同的结果）

还有一个小问题就是C语言中空格的问题，看下面的程序。

#include

#include

#define MAX 10

int main()

{

int i;

char b[MAX]={0};

gets(b);

printf(“ Array b: ”);

for(i=0;i

printf(“%d ”,b[i]);

printf(“ Done”);

return 1;

}

在这里，我输入了“ int”(三个空格+int)，打印的结果如上图。

b中前三个记录了空格的Ascii码，即32。

b中后面没有使用的空间依然是0。

打完收工。

c语言数组实训 第2篇

（2）#include

int main(void)

{

int i;

char ch;

char str[100];

printf(“请输入字符串:n”);

scanf(“%s”, str);

printf(“请输入查找字符:n”);

scanf(“ %c”, &ch);

for(i=0;str[i]!=';i++)

{

if(str[i] == ch)

{

printf(“位置为:%dn”, i+1);

return 0;

}

}

printf(“该字符不存在n”);

return 0;

}

（3）

(1)

#include

main()

{

long matrix[8][8],min,max,temp;

int i,j,m,n;

printf(“nPlease input n of Matrix:n”);

scanf(“%d”,&n);

m=n;

printf(“nPlease input elements of Matrix(%d*%d):n”,m,n);for(i=0;i

for(j=0;j

scanf(“%ld”,&matrix[i][j]);

for(i=0;i

{

for(j=0;j

printf(“%5ld”,matrix[i][j]);

printf(“n”);

}

}

(2)

#include

main()

{

long matrix[8][8],min,max,temp;

int i,j,m,n,nMax=0,nMin=0;

printf(“nPlease input n of Matrix:n”);

scanf(“%d”,&n);

m=n;

printf(“nPlease input elements of Matrix(%d*%d):n”,m,n);for(i=0;i

for(j=0;j

scanf(“%ld”,&matrix[i][j]);

min=max=matrix[0][0];

for(i=0;i

for(j=0;j

{

if(matrix[i][j]>max)

{

max=matrix[i][j];

nMax=i;

}

else if(matrix[i][j]

{

min=matrix[i][j];

nMin=i;

}

}

for(j=0;j

{

temp=matrix[nMax][j];

matrix[nMax][j]=matrix[nMin][j];

matrix[nMin][j]=temp;

}

printf(“nResult matrix:n”);

for(i=0;i

{

for(j=0;j

printf(“%5ld”,matrix[i][j]);

printf(“n”);

}

}

(3)

#include

main()

{

long matrix[8][8],min,max,temp;

int i,j,m,n,nMax=0,nMin=0;

printf(“nPlease input n of Matrix:n”);

scanf(“%d”,&n);

m=n;

printf(“nPlease input elements of Matrix(%d*%d):n”,m,n);for(i=0;i

for(j=0;j

scanf(“%ld”,&matrix[i][j]);

min=max=matrix[0][0];

for(i=0;i

for(j=0;j

{

if(matrix[i][j]>max)

{

max=matrix[i][j];

nMax=i;

}

else if(matrix[i][j]

{

min=matrix[i][j];

nMin=i;

}

}

for(j=0;j

{

temp=matrix[nMax][j];

matrix[nMax][j]=matrix[nMin][j];

matrix[nMin][j]=temp;

}

printf(“nResult matrix:n”);

if(nMax!=nMin)

for(i=0;i

{

for(j=0;j

printf(“%5ld”,matrix[i][j]);

printf(“n”);

}

Printf(“same line!n”)

（4）#include

void main()

{

int a[20];

int n,j,i,k,m=20;

printf(“给定的数组为：n”);

for(n=0;n<20;++n)

{

a[n]=2*n+3;

printf(“%d ”,a[n]);

}

printf(“n”);

printf(“输入要查找的数:”);

scanf(“%d”,&j);

for(n=0;n<=m;)

{

i=(m+n)/2;

if(a[i]

n=i+1;

else if(a[i]>j)

m=i-1;

else if(a[i]=j)

{

printf(“该数在数组的第%d位上n”,i+1);break;

}

if(n>m)

{

printf(“No Foundn”);

}

}

}

二、#include

void arr();

int sea(int j);

int a[20];

void main()

{

int n,j,i,h;

printf(“请输入20个数据：n”);

for(n=0;n<20;++n)

scanf(“%d”,&a[n]);

}

arr();

printf(“n请输入要查找的数：”);

scanf(“%d”,&j);

h=sea(j);

if(h==0)

{

printf(“No foundn”);

}

else

{

printf(“该数在已排序数组的第%d位n”,h)}

}

void arr()

{

int z,n,k;

for(n=0;n<20;++n)

{

for(k=0;k<19-n;k++)

if(a[k]>a[k+1])

{

z=a[k];

a[k]=a[k+1];

a[k+1]=z;

}

printf(”将数组排序,得:n“);

for(n=0;n<20;++n)

printf(”%d ",a[n]);

}

}

int sea(int j)

{

int n,i,h,m=20;

for(n=0;n<=m;)

{

i=(n+m)/2;

if(a[i]

n=i+1;

else if(a[i]>j)

m=i-1;

else if(a[i]=j)

{

浅析C语言数组与指针 第3篇

关键词：C语言,指针,数组,自增自减

在C语言中数组表示一组数据类型都一样的有序数据的集合, 在内存中, 它们占有连续的存储单元, 数组分一维数组和多维数组, 一维数组是数组中最简单的, 比较容易理解, 用一个数组名和一个下标就能唯一地确定一个元素。多维数组理解相对抽象些, 以二维数组举例, 二维数组在内存中虽然是占一个连续的存储单元, 但是习惯上把它写成矩阵的形式, 更有助于理解其逻辑结构, 二维数组每一行都可以看成一个一维数组。任何数组它们的数组名代表数组的首地址。而指针是C语言的另一个重要概念, 指针代表地址, 并且指针是可以移动的, 对于数组和指针的使用, 初学者往往感到无所适从, 笔者根据多年经验, 利用等级考试中的典型实例来进行描述和分析, 所有实例如都在VC6.0环境下通过, 希望初学者能快速理解和掌握。

1指向一维数组指针的定义及数组元素的引用

定义指向数组元素的指针变量的方法, 与定义指向变量的指针变量相同, 假设定义了一个一维数组int a[5]和一个指针变量int *p, 如何让指针变量指向数组呢?对于一维数组来说, 只要让指针变量指向它的数组元素就可以, 因为数组名a代表数组的首地址, 所以p=&a[0] 或p=a都表示指针指向数组的第一个元素, 直接定义可以写成int *p=a。而p+1表示指向下一个元素, p-1表示指向数组上一个元素, 这样, 其后面第i个元素它的地址就可以表示成p+i, 也可以表示成a+i。

若p指向a[0], 而a[i]的地址可以用p+i或a+i表示, 所以, 引用数组元素的时候, 既可以用普通的下标法如a[i]形式, 也可以用指针法, 这时* (p+i) 和* (a+i) 都可以表示a[i]元素。

实例分析:此实例中, 定义了一个指针指向a[1], i的值为3, 输出a[3]和p[3]的值, 很多初学者以为p[i]的写法是错误的, 有的初学者则认为a[3]和p[3]等价, 输出结果是40, 40, 但实际上, 在C语言中, 指针变量可以带下标, 程序在编译时, 会把下标的处理转换为地址的, p[i]处理成* (p+i) , 因为一开始的时候p指向a[1], 那么p+i则表示往后数第三个元素, 也就是a[4], 故此程序输p出结果为40, 50。若一开始p=a, 也就是说指针指向第一个元素, 那么a[i]和p[i] 的值就是相等的。

2指针与自增自减运算符的结合

指针若与自增自减运算符结合起来使用, 初学者最容易出错, 以自增运算符为例, 若程序中出现*p++、* (p++) 、* (++p) 、++ (*p) 等算式, 看起来差不多, 很多初学者搞不懂它们之间的区别, 殊不知“失之毫厘, 谬以千里”, 因为不懂它们的区别, 分析程序时往往得到错误的结果。

首先, 大家要知道“*”和“++”都是单目运算符, 它们同一个优先级, 其结合方向是自右向左的, 所以*p++和* (p++) 等价, 根据自增运算符的“名前先取”原则, 要先取*p的值, 再使p自增1, 即指向下一个数组元素, * (++p) 则是先使p指向下一个元素, 再取*p的值, 这几个算式都是对所指的地址加1。 ++ (*p) 表示先取*p, 再在这个值的基础上加1, 也就是对所指的元素的值加1。

实例分析:此实例中, 自先定义了数组a, 指针p和指向指针的指针k, 通过p=a和k=&p语句, 使指针p指向数组a的首地址, k指向指针p, 接下来printf (“%d ”, * (p++) ) 语句, 是先输出*p的值为2, 再使指针往后指, 再输出**k的指也就是*p的值, 此时, p指向4, 输出4, 程序的输出结果为“2 4”。

3指向二维数组指针的定义及数组元素的引用

在使用指针指向二维数组时首先要了解多维数组元素的地址表示方式, 假设有二维数组a[3][3], 那么在逻辑上可以把这个二维数组看作是一个3行3列的表格, 也可以看成是一个有3个元素的一维数组, 该数组的每个元素也是一个一维数组, 序号为0的行的首地址可以用a[0]、&a[0]或a表示, 序号为1的行的首地址可表示为a[1]、&a[1]或a+1, 如图1所示。根据一维数组指针的定义, a[0]的值可以又表示成为*a, a[1]可以表示为* (a+1) , a[i]即为* (a+i) 。序号为0的行的首地址也就是元素a[0][0]的地址, 即&a[0][0], 它后面几个元素的地址可以表示为a[0]+1, a[0]+2 , 若用指针法表示为* (a+0) 、* (a+0) +1和* (a+0) +2, 以此类推, 第i行第j列元素的地址&a [i][j]可以表示成为a[i]+j, 指针法表示为* (a+i) +j, 也就是说&a[i][j]、 a[i]+j、* (a+i) +j是等价的。这样, 对于一个二维数组来说, 元素a[i] [j]可用指针法表示为* (a[i]+j) 或* (* (a+i) +j) 。

指针变量指向二维数组中的元素, 可以有两种定义指针方法, 一种是直接定义成指向数组元素的指针变量, 如int *p, 再让p指向数组中某个具体元素;还有一种是定义成指向二维数组某一行的指针变量, 假设一行有M个数据, 则可以定义成int (*p) [M]=a, 这样就可以让指针指向第一行。

程序分析:此实例中, 指针p指向二维数组a的首地址, 然后执行循环, 首先i=0, j=0, 累加* (* (p+0) +0) , 即a[0][0], 接着i=0, j=1, 累加* (* (p+0) +1) , 即a[0][1], 然后j=2时跳出内循环, 以此类推, 执行下一次外循环i=1时, 累加a[1][0]和a[1][1], 执行外循环i=2时累加a[2][0]和a[2][1]……最后i=3时跳出整个循环, 由此看出, 语句在这里其实就是累加二维数组第一列和第二列的元素。最后结果为1+3+9+11+17+19=60, 输出“k=60”。

总之, 指针和数组结合起来使用非常灵活, 同一地址有多种表示方法, 而指针根据地址表示的不同可定义成指向数组元素的指针和指向某行数据的指针, 初学者很难理解, 大家一定要从C语言的数组和指针的概念出发, 仔细琢磨, 反复思考, 多比较, 多应用, 如果能很好地应用指针访问数组, 对C语言后面的知识学习有很大帮助, 如C语言的结构体、共用体、链表等, 都是跟指针和数组相关的, 正确灵活地运用指针, 可以使程序更加简洁、紧凑、高效。

参考文献

[1]谭浩强.C程序设计[M].4版.北京:清华大学出版社, 2010.

[2]未来教育.全国计算机等级考试模拟考场二级C[M].成都:电子科技大学出版社, 2015.

C语言中数组的元素 第4篇

关键词：数组；元素；数据；类型

中图分类号：TP313文献标识码：A文章编号：1007-9599 (2010) 16-0000-02

Elements of the Array in C-language

Zhang Kexing

（Foreign Language Teachers College of Taiyuan University,Taiyuan030012,China）

Abstract:The array is the most commonly used programming data st-

ructure.Array can be divided into array of values（integer group,real array）,a character array and pointer array and the array of structures.

This array will be examples of various types were analyzed and explained.

Keywords:Array;Element;Data;Type

一、引言

數组是相互关联的一批数据的序列，序列中的数据称为数组的元素，可按照排列顺序编号，起始编号一般为0，前后两个数据的编号有差异，通过编号可以唯一指定数组中的数据成员。数组中的元素可以是基本类型，也可以是构造类型。按照数组元素的不同可将数组分为数值数组、字符数组、指针数组、结构数组。

二、数值数组

数值数组是指数组元素是整型、实型、及其相关类型的数据，简单说，就是元素是数字的数组。

例1：

main（）

{

int i，a[10]；

for（i=0；i<=9；i++）

a[i]=i；

for（i=9；i>=0；i--）

printf（"%d "，a[i]）；

}

在该例中，第一个for语句给数组a中的10个元素赋值为整形数据0-9，赋值以后数组中数据如下：

第二个for语句将数组a中的10个数字反序输出，即9、8、7、6、5、4、3、2、1、0

数值数组是数组中使用率最高的数组，需要注意的是一个数组中的数据必须是同一种类型的数据，

{int a[3]；

a[0]=3；

a[1]=2.5；

a[2]=3.0；}

是不合法的。

三、字符数组

C语言没有专门定义字符串数据类型（如其他语言中的string），它用以''结尾的字符数组来表示一个逻辑意义上的字符串。

字符数组主要有两种用途，（1）存储字符串，（2）存储字符或字符变量。这两个是不同的，刚开始接触时很容易混淆。下面进一步分析这两者的不同。

首先初始化时不同，用于存储字符串，例如：char str[]="Hello"； 用于存储字符或字符变量，例如：char Chars[]={‘H‘‘e‘，‘1‘‘1‘，‘o‘}。这两者的存储方式是一样的，但是存储内容稍微有所不同，那就是第一种情况会在结尾加上‘’，存储情况类似于{‘H‘‘e‘，‘1‘‘1‘，‘o‘，‘‘}，存储空间会比第二种情况大一点，但是这个存在空间并不被计算进字符串（其实只是字符数组）变量中。

C语言中提供的字符串操作函数其实是针对于结尾是‘‘的字符数组进行的。输出函数printf中的输出参数%s也是针对于结尾是‘‘的字符数组。

另外，还有一种方法可以定义字符串（其实也是字符数组），声明如下：

char * string = "this is a point charArray."；字符指针指向字符数据的第一个字符的位置。

最后，有两点特别说明。

（1）字符串常量给出的是地址值。如

char *p， s[10]；

p="hello"；//正确

（2）不能用赋值语句给字符数组整体赋一串字符，例：

char str[10]；

str = "abc"；//错误

例2：

char c[10]={‘c’， ‘’， ‘p’， ‘r’， ‘o’， ‘g’， ‘r’， ‘a’，’m’}；

赋值后数组元素如下：

四、指针数组

在C语言中，一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

指针数组说明的一般形式为：

类型说明符*数组名[数组长度]

其中类型说明符为指针值所指向的变量的类型。

例如：

int *pa[3]

表示pa是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。

例3：

通常可用一个指针数组来指向一个二维数组。指针数组中的每个元素被赋予二维数组每一行的首地址，因此也可理解为指向一个一维数组。

main（）{

int a[3][3]={1，2，3，4，5，6，7，8，9}；

int *pa[3]={a[0]，a[1]，a[2]}；

int *p=a[0]；

int i；

for（i=0；i<3；i++）

printf（"%d，%d，%dn"，a[i][2-i]，*a[i]，*（*（a+i）+i））；

for（i=0；i<3；i++）

printf（"%d，%d，%dn"，*pa[i]，p[i]，*（p+i））；

}

本例程序中，pa是一个指针数组，三个元素分别指向二维数组a的各行。然后用循环语句输出指定的数组元素。其中*a[i]表示i行0列元素值；*（*（a+i）+i）表示i行i列的元素值；*pa[i]表示i行0列元素值；由于p与a[0]相同，故p[i]表示0行i列的值；*（p+i）表示0行i列的值。

在C语言中，数组元素全为指针的数组成为指针数组。

一维指针数组的定义形式为：“类型名*数组标识符[数组长度]”。

例如，一个一维指针数组的定义：int *ptr_array[10]。

指针数组的含义：

指针数组中的每一个元素均为指针，即有诸形如“*ptr_array[i]”的指针。

由于数组名本身也是一个指针，因此指针数组中的元素亦可以表示为“*（*（ptr_ayyry+i））”。又因为“（）”的优先级较“*”高，且“*”是右结合的，因此可以写作**（ptr_array+i）。

五、结构数组

数组的元素也可以是结构类型的。因此可以构成结构型数组。结构数组的每一个元素都是具有相同结构类型的下标结构变量。在实际应用中，经常用结构数组来表示具有相同数据结构的一个群体。如一个班的学生档案，一个车间职工的工资表等。

方法和结构变量相似，只需说明它为数组类型即可。

例4：

struct stu

{

int num；

char *name；

char sex；

float score；

}boy[5]；

定义了一个结构数组boy，共有5个元素，boy[0]～boy[4]。每个数组元素都具有struct stu的结构形式。

例5：计算学生的平均成绩和不及格的人数。

struct stu

{

int num；

char *name；

char sex；

float score；

}boy[5]={

{101，"Li ping"，'M'，45}，

{102，"Zhang ping"，'M'，62.5}，

{103，"He fang"，'F'，92.5}，

{104，"Cheng ling"，'F'，87}，

{105，"Wang ming"，'M'，58}，

}；

main（）

{

int i，c=0；

float ave，s=0；

for（i=0；i<5；i++）

{

s+=boy[i].score；

if（boy[i].score<60） c+=1；

}

printf（"s=%fn"，s）；

ave=s/5；

printf（"average=%fncount=%dn"，ave，c）；

}

本例程序中定义了一个外部结构数组boy，共5个元素，并作了初始化赋值。在main函数中用for语句逐个累加各元素的score 成员值存于s之中，如score的值小于60（不及格）即计数器C加1，循环完毕后计算平均成绩，并输出全班总分，平均分及不及格人数。

六、总结

数组是程序设计中最常用的数据结构。数组可分为数值数组（整数组，实数组），字符数组以及指针数组和结构数组。数组可以是一维的，二维的或多维的。数组类型说明由类型说明符、数组名、数组长度（数组元素个数）三部分组成。要想将不同的数据用不同类型的数组存放，就需要深入了解每一种类型的数组及其特点，这样才能灵活运用，充分发挥每种数据类型的长处。

参考文献：

[1]谭浩强.C程序设计教程[M].北京:清华大学出版社,2007,7

[2]李岩.C语言程序设计基础与上机知道[M].北京:清华大学出版社,2006,3

[3]马秀丽等.C语言程序设计[M].北京:清华大学出版社,2008,3

[4]罗坚.C语言程序设计[M].北京:中国铁道出版社,2009,2

作者簡介：

张科星（1980-），女，山西太原人，研究生，太原大学外语师范学院，助教，研究方向：网络，计算机教育。

c语言数组方法总结 第5篇

1.输入元素的值：

inti,a [10];

for(i = 0;i < 9;i ++);

a[i] = i;

(1)正序排列：(2)倒序排列：

for(i =0;i < 10;i ++)for(i = 9;i >= 0;i--)printf(“%d”, a[i]);printf(“%d”, a[i]);

2.初始化元素的值：

（1）在定义时，将数组元素一次放在一对花括号里;

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

(2)可以只给一部分元素赋值:

eg: int a[10]={1,3};

(3)使数组全部元素为0：

eg: int a[10]={0,0,0,0,0,0,0,0,0,0};或者 int a[10]={0};

(4)在对全部元素赋初值的时候，由于元素数已经确定，因此，可以不指定数组长度。（注：数组长度与提供初值个数不相同时，则长度不可以省略。）

3.巧妙地将两个元素列在一个循环中输出：（用for循环处理fobonacci数列）； eg：int f[20]={1,1};

for(i=2;i<20;i++)

f[i]=f[i-1]+f[i-2];

4． 数列Fobonacci数列核心：

int f[20]={1,1};

for(i=2;i<20;i++)

f[i]=f[i-1]+f[i-2];

5.换行操作：

for(i=0;i<=20;i++)/*当然也可以在for循环中处理，直接将{if(i%5= =0)printf(“n”);if(i%5= =0)printf(“n”);插入换行*/Printf(“%12ld”,f[i]);

}

6.起泡法：

int a[10];

for(j=0;j<9;j++)/*进行n-1趟比较*/

for(i=0;i<9-j;i++)/*在j趟比较中，比较n-1次*/

if(a[i]>a[i+i])/*由小到大排列，if(a[i]

7.初始化二维数组：

 分行给二维数组赋初值；

 将所有的元素都写在一个花括号里；

 对部分元素赋值：

1)int a[3][3]={{3},{5},{9}};只讲0列元素赋值

2)int a[3][3]={{1}, {0,6},{0,0,11}};对部分元素赋值，对非0元素少使用方便

3)int a[3][3]={{1}, {5,6}};只对几行元素赋值

4)int a[3][3]={{1}, {},{9}};对第二行元素赋值

 对全部元素赋值可以省略一维长度：

 对部分元素赋初值，在省略一位长度时，应分行赋值：

8.二维数组的输入输出：

 输入：直接定义

 输出：

for(i=0;i<=2;i++)

{for(j=0;j<=1;j++)

printf(“%5d”,b[i][j]);

printf(“n”);

}

9.二维数组的行列转换：

b[j][i]=a[i][j];

10.数组中求最大值并输出行列号：

Eg：inti,row=0,colum=0,max;

inta[3][4]={1,2,3,4,5,6，7,8,9,10,11,12};

max=a[0][0];

for(i=0;i<=2;i++)

for(j=0;j<=3;j++)

if(a[i][j]>max)

{max=a[i][j];

row=i;

colum=j;}

11.字符数组的初始化方法：

 逐个字符初始化：

eg：char c[10]={„I‟, „‟, „a‟, „m‟, „‟, „h‟, „a‟, „p‟, „p‟, „y‟};

1)在定义字符数组时，不初始化，则数组中的各元素的之不可预料；

2)如果花括号中提供的初值个数（即字符个数）大于数组的长度，则按语法错误

处理；

3)如果花括号中提供的初值个数（即字符个数）小于数组的长度，其余元素自动

定为空字符即（„‟）;

 如果提供的初值个数与数组长度相同，则在定义时可以省略数组长度；  也可以定义一个二维数组：

eg:char diamond[5][5]={{},{},{},{},{}}; 用字符串常量，使字符数组初始化：

eg： char c[ ]={“I am happy”};或char c[ ]= “I am happy”;

12.字符数组的输出：

一维：二维：

for(i=0;i<=11;i++)for(i=0;i<=11;i++)

printf(“%c”,c[i]);for(i=0;i<5;i++)

printf(“n”);printf(“%c”,diamond[i][j]);

13.字符数组输出最大值：

eg：if(strcmp(string,str[1]>0)

strcpy(string,str[0]>0);

else

strcpy(string,str[1]);

if(strcmp(str[2],string>0)

strcpy(string,str[2]);

C语言数组基本概念理解 第6篇

变量类型 变量名；

元素类型 数组名[元素个数]; // 数组中保存的每一个数据，我们称之为元素

特点：数组只能存放同一种数据类型

数组中的每一个元素都有一个索引号，索引号从0开始部分初始化， 没有赋值的元素默认是0

数组[]中的元素个数只能写整型常量，以及返回值是整型常量的表达式通过变量定义数组，如果没有对数组进行初始化，里面存放的是一些垃圾数据（随机值）在定义数组的同时进行初始化，可以省略元素个数，会自动的计算出数组元素的个数要想给数组一次性赋值（给数组中所有的元素赋值）只能在定义数组的同时，如果定义完数组之后，就不能再对数组进行一次性的赋值数组的地址就是它第0个元素的地址，数组名就是数组的地址

数组元素存放值是从小到大， 而每一个元素存值又是从大到小

因为内存寻址从大到小，所以先定义的数组的地址比后定义的地址大

基本数据类型作位函数参数是值传递

数组作为函数参数传递的是地址

当数组作为函数参数传递的时候，可以省略[]中的元素个数

当数组作为函数参数传递的时候，会自动转换成“指针类型”

而指针在当前操作系统mac 下占用8个字节

想在函数中动态计算数组的元素个数是不行的，因为指针类型占8个字节

选择排序原理：依次选择数组中过的每一个元素和其他元素进行比较

当内循环执行完一次（比较完一次）， 最值出现在头角标上

冒泡排序原理： 冒泡排序是拿相邻的两个元素进行比较

特点： 内循环执行完一次（完整的比较完一次），最值出现在尾角标上，

C语言数组基本概念理解

，

大一c语言数组实验心得 第7篇

很多初学者弄不清指针和数组到底有什么样的关系，为避免混淆不清，下面总结一下指针和数组的特性。

指针是保存数据的地址，任何存入指针变量的数据都会被当作地址来处理，指针变量本身的地址由编译器另外存储，存储在哪里，我们并不知道，间接访问数据，首先取得指针变量的内容，把它作为地址，然后从这个地址读或写入数据。

指针可以用间接访问操作符(_)访问，也可以用以下标的形式访问,指针一般用于动态数据结构。

数组是用来保存数据的，数组名代表的是数组首元素的地址而不是数组的首地址，所以数组p与&p是有区别的，虽然内容相同，但意义却不同，&p才是整个数组的首地址，数组名是整个数组的名字，数组内每个元素并没有名字，不能把数组当一个整体来进行读写操作。

当然数组在初始化时也有例外，如int p[]=“12345”是合法的。

数组可以以指针的形式访问如_(p+i);也可以以下标的形式访问p[i]，但其本质都是p所代表的数组首元素的地址加上i_sizeof(类型)个字节作为数据的真正地址来进行访问的。

数组通常用于存储固定数目且数据类型相同的元素。

刚开始的时候我

有点分不清指针数组和数组指针，现在也总结一下，指针数组，首先它是一个数组，数组的每个元素都是指针，可以理解为“存储指针的数组”的简称，数组指针，首先它是一个指针，它指向一个数组，在32位系统下永远只占4个字节，至于它指向的数组有多少个字节，并不知道，可以理解为“指向数组的指针”。

举个例子，int _p1[10]与int (_p2) [10], 要理解这个问题，首先要清楚操作符的优先级，“[]” 的优先级比“_”的优先级高，所以首先p1与“[10]”结合构成一个数组p1[10],int _为修饰数组的内容，所以数组元素是指向int类型的指针，所以这个是指针数组，“”的优先级比“[]”的优先级高，“_”与p2结合构成一个指针变量，int修饰数组的内容，即数组的每个元素，数组这里并没有名字，是个匿名数组，现在清楚了p2是一个指针，它指向一个包含10个int类型数据的数组，即为数组指针。

下面再说说内存管理，内存分为三个部分：静态区、堆、栈。

其实堆栈就是栈，而不是堆。

静态区是保存自动全局变量和static变量。

静态区的内容在整个程序的生命周期内都存在，由编译器在编译的时候分配。

堆是由malloc系统函数分配内存的。

其生命周期由free和delete决定。

栈保存局部变量。

栈上的内容只在函数范围内存在，当函数运行结束，这些内容也会自动被销毁。

再说说有关内存需要注意的地方，定义了指针变量，在使用之前一定要初始化使它指向一块合法的内存，不管什么时候，我们在使用指针之前一定要确保指针是有效的。

使用malloc系列函数分配内存，使用完之后应及时释放内存，以防止内存泄露。

C语言中数组和指针剖析 第8篇

但是如果是用静态数组, 比如是一维数组的话, 那不管你定义多大, 还是不能满足需要的, 如果定义char A, 当如果存储空间超过范围A数组就不能再存放了, 除非事先增大了空间。比如下面这个表格的模拟情况就反映了这个特点。

这个表格反映了使用A[5]数组来存放当增大就会溢出出错情况如下:

数组要事先就确定空间大小也就是下标大小, 而指针是可以变化的, 并且数组有下标就很方便来调用中间的一个具体位置的值。

C语言中对于指针可以指向相应类型的变量, 比如整型指针是不能指字符串的, 因为它的每次移动的大小跨度为两个字节, 而不同的记录型指针也是不能互相指向的, 也就是加入struct hhp*pl;这个pl结构体指针它的pl++的每次加一得跨度可能变化不一样, 也就是它的步长大小与其他的指针不同, 所以就不能乱指向。再比如一维数组a[5], 我们在使用它的时候, a+3则表示此时是a[3]的值了;而二维数组a[5][5]中的a+3, 则此时表示值为a[3][0]了, 所以就是地址跨度的不一样。指针一维数组char*a[5], 它相当于是一个二维非指针字符数组结构;指针二维数组char*a[5][5], 它相当于是一个三维非指针字符数组的结构;他们指向下一个的变化的跨度或者步长是不一样的, 要小心使用。

程序中使用指针和数组在本程序中发生地都是同一个错误, 此表如下示:

c语言数组实训 第9篇

【摘要】说明编写同时适合“中职升本”、“专升本”和“高中升本”三种学历层次起点学生的教材的必要性，根据不同起点的学生培养目标不同从而实施多层次差异化教学的需要，教材内容分基础篇、进阶篇和综合篇三篇，不同篇章适合不同学历层次起点的学生。

【关键词】多层次起点 差异化教学 中职升本 立交桥

【基金项目】2015年桂林电子科技大学海洋信息工程学院教育教学改革项目、2015年广西高等教育教学改革项目（2016JGA）、2015年桂林电子科技大学校级教育教学改革（电子与信息工程示范特色专业及实训基地建设专项）。

【中图分类号】G64【文献标识码】A 【文章编号】2095-3089（2016）09-0210-02

0.引言

桂林电子科技大学北海校区自从2013年建立海洋信息工程学院以来，逐步形成了职业教育多层次衔接贯通“立交桥”的应用型技术技能型人才培养模式，在“中职升本”、“专升本”和“高中升本”的多层次起点的学生培养过程中探索分层“因材施教”、“分设目标发展”的培养思路，不断探索专业结构的优化与教学内涵的建设，这其中的一个重要内容就是针对不同层次学生的差异化教学和相应的教材建设。

目前专门针对“中职升本”学生的教材还比较少，传统本科教材并不适合理论基础薄弱的“中职升本”学生使用，本科教学也不宜使用理论深度不够的高职教材，这也使得我们必须加快建设适合“中职升本”学生教材的步伐。

鉴于我院多层次衔接贯通“立交桥”的应用型技术技能型人才培养模式，若每门课的教材均按“中职升本”、“专升本”和“高中升本”三个层次分开建设，将是一件非常麻烦的事情，那么如何编写一本同时适合三种学历层次起点学生的教材呢？本文以C语言程序设计实验实训教材建设为例进行阐述。

1.三种学历层次起点学生的特点

1.1“中职升本”学生的特点

实践动手能力普遍较强，但是未读过高中，理论（特别是英语和数学）基础较弱，缺乏逻辑思维的训练，部分同学主观上虽然在努力学习，但思维不够活跃，跟不上教师讲课和训练思路，这部分学生的培养目标为高级技师。

1.2“专升本”学生的特点

读过高中，计算机相关专业的学生有一定的编程基础，学习程序设计但是专科阶段的学习偏重实践，理论基础相对较弱，这部分学生的培养目标为开发工程师。

1.3“高中升本”学生的特点

一般来说理论基础较好，理解能力相对较强，教师讲过的知识能很快理解并掌握，为“学有余力”类型。但是这部分学生在高中阶段主要是进行理论学习，故实践动手能力相对较弱，这部分学生的培养目标为算法设计、开发工程师。

2.适合三种学历层次起点的C语言程序设计实验实训教材建设

根据多层次差异化教学的需要，教材内容分基础篇、进阶篇和综合篇三篇，不同篇章适合不同学历层次起点的学生，其学习的先后关系如图1所示：

每个实训项目前除了提出实验目的和要求，还对相关知识点进行详细地阐述，并给出相应的例子，使得学生在进一步夯实理论基础的前提下再做实验，并反过来通过实验更好地掌握理论知识。

（1）基础篇

针对初学者，从C语言的基础开始，使略有计算机基础的人都能容易地学会C语言编程，该篇内容对于“中职升本”、“专升本”和“高中升本”三种学历起点的学生均适用。

（2）进阶篇

在原有基础上介绍了C语言的复杂运用，高级编程技巧等，适用于“专升本”和“高中升本”学生。本篇需要学生具备一定的数学基础和逻辑思维能力。

（3）综合篇

从C语言综合实训角度出发，使读者了解使用C语言进行系统设计，游戏开发，图形绘制的相关内容，适用于“高中升本”学生。本篇需要学生具备较好的数学基础和较强的逻辑思维能力。

主要实验实训内容如表1所示：

需要说明的是，每篇内容的适用对象并不是绝对的，仅供教师在教学时进行分层授课有一个参考。教师在给不同学历层次起点学生授课时对学生所掌握的内容可以有相应不同的要求，但是对于三种层次所有学有余力的学生来说，则应多加鼓励，可以引导“中职升本”学生根据自身的接受能力、理解能力主动学习进阶篇和综合篇，也可以引导“专升本”学生根据自身的努力情况及后续学习状态选择综合篇进行学习。

3.结论

c语言数组实训 第10篇

**********一维数组**********

#include

#define n 10

int main()

{

}

int a[n]={1,1},i,j;printf(“%5dn%5d%5dn”,1,a[0],a[1]);for(i=1;i0;j--)a[j]=a[j-1]+a[j];for(j=0;j

**********二维数组**********

#include

int main()

{

int a[30][30]={0},i,j,n=10;

for(i=0;i<=n-1;i++)

a[i][0]=1;

for(i=1;i<=n-1;i++)

for(j=1;j<=i;j++)

a[i][j]=a[i-1][j-1]+a[i-1][j];

for(i=0;i<=n-1;i++)

{

for(j=0;j<=i;j++)

printf(“%5d”,a[i][j]);

printf(“n”);

}

return 0;

深度理解C语言的指针与数组 第11篇

Section 1 左值与右值

编译器为每个变量分配一个地址(左值)，该地址在编译时可知，且变量在运行时一直存于该地址。存于该地址的变量的值(右值)只有在运行时可知。因此，编译器如果需要一个地址来执行某种操作，它可以直接进行操作，如果需要一个变量的值，它需要发出指令从指定地址中读入变量值并存于寄存器中。到这里，可以理解作为一个指针变量，它本身的地址是左值，它变量的值(即指向的地址值)为右值。所以指针首先需要在运行时取得它的当前值，然后才能对它进行解除引用操作。

数组名是一个左值，即内存中的位置。但数组名是一个不可修改的左值，即不可被赋值。

int main()

{

int a[3] = {0};

int b = 1;

a = &b; //ERROR: “=” : 左操作数必须为 l 值。

return 0;

}

Section 2 数组与指针的不同

一个例子：

int main()

{

char arr[4] = “abc”; // Note 1

//char arr[4] = {'a', 'b', 'c', '�'}; // Note 2

char *ptr = “ABC”; // Note 3

//ptr+1 = &arr[2]; // Note 4

printf(“arr: %x, %x, %x %x ”, &arr, &arr[0], &arr[1]); //Note 5

printf(“ptr: %x, %x, %x %x ”, &ptr, &ptr[0], &ptr[1]);

return 0;

}

Note 1&2等价定义，其结构如下：

a b c �

[__] [__] [__] [__]

12fed4 +1 +2 +3

Note 3结构如下

42703c A B C �

[__] [__] [__] [__] [__]

12fec8 42703c +1 +2 +3

Note 4复习一下Section 1.显然的错误，因为p+1首先需要知道p的值(右值)，只有在运行时刻才能得到，编译时刻就希望对其所在的地址进行赋值显然错误，

Note 5验证Note1和3,运行结果如下：

arr: 12fed4, 12fed4, 12fed5

ptr: 12fec8, 42703c, 42703d

可以发现，arr的地址(左值)的结果与数组中首元素的地址一致，而ptr的变量值(右值)与数组的首元素地址一致。

因此对一个数组中的元素进行引用，c=arr[i]和c=ptr[i]都能够取出相应数组中的第i个元素。但要注意这两个操作的过程完全不同：

c = arr[i]; c = ptr[i];

1:取地址12fec8的内容，即42703c

1 取出i的值与12fed4相加 2:取出i的值与42703c相加

2 取地址(12fed4+ i)的内容 3:取地址(42703c+i)的内容

得到结论：尽管c=arr[i]和c=ptr[i]用同样的形式完成了同样的功能，但绝不可以混用。注意数组原始的声明方式，如果原始声明为数组式的，那么对其元素的引用要使用数组形式，反之亦然。

文件1中：