【C语言学习】C语言之数组

---

数组的概念

数组是若干个相同类型的变量在内存中有序存储的集合。

概念理解∶
数组用于存储一组数据
数组里面存储的数据类型必须是相同的
数组在内存中会开辟—块连续的空间

---

提示：

int a[10]//定义了一个整型的数组a，a是数组的名字，数组中有10个元素，每个元素的类型都是int类型，而且在内存中连续存储。
//这十个元素分别是a[0], a[1].... a[9]
//a[0]~a[9]在内存中连续的顺序存储

数组的分类

按元素的类型分类

字符数组
即若干个字符变量的集合，数组中的每个元素都是字符型的变量

char s[10];     //s[0],s[1].….s[9];

短整型的数组

short int a[10]; 

整型的数组

int a[10];   //a[0]~a[9]; 

长整型的数组

 long int a[10];

浮点型的数组（单、双>

float a[6];  
a[4]=3.14f;

double a[8]; 
a[7]=3.115926;

指针数组

char*a[10]

 int*a[10];

结构体数组

struct stu boy[10];

按维数分类

一维数组
int a[30];
类似于一排平房

二维数组
int a[2][30];
可以看成一栋楼房有多层，每层有多个房间，也类似于数学中的矩阵二维数组可以看成由多个一维数组构成的。
有行，有列，
多维数组
int a[4][2][10];
三维数组是由多个相同的二维数组构成的int a[5][4][2][10];

数组的定义

一维数组的定义及其初始化

格式:

数据类型 数组名[数组元素个数];

例:

int a[10]; //定义了一个名为a的数组，数组中每一个元素都是int类型，一共有10个元素
//每一个元素都保存在一个变量中，每一个变呈都是有数组名和数组下标组成的,并且是从0开始的，分别是a[0] a[1] a[2]... a[9]

int b[]={1,2,3};

注意:数组元素的个数在定义的时候也可以不写，但是如果不写，必须初始化(定义的时候赋值)

a、全部初始化

int a[5]={2,4,7,8,5};//代表的意思: a[0]=2;a[1]=4;a[2]=7;a[3]=8;a[4]=5;

b、部分初始化

int a[5]={2,4,3};//初始化赋值不够后面补0
a[0]= 2;a[1]=4;a[2]=3;a[3]=0;a[4]=0;

注意:只能省略后面元素，可以不初始化，不能中间的不初始化

引用方法：
一维数组元素的引用方法
数组名[下标];//下标代表数组元素在数组中的位置，注意从0开始

int a[10];
a[2];

二维数组元素的引用方法:
数组名 [行下标][列下标];

int a[3][4];
a[1][2];

二维数组的定义及其初始化

格式: 数据类型 数组名[行的个数][列的个数];
例如︰

int a[2][4];
//解释:定义一个名为a的二维数组，每一个元素都是int类型这个二维数组中包含两行四列的元素，一共有8个元素二维数组也是连续开辟空间访问元素是行和列都是从0开始，分别是a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1]a[1][2]a[1][3]

注意:二维数组的下标也是可以省略的，但是有条件,行数可以省略，但是列数不能省略

按行初始化:
a、全部初始化

int a[2][2]={[1,2],[4,5]};
//a[0][0]=1; a[0][1]= 2; a[1][0]= 4,a[1][1]=5;

b、部分初始化

int a[3][3]={{1,2},{3,4}}
//a[0][0] = 1;a[0][1]=2;a[1][0]=3;a[1][1]=4;

逐个初始化:
全部初始化:

int a[2][3]={2,5,4,2,3,4};

部分初始化:

int a[2][3]={3,5,6,8};

例1：

#include <stdio.h>

int main(int argc,char *argv[])
{
    //定义一个一维数组
    int a[10];
    //通过sizeof关键字可以获取数组的大小
    printf("sizeof(a) = %d %d \n",sizeof(a),10 * sizeof(int));

    //如果定义数组的同时赋值（初始化），可以不指定数组元素的个数，系统会根据初始化元素个数自动赋值
    int b[] = {10,20,30};
    printf ("sizeof(b)= %d\n",sizeof(b));

    printf ("111111111111111分界线1111111111111111\n");
    //定义一个二维数组
    int c[2][4];
    printf("sizeod(c)=%d %d\n",sizeof(c),2*4*sizeof(int));

    //二维数组的行数可以省略，但是列数不能省略，在初始化时可以这样操作
    //系统会根据列数自动指定行数，最终得到的函数所得到得元素个数移动是列的整数倍

    int d[][4]={1,2,3,4,5,6};

    return 0;
}

例2：

#include <stdio.h>

int main(int argc,char *argv[])
{
    //一维数组的初始化
    //如果不初始化，直接使用会是随机值
    //int a[4];
    //初始化方式1:全部初始化
    //int a[4] = {123，78，666，476};
    //如果是全部初始化，可以不指定数组元素的个数，系统会自动分配
    //int a[]= {10,20,30,40};
    //初始化方式2:局部初始化
    //未初始化后自动补0
    int a[4]={10,20};
    printf("%d\n",a[0]);
    printf ("%d\n",a[1]);
    printf ("%d\n",a[2]);
    printf ("%d\n",a[3]);
    
    return 0;
}

例3：

#include <stdio.h>

int main(int argc,char *argv[])
{
    //二维数组的初始化
    //如果不初始化，直接使用会是随机值
    //int a[2][3];
    //初始化方式1:按行初始化（全部初始化）
    //int a[2][3] = {{123,78,666},{222,5555,476}};
    //局部初始化,没有赋值的位置自动补0
    //int a[2][3]={{11,22},{33}};

    //初始化方式2：逐个初始化
    //全部初始化
    //int a[2][3]= {10,20,30,40,50,60};
    //局部初始化，未初始化的自动补0
    int a[2][3]= {10,20,30};
    printf("%d\n",a[0][0]);
    printf ("%d\n",a[0][1]);
    printf ("%d\n",a[0][2]);
    printf ("%d\n",a[0][3]);
    printf("%d\n",a[1][0]);
    printf ("%d\n",a[1][1]);
    printf ("%d\n",a[1][2]);
    printf ("%d\n",a[1][3]);

    return 0;
}

//c++
#include <iostream>

using namespace std;


int main(int argc,char *argv[])
{
   //一维数组的引用以及一维数组的遍历
   int a[6] ={111,222,333,444,555,666};
   a[3]= 10000;

   //一维数组的遍历
   int i;
   for(i =0; i < sizeof(a) / sizeof(int) ; i++)
   {

       printf ( "a[%d]=%d\n" , i, a[i]);
   }
   printf ( "********************\n" );

   //二维数组的引用以及遍历
    int b[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

     //b[2][0]=666;//修改值
   //二维数组的遍历
    int m,n;
   //外层循环控制行数
    for (m=0;m<3;m++)
     {
        //内层循环控制列数
        for(n=0;n<4;n++)
        {
            printf("%-4d",b[m][n]);
        }
        printf ("\n");
      }
      return 0;
}

2.5.1字符数组的定义

char c1[={‘c’,' ','p','r’,’o’,'g’};
char c2[]="c prog";
char a[][5]={
                  {‘B’,'A’,'S’,'I','C’}，
                  { ‘D’,'B’,’A’,'S’,’E’}
                  };
char a[ ][6]= {“hello”," world”};

字符数组的定义、引用

1.用字符串方式赋值比用字符逐个赋值要多占1个字节,用于存放字符串结束标志‘\0’;
2.上面的数组c2在内存中的实际存放情况为:

注:"\0"是由C编译系统自动加上的
3.由于采用了"\0"标志，字符数组的输入输出将变得简单方便.

#include <stdio.h>

int main(int argc,char *argv[])
{

//定义一个字符数组，通过scanf函数输入字符串并输出结果
//通过赋值""这样的方式可以清除字符数组中的垃圾字符，让每一个元素都是\0
    char ch[32] = "";
//数组名就是当前数组的首地址，所以scanf的第二个参数直接传数组名即可
    scanf ( "%s", ch) ;
    printf("ch = %s\n" , ch);


    return 0;
}