C语言数组学习

学习环境：xp ，vs 6++

操作符：sizeof可用于求的数组的长度。

用法：数组长度 = sizeof(数组名)/sizeof(数组第一个元素)

一维数组：

1、C语言不允许用变量来指定数组长度

int len = 5;
//int arr[len];//这种用变量来制定数组长度，在C语言中是不允许的，编译不通过
int arr[5];//这样声明数组，表示定义一个指针常量，没有指向任何int型数组，C语言不会给每个元素赋初始值0
printf("%d\n", arr[0]);//由于没有给数组赋初始值，将输出一个不确定的数，输出：-858993460

//int：-858993460（十六进制OXCCCCCCCC）（二进制11001100110011001100110011001100）
//当一个未初始化赋值的时候(至少是vc 下未初始化的内存)默认是0xCCCCCCCC;，他在内存就默认保存为-858993460

for(int i=0; i < sizeof(arr)/sizeof(arr[0]); i++){
printf("第%d个元素值：%d，对应地址：%p\n", i,arr[i], &arr[i]);//每个元素值都是-858993460
}
printf("\n");

输出结果：



2、只给第一个元素赋初始值，后面元素自动初始化为0

int arr1[5] = {6};//只给第一个元素赋初始值，后面元素自动初始化为0
for(int j=0; j < sizeof(arr1)/sizeof(arr1[0]); j++){
printf("第%d个元素值：%d，对应地址：%p\n", j,arr1[j], &arr1[j]);
}

输出结果：



3、定义数组时每个元素都初始化

int arr2[5] = {4,2,-4,6,-10};//定义数组时每个元素都初始化

for(int n=0; n < sizeof(arr2)/sizeof(arr2[0]); n++){
printf("第%d个元素值：%d，对应地址：%p\n", n,arr2
, &arr2
);
}

输出结果：



4、定义数组不指定长度，长度自动计算为3

int arr3[] = {4,2,-4};//定义数组不指定长度，长度自动计算为3
for(int m=0; m < sizeof(arr3)/sizeof(arr3[0]); m++){
printf("第%d个元素值：%d，对应地址：%p\n", m,arr3[m], &arr3[m]);
}

输出结果：



二维数组：

1、定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组

int arr[3][4];//定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组
for(int i=0; i< sizeof(arr)/sizeof(arr[0]); i++){
for(int j=0; j < sizeof(arr[i])/sizeof(arr[i][0]); j++){
printf("%d,", arr[i][j]);//由于为初始化，输出-858993460
}
printf("\n");
}

输出结果：



2、定义二维数组，每个元素都初始化

//定义二维数组，每个元素都初始化
int arr1[3][4]={
{4,6,1,3},
{20,30,3,4},
{-1,5,5,8}
};

for(int m=0; m< sizeof(arr1)/sizeof(arr1[0]); m++){
for(int n=0; n < sizeof(arr1[m])/sizeof(arr1[m][0]); n++){
printf("%d,", arr1[m]
);
}
printf("\n");
}

输出结果：



3、定义二维数组，只初始化一维的部分元素，未初始化的默认为0

int arr2[3][4] = {
{3,6}
};

for(int j=0; j< sizeof(arr2)/sizeof(arr2[0]); j++){
for(int k=0; k < sizeof(arr2[j])/sizeof(arr2[j][0]); k++){
printf("%d,", arr2[j][k]);
}
printf("\n");
}

输出结果：



4、只初始化5个元素，自动将前4位作为一维数组的第一个元素，其他未初始化的默认为0

int arr3[3][4]={
1,6,8,9,4
};

for(int a=0; a< sizeof(arr3)/sizeof(arr3[0]); a++){
for(int b=0; b < sizeof(arr3[a])/sizeof(arr3[a][0]); b++){
printf("%d,", arr3[a][b]);
}
printf("\n");
}

输出结果：



5、连续初始化12个值，自动4个一组作为一维数组的元素

//连续初始化12个值，自动4个一组作为一维数组的元素
int arr4[3][4]={
2,4,7,1,
6,8,2,4,
-1,4,10,5
};
for(int c=0; c< sizeof(arr4)/sizeof(arr4[0]); c++){
for(int d=0; d < sizeof(arr4[c])/sizeof(arr4[c][0]); d++){
printf("%d,", arr4[c][d]);
}
printf("\n");
}

输出结果：



6、定义二维的长度为4，不指定一维的长度，自动计算长度为2

//定义二维的长度为4，不指定一维的长度，自动计算长度为2
int arr5[][4]={
{5},
{10,3,-4}
};
for(int e=0; e< sizeof(arr5)/sizeof(arr5[0]); e++){
for(int f=0; f < sizeof(arr5[e])/sizeof(arr5[e][0]); f++){
printf("%d,", arr5[e][f]);
}
printf("\n");
}

输出结果：



7、必须指定二维的长度，否则编译不通过

//int arr6[2][]={ 4,8 };//这样是不对的，必须指定二维的长度
//int arr6[2][]={	4,8 };//这样是不对的，必须指定二维的长度
/*
//这样是不对的，必须指定二维的长度
int arr6[][]={
{4,5},
{5,6,7}
};
*/

全部代码：ArrayTest1.cpp

#include <stdio.h>

void test1(){
int len = 5;
//int arr[len];//这种用变量来制定数组长度，在C语言中是不允许的，编译不通过
int arr[5];//这样声明数组，表示定义一个指针常量，没有指向任何int型数组，C语言不会给每个元素赋初始值0
printf("%d\n", arr[0]);//由于没有给数组赋初始值，将输出一个不确定的数，输出：-858993460

//int：-858993460（十六进制OXCCCCCCCC）（二进制11001100110011001100110011001100）
//当一个未初始化赋值的时候(至少是vc 下未初始化的内存)默认是0xCCCCCCCC;，他在内存就默认保存为-858993460

for(int i=0; i < sizeof(arr)/sizeof(arr[0]); i++){
printf("第%d个元素值：%d，对应地址：%p\n", i,arr[i], &arr[i]);//每个元素值都是-858993460
}
printf("\n");

int arr1[5] = {6};//只给第一个元素赋初始值，后面元素自动初始化为0
for(int j=0; j < sizeof(arr1)/sizeof(arr1[0]); j++){
printf("第%d个元素值：%d，对应地址：%p\n", j,arr1[j], &arr1[j]);
}

printf("\n");
int arr2[5] = {4,2,-4,6,-10};//定义数组时每个元素都初始化

for(int n=0; n < sizeof(arr2)/sizeof(arr2[0]); n++){
printf("第%d个元素值：%d，对应地址：%p\n", n,arr2
, &arr2
);
}
printf("\n");

int arr3[] = {4,2,-4};//定义数组不指定长度，长度自动计算为3
for(int m=0; m < sizeof(arr3)/sizeof(arr3[0]); m++){
printf("第%d个元素值：%d，对应地址：%p\n", m,arr3[m], &arr3[m]);
}
printf("\n");
}

void test2(){
int arr[3][4];//定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组
for(int i=0; i< sizeof(arr)/sizeof(arr[0]); i++){
for(int j=0; j < sizeof(arr[i])/sizeof(arr[i][0]); j++){
printf("%d,", arr[i][j]);//由于为初始化，输出-858993460
}
printf("\n");
}

//定义二维数组，每个元素都初始化
int arr1[3][4]={
{4,6,1,3},
{20,30,3,4},
{-1,5,5,8}
};

for(int m=0; m< sizeof(arr1)/sizeof(arr1[0]); m++){
for(int n=0; n < sizeof(arr1[m])/sizeof(arr1[m][0]); n++){
printf("%d,", arr1[m]
);
}
printf("\n");
}

//定义二维数组，只初始化一维的部分元素，未初始化的默认为0
int arr2[3][4] = {
{3,6}
};

for(int j=0; j< sizeof(arr2)/sizeof(arr2[0]); j++){
for(int k=0; k < sizeof(arr2[j])/sizeof(arr2[j][0]); k++){
printf("%d,", arr2[j][k]);
}
printf("\n");
}

printf("\n");

//只初始化5个元素，自动将前4位作为一维数组的第一个元素，其他为初始化的默认为0
int arr3[3][4]={
1,6,8,9,4
};

for(int a=0; a< sizeof(arr3)/sizeof(arr3[0]); a++){
for(int b=0; b < sizeof(arr3[a])/sizeof(arr3[a][0]); b++){
printf("%d,", arr3[a][b]);
}
printf("\n");
}
printf("\n");
//连续初始化12个值，自动4个一组作为一维数组的元素
int arr4[3][4]={
2,4,7,1,
6,8,2,4,
-1,4,10,5
};
for(int c=0; c< sizeof(arr4)/sizeof(arr4[0]); c++){
for(int d=0; d < sizeof(arr4[c])/sizeof(arr4[c][0]); d++){
printf("%d,", arr4[c][d]);
}
printf("\n");
}

printf("\n");
//定义二维的长度为4，不指定一维的长度，自动计算长度为2
int arr5[][4]={
{5},
{10,3,-4}
};
for(int e=0; e< sizeof(arr5)/sizeof(arr5[0]); e++){
for(int f=0; f < sizeof(arr5[e])/sizeof(arr5[e][0]); f++){
printf("%d,", arr5[e][f]);
}
printf("\n");
}

printf("\n");

//int arr6[2][]={ 4,8 };//这样是不对的，必须指定二维的长度
//int arr6[][]={	4,8 };//这样是不对的，必须指定二维的长度
/*
//这样是不对的，必须指定二维的长度
int arr6[][]={
{4,5},
{5,6,7}
};
*/
}

main.cpp

#include <stdio.h>

//声明其他源文件里的函数，即声明外部函数
//返回值 函数名(参数类型 形参名1,参数类型 形参名2);
void test1();

void test2();
int main(int argc, char argv[]){
//调用外部函数
test1();
test2();

return 0;
}