一维数组的声明

include
#include
int main(void)
//数组是用于储存多个相同类型数据的集合
{ //格式；类型+数组名+【元素个数】//【】表示声明的是数组变量 空间是连续的
int a[5]; //声明了一个有十个int型元素 的数组 数组的名字是a；a是一个数组类型的变量
//数组名也可以是其他的，标识符是由，字母数字下划线组成的，必须以字母下划线开头
//所有元素都是这个类型，即类型必须相同
//10表示元素的个数，目前必须是整型常数，大小暂时别超过一百四十万字节，不能是0
//新特性，变长数组，个数可以用变量表示，而不是说数组可以变化长度 //int a【n】；n必须是固定的值目前
//支持的编译器不多，所以移植性差一点，还可以放浮点型
system(“pause”); //这里断点，调试，表示这里即将被执行
return 0;
}

一维数组的初始化

include
#include
int main(void)
{
int a[5] = {1, 2, 3, 4, 5}; //初始化元素，定义元素，就初始化多于数组的个数会报错
int b[10] = {1, 2, 3}; //可以初始化部分元素，后面没有指定初始化的数据会自动默认为0
int c[100] = {0};//通常用这个属性初始化整个数组
//初始化部分元素其它都默认为0，把0初始化为第一个元素，其它都默认为0
//int d[8] = {1, 2, 3, [7] = 12}; //初始化指定元素，目前支持的编译器不多，一般支持新版编译器
//第四个元素不写，直接写第七个元素也可以，给指定的元素初始化
int e[] = {1, 2, 3}; //一定要初始化。如果没有初始化，最终数组的元素个数由初始化数据的个数决定

system(“pause”); //这里断点，调试，表示这里即将被执行
return 0;
}

数组的元素访问

include
#include
int main(void)
{ //定义的时候数组名用常量，定义变量老编译器不支持
int a[5] = {2,4,5,8,9}; //变量有类型，代表的就是数组，代表数组的时候5代表元素的个数
int i ;
// //a[0] //元素的访问；数组名+【下标】 方括号里面装的是下标，数组的第一个元素的下标是0开始，第二个是1，数组的个数减一
// //a[1] //前面没有类型，那代表的就是‘一个具体元素的下标’，方括号里面代表具体的元素例如下标1代表第二个元素值是4
// //区别，一个是数组，一个是下标，一个代表元素个数，一个代表具体元素的下标；区分看有没有类型
//
// //printf(“%d, %d, %d, %d, %d\n”, a[0], a[1], a[2], a[3], a[4]);
// //这个输出是上面初始化的元素
//
// ////a[0] = 555;
// ////a[1] = 666;
// ////a[2] = 777;
// ////a[3] = 888;
//
// //scanf(“%d”, &a[2]);
//
for (i = 0; i <= 4; i++ )
{
printf(“%d “, a[i] );// 可以用for循环打印元素
//下标运算可以用变量表示
//分析，执行第一条语句i赋初始值0，在判断第二条语句零小于等于四条件成立，执行代码块，
//此时i是零所以打印的是a[0]的元素，因为上面已经赋过初始值了，就算不打印也是那个值，
//打印只是为了观看，所以a[0]的元素是2，以此类推
//这里输出的是赋值后的元素
}
system(“pause”);
return 0;
}

数组元素的赋值

include
#include
int main(void)
{ //数组名字a是一个常量//a【5】是一个为变量a的数组，数组元素的个数是5，并且这个数组是int型的数组变量
int a[5] = {2, 4, 5, 8, 9}; //这个格式只能定义的时候去用
int j = 2; //可以定义变量，
int g;
printf(“%d, %d, %d, %d, %d\n”, a[0], a[1], a[2], a[3], a[4]);
//这里输出的是初始化的元素,即使没有输出也会被初始化，输出只是为了观看元素下标访问
//printf只是把值输出来看，并不是赋值的过程。
a[0] = 123; //a是数组名，0是下标，元素赋值格式 数组名+【元素下标】 = 0。123赋给了元素1
a[1] = 456; //把456 赋值给了 元素2
a[2] = 789;
a[3] = 555;
a[4] = 666;

scanf(“%d”, &a[0]); //可以输入指定的一个元素
printf(“%d, %d, %d, %d, %d\n”, a[0], a[3-j], a[1+1], a[5-2], a[4]);//可以是整型表达式运算，注意不能越界
//这里输出的是赋值后的元素
//printf只是把值输出来看，并不是赋值的过程。所以即使不输出也会被赋值

for(g=0;g<=4;g++) //可以用循环来打印输出的元素
{
printf(“%d, “,a[g]);//解析，g=0的意思是元素的下标0，g<=4；g++的意思是条件成立打印从0~4的对应元素
}
//scanf(“%d”, &a[4]); //先输出循环中的元素
//然后再用scanf，需要在下面再来一个printf才能看见scanf所输入的值
//printf(“%d”,a[4]);
system(“pause”);
return 0;
}

一维数组的地址

include
#include
int main(void)
{
//double改成这个就会变成八字节一个元素
int a[5] = {3, 5, 6, 8, 9};
//每个元素都是一个int类型，一个int型的大小为4字节，有五个元素,这个数组的大小是20个字节
printf(“%d\n”,sizeof (a));
//sizeof操作符以字节形式给出了其操作数的存储大小。

printf(“%d, %d, %d, %d, %d\n”, a[0], a[1], a[2], a[3], a[4]);

printf(“%p, %p, %p, %p, %p\n”, &a[0], &a[1], &a[2], &a[3], &a[4]); //以十六进制输出，取地址要加取地址符&
printf(“%d, %d, %d, %d, %d\n”, &a[0], &a[1], &a[2], &a[3], &a[4]);//以十进制输出，取地址要加取地址符&

printf(“%d, %d, %d\n”, &a[0], &a[0]+1, &a[2]);
//通过a[0]知道a[1]的地址，&a[0]+1 就得到了a[1]的地址，下一个元素的地址
//地址+1加的是一个类型的大小4，加减加减法运算，都可以。叫做地址偏移

//&a，代表的是数组，a[0]代表的是元素
printf(“%d, %d\n”, &a, &a+1); //&a数组的地址；与元素1重名了，&a+1，则是下一个数组的地址了
//printf(“%d\n”, &a[0]); //差值是4，4是四个字节，一个字节对应一个地址
//a == &a[0] //数组名和数组的首元素的地址是相同的，在实际应用中也是等价的。但类型不一样。
system(“pause”);
return 0;
}

二维数组的声明

include
#include
int main(void)
{
//int b[3]; 是3个元素的数组，每个元素都是一个整型。元素的类型可以是C语言数据类型的任意一种类型，比如说double型,指针类型
//一个一维数组的元素又是一个小的一维数组，一维数组的一维数组就是二维数组。
//{ {1,2},{3,4},{5,6}}
int a[3][2]; //二维数组是两个[],同理十维数组就是十个[]; a代表数组的名字
//前边的三表示，大数组里面，有3个小的一维数组，2表示每个小的一维数组里面有两个元素。里面的小数组元素的个数必须是一样的
//比如说第一个小数组里面是五个元素，那个它后面的小数组都是五个元素，int表示每个小数组里面的元素是整型
//元素的个数是 == 2 3。同理二维数组的大小== 3 2 * 类型
printf(“%d”, sizeof(a)); //sizeof(a)
system(“pause”);
return 0;
}

二维数组的初始化

include
#include
int main(void)
{
int b[3][2] = { {7,8}, {5,2},{4,1}};
int c[3][2] = { {7,8}, //可以 以行列的方式来表示，行列式，便于理解，这个数组对应的3是行数2是列数，但数组本身是线性的
{5,2},
{4,1}};
int a[3][2] = {{1,2},{3,4}}; //可初始化部分元素，初始化两组,未指定元素默认是0
int d[3][2] = {{1},{3,4}}; //只初始化大数组里的小数组里的一个元素，另一个元素也会默认为0
int e[3][2] = {1,2,3,4,5}; //可以不加花括号，第一个对应的大数组里面是1，2第二个是3，4第三个是5，0
int f[][2] = { {7, 8, 5}; //第一个行的元素个数可以省略，但是必须是在初始化的时候，否则会报错

printf(“%d”, sizeof(b));//sizeof操作符以字节形式给出了其操作数的存储大小。
system(“pause”);
return 0;
}

二维数组的地址

include
#include
int main(void)
{
int a[3][2] = {{1,2},{3,4},{5,6}};

printf(“%d, %d, %d, %d, %d, %d\n”, &a[0][0], &a[0][1], &a[1][0], &a[1][1], &a[2][0], &a[2][1]);
printf(“%d, %d, %d\n”, &a[0], &a[1], &a[2]);
printf(“%d\n”, &a);
printf(“%d\n”, &a[3][2]);
system(“pause”);
return 0;
}

二维数组的赋值

include
#include
#include
int main(void)
{
int a[5] = {0,4,7,5,6};
int b[5];
int c[2];
int i;
for (i = 0; i < 5; i++)
{
b[i] = a[i]; //元素可以用i表示，条件成立，打印a[0] = b[0],以此类推就依次把数组a[5]赋值给了b[5]
}
//printf(“%d”, b[i]);
for (i = 0; i <= 4; i++)
{
printf(“%d\n”, b[i]);
}
for (i = 0; i < 2 ; i++)
{
c[i] = a[i+2]; //利用表达式的运算，就可以得到自己指定的几个元素
}
for (i = 0; i <= 1; i++)
{
printf(“%d “, c[i]);
}
//（menmekaopi）内存拷贝函数 //sizeof操作符以字节形式给出了该操作数的字节大小，int的字节是4字节
memcpy(b, a, sizeof(int)5); //第一个参数添要被赋值的数组，第一个参数添b，第二个数值添a，将a的数值赋值到b里面
//第三个是赋值多少内容，按字节算
//a和b都是数组名字，数组名是元素的首地址
memcpy(&b[0], &a[0], sizeof(int)5); //这个是最本质的写法
//数组名的地址和首元素的地址是一样的，意义也是一样的，实际应用中也是一样的，只是类型不一样。
//那就可以实现一个这样的功能，将数组a的指定元素赋值给b，如下。
memcpy(&b[0], &a[2], sizeof(int)*2);
//将数组a的元素5，6赋值给b，注意字节得换成相应的字节，不然就会越界赋值
//不能用数组名直接去赋值，因为数组名是常量，a=b，常量之间不能进行赋值，左操作数必须为左值
printf(“\n%d %d\n”, b[3], b[4]);
system(“pause”);
return 0;
}

二维数组的赋值2

include
#include
#include
int main(void)
{
int a[3][2] = {1,2,3,4,5,6};
int b[3][2];
int i;
memcpy(&b[0][0], &a[0][0], sizeof(int)6); //注意字节, 个数要控制好, 别越界
/for(i = 0; i <= 7; i++)
{
printf(“%d “, &b);
}*/
system(“pause”);
return 0;
}

多维数组

include
#include
int main(void)
{
int a[2][3][4] = {{{1,1,1,1},{1,2,3,4},{1,2,3,4}},{{1,2,3,4},{1,2,3,4},{1,2,3,4}}}; //三维数组的定义和初始化
//a[0][0][0] //下标是从零开始的
//000 001 002 003 //010 011 012 013 //020 021 022 023
//100 101 102 103 //110 111 112 113 //120 121 122 123

system(“pause”);
return 0;
}

数组的声明

int a[5];
1、格式；类型+数组名+【元素个数】//【】表示声明的是数组变量 空间是连续的
2、声明了一个有十个int型元素 的数组 数组的名字是a；a是一个数组类型的变量
3、数组名也可以是其他的，标识符是由，字母数字下划线组成的，必须以字母下划线开头
4、所有元素都是这个类型，即所有的元素类型必须相同。

一维数组的初始化

int a[5] = {1, 2, 3, 4, 5}; //初始化元素，定义元素，就初始化多于数组的个数会报错
int b[10] = {1, 2, 3}; //可以初始化部分元素，后面没有指定初始化的数据会自动默认为0
int c[100] = {0};//通常用这个属性初始化整个数组 各元素都初始化为零
int d[8] = {1, 2, 3, [7] = 12}; //初始化指定元素，目前支持的编译器不多，一般支持新版编译器，第四个元素不写，直接写第七个元素也可以，给指定的元素初始化
int e[] = {1, 2, 3}; //一定要初始化。如果没有初始化，最终数组的元素个数由初始化数据的个数决定。

数组的元素访问

int a[5] = {2,4,5,8,9}; //变量有类型，代表的就是数组，代表数组的时候5代表元素的个数
int i ;
a[0] //元素的访问；数组名+【下标】 方括号里面装的是下标，数组的第一个元素的下标是0开始，第二个是1，数组的个数减一
a[1] //前面没有类型，那代表的就是‘一个具体元素的下标’，方括号里面代表具体的元素例如下标1代表第二个元素值是4
区别，一个是数组，一个是下标，一个代表元素个数，一个代表具体元素的下标；区分看有没有类型
可定义一个循环变量来打印各元素的值 可用 a[i] 表示 i再自增 就是各元素的下标打印了

数组元素的赋值

int a[5] = {2, 4, 5, 8, 9};
数组名字a是一个常量//a【5】是一个为变量a的数组，数组元素的个数是5，并且这个数组是int型的数组变量
懒得写。

一维数组的地址
二维数组的声明
二维数组的初始化
二维数组的地址
放组
二维数组的赋值
个数:
二维数组的赋值2
头
多维数组**