C语言数组(初阶)

1.数组

一次性定义多个相同类型的变量，并存储到一片连续的内存中

存储100个int类型的整数:

以前想到办法:  定义变量比较耗时, 后续引用比较麻烦
int i1=0;
int i2=1;
int i3=2;
...........

利用数组的方式去进行存储:
int array[100] = {0};   


int array[100] 解释:
int  : 数组中每个空间都是存储int类型数据
array: 变量名[数组名], 即使申请连续内存的名字
[100]: 数组申请的连续空间，平均分为100等份

变量类型: int [100]
变量名  : array

1.1.定义

  

 语法:  数据类型 变量名[数组项数];
 例子:  定义一个可以存储100个字符的空间。
        char array[100];
            
        定义一个可以存储50个整型的空间。
        int array[50];

1.2.引用

   概念:   对数组中的每一项数据进行使用[赋值]
   语法:   数组名[ 下标] = 值;        //下标： 每一项的编号
            
    int  array[5] = { 99, 100, 101, 102, 103};
    
    array[0];        --> 存储数值99
    array[1];        --> 存储数值100
    array[2];        --> 存储数值101
    array[3];        --> 存储数值102
    array[4];        --> 存储数值103
    array[5];        --> 因为数组，只有5项数据， 下标0~4

1.3.初始化

概念:    给数组的每一项赋一个固定的初始值
            [因为没有给初始值的时候，每一项都是随机数]
            
例子:
整体初始化:  只能在数组定义时才可以进行;
   
数据类型 变量名[数组项数] = {数值1, 数值2, 数值3, ... };
        int array[5]   = { 0, 1, 2, 3, 4};    //给每一项数据赋值一个值
        
特殊整体赋值
        缺省初始化
        int array[100] = { 0};                //把数组中的每一项赋值为0
            
先定义，再初始化的解决方法:
        int  array[100];
        for( int i = 0 ; i < 100 ; i++)
        {
            array[i] = 0;
        }

错误:
            int array[100];
            array[100] = {0};        //因为数组只有100项，标号0~99， 没有第100项空间，所以错的
            

        
1.4.字符数组

作用: 用来进行存储字符的数组

定义： char 数组名[ 数组项数] = {0};

字符序列 :
        char s1[5] = {'a', 'b', 'c', 'd', 'e'};       // s1存放的是字符序列，非字符串, printf()函数可能会出现的现象-乱码
        

1.5.字符串    

写法1 :  char s2[6] = {'a', 'b', 'c', 'd', 'e', '\0'};   // s2存放了一个字符串    
        写法2 :  char s2[6] = {'a', 'b', 'c', 'd', 'e'};
        写法3 :  char s2[6] = {"abcde"};                 //等价于写法2
        写法4 :  char s2[6] = "abcde";                   //等价于写法2

1.6.缺省数组

作用:   定义数组的项数由实际赋值的数据个数决定， 在编译时已经决定了数组的项数，后续项数就不能重新更改。
定义:
        int array[ ] = { 99, 100, 101, 102, 103, 104, 105};        //赋了7个数值,所以改数组一共有7项。

        错误:
        int array[ ];        //明显错误, 第一个数组项数没有确定, 第二个没有赋值
        
        特殊写法:
        char array[] = "hello world";

2.二维数组

2.1引用

     int a[2][3];
        a    :  数组名, 整个二维数组
        a[0]:  a数组中的第0个一维数组
        a[1]:  a数组中的第1个一维数组
        a[2]:  错误的引用方法
        a[0][0]: a数组中的第0个一维数组中的第0项数据
        a[0][1]: a数组中的第0个一维数组中的第1项数据
        a[0][2]: a数组中的第0个一维数组中的第2项数据
        a[0][3]: a数组中的第1个一维数组中的第0项数据 
        这种引用下一个数组中数据的写法可以用, 但是少用

        a[1][0]: a数组中的第1个一维数组中的第0项数据    
        a[1][1]: a数组中的第1个一维数组中的第1项数据
        a[1][2]: a数组中的第1个一维数组中的第2项数据
        a[1][3]: a数组中的第1个一维数组中的第0项数据
        

2.2初始化

    完全初始化：
        int a[2][3] = { {0, 1, 2} , { 3, 4, 5} };    
        int a[2][3] = { 0, 1, 2, 3, 4, 5};        等价于上面的写法
        
     不完全初始化:
        int a[2][3] = { {0, 1} , { 3}}            //正确：  只初始化a[0][0],a[0][1],a[1][0]这三项的数据, 其他没有赋值的项由系统自动赋值为0
        int a[2][3] = { 0, 1, 3};                //        只初始化a[0][0],a[0][1],a[0][2]这三项的数据, 其他没有赋值的项由系统自动赋值为0
        int a[2][3] = {0};                        //每一项都初始化为0

  2.3  缺省的二维数组

        int a[][3] = { 0, 1, 2};                //等价于a[1][3];
        int a[][3] = { 0, 1, 2, 3};                //等价于a[2][3];
        int a[][3] = { {0, 1} , {3}};            //等价于a[2][3];

        int a[][]  = { {0, 1} , {3}};            //错误的写法,
                              二维数组中的一维数组长度必须要确定