陣列的定義

陣列（Array）是有序的元素序列， 若將有限個型別相同的變數的集合命名，那么這個名稱為陣列名，組成陣列的各個變數稱為陣列的分量，也稱為陣列的元素，有時也稱為下標變數，用于區分陣列的各個元素的數字編號稱為下標，陣列是在程式設計中，為了處理方便， 把具有相同型別的若干元素按有序的形式組織起來的一種形式，這些有序排列的同類資料元素的集合稱為陣列，

一維陣列的創建和初始化

陣列的創建

陣列是一組相同型別元素的集合， 陣列的創建方式：

type_t arr_name [const_n];
//type_t 是指陣列的元素型別
//const_n 是一個常量運算式，用來指定陣列的大小

陣列創建的實體：

//代碼1
int arr1[10];
//代碼2
int count = 10;
int arr2[count];//陣列時候可以正常創建？
//代碼3
char arr3[10];
float arr4[1];
double arr5[20];

注：上面的代碼2，在用 gcc 去編譯這段程式時，是沒有任何問題的，但在vs2019環境下會報以下的錯誤：

是因為在 ISO/IEC9899 標準的 6.7.5.2 Array declarators 中明確說明了陣列的長度可以為變數的，稱為變長陣列（VLA，variable length array），（注：這里的變長指的是陣列的長度是在運行時才能決定，但一旦決定在陣列的生命周期內就不會再變，）
在 GCC 標準規范的 6.19 Arrays of Variable Length 中指出，作為編譯器擴展，GCC 在 C90 模式和 C++ 編譯器下遵守 ISO C99 關于變長陣列的規范，

注意：在我們學習的vs2019環境下，陣列創建， [] 中要給一個常量才可以，不能使用變數，

陣列的初始化

陣列的初始化是指，在創建陣列的同時給陣列的內容一些合理初始值（初始化），

int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

陣列在創建的時候如果想不指定陣列的確定大小就得初始化，陣列的元素個數根據初始化的內容來確定，

注：char型資料是將一個字符常量放到一個字符變數中,并不是把該字符本身放到記憶體單元中去,而是將該字符的相應的ASCII代碼放到存盤單元中，因為b的ASCII碼值是98，所以arr4和arr5所存盤的內容是完全一致的，

對于下面的代碼要區分，記憶體中是如何分配的呢？

char arr1[] = "abc";
char arr2[3] = {'a','b','c'};

arr1以字串的方式初始化，在陣列的結尾會自動添加上’\0’，而arr2的方式則不會，只能自己在初始化的結尾加上’\0’才能完成初始化操作，

一維陣列的使用

對于陣列的使用我們之前介紹了一個運算子： [] ，下標參考運算子，它其實就陣列訪問的運算子， 我們來看代碼：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    //計算陣列的元素個數
    int sz = sizeof(arr)/sizeof(arr[0]);
    //對陣列內容賦值,陣列是使用下標來訪問的，下標從0開始，
    int i = 0;//做下標
    for(i=0; i<10; i++)
    {
        arr[i] = i;
    } 
    //輸出陣列的內容
    for(i=0; i<10; ++i)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

總結:

1. 陣列是使用下標來訪問的，下標是從0開始，
2. 陣列的大小可以通過sizeof運算子計算得到，

int arr[10];
int size =sizeof(arr)/sizeof(arr[0]);

一維陣列在記憶體中的存盤

接下來我們探討陣列在記憶體中的存盤， 看代碼：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}

仔細觀察輸出的結果，我們知道，隨著陣列下標的增長，元素的地址，也在有規律的遞增， 由此可以得出結論：陣列在記憶體中是連續存放的，

二維陣列的創建和初始化

二維陣列的創建

//陣列創建
int arr[3][4];
char arr[3][5];
double arr[2][4];

二維陣列的初始化

//陣列初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

二維陣列的使用

二維陣列的使用也是通過下標的方式， 看代碼：

#include <stdio.h>
int main()
{
	int arr[3][4] = { 0 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			arr[i][j] = i * 4 + j;
		}
	}
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	return 0;
}

運行結果：

二維陣列在記憶體中的存盤

像一維陣列一樣，這里我們嘗試列印二維陣列的每個元素的地址，

#include <stdio.h>
int main()
{
	int arr[3][4];
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}
	return 0;
}

通過結果我們可以分析到，其實二維陣列在記憶體中也是連續存盤的，

陣列作為函式引數

往往我們在寫代碼的時候，會將陣列作為引數傳個函式，比如：我要實作一個冒泡排序函式將一個整形陣列排序， 那我們將會這樣使用該函式：

冒泡排序函式的錯誤設計

//方法1：
#include <stdio.h>
void bubble_sort(int arr[])
{
    int sz = sizeof(arr) / sizeof(arr[0]);//這樣對嗎？
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
int main()
{
    int i = 0;
    int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
    bubble_sort(arr);//是否可以正常排序？
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

運行結果：

可以看出運行結果并沒有符合我們的預期，我們通過除錯可以看bubble_sort 函式內部的sz大小為1，
這是因為函式在傳遞陣列名時，并沒有把整個陣列名傳進去，而傳的是首元素地址，本質上是一個指標，

陣列名是什么？

#include <stdio.h>
int main()
{
    int arr[10] = {1,2，3,4,5};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr);
    //輸出結果
    return 0;
}

運行結果：

結論：

陣列名是陣列首元素的地址，（有兩個例外）

1. sizeof(陣列名)，計算整個陣列的大小，sizeof內部單獨放一個陣列名，陣列名表示整個陣列，
2. &陣列名，取出的是陣列的地址，&陣列名，陣列名表示整個陣列，

除此1,2兩種情況之外，所有的陣列名都表示陣列首元素的地址，

冒泡排序函式的正確設計

當陣列傳參的時候，實際上只是把陣列的首元素的地址傳遞過去了，
所以即使在函式引數部分寫成陣列的形式： int arr[] 表示的依然是一個指標： int *arr ，那么，函式內部的 sizeof(arr) 結果是4，
如果 方法1 錯了，該怎么設計？

//方法2
void bubble_sort(int arr[], int sz)//引數接收陣列元素個數
{
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
int main()
{
    int i = 0;
    int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz);//是否可以正常排序？
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

運行結果：