C語言中數組的介紹及使用

這篇文章主要講解了“C語言中數組的介紹及使用”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“C語言中數組的介紹及使用”吧！

目錄

• 數組

• 一維數組

• 初始化

• 使用

• 總結：

• 內存存儲

• 二維數組

• 創建

• 初始化

• 數組越界問題

• 數組作函數參數

• 應用實例

  
  

數組

一維數組

創建 定義

數組是一組相同類型的元素的集合。那數組的語法形式：

type_t arr_name [const_n]
//如：
int arr[10];

type_t 指的是數組元素的類型。

const_n 指的是一個常量表達式，用來指定數組的大小。

此時運行程序的話，系統會報一個警告：未初始化變量。打開調試就會發現系統默認填入一些無意義的數據。

當然全局數組的話，系統默認初始化為0；

int arr[10];// 0 0 ... 0
int main(){
  return 0;
}

創建實例

//1.	
int arr[10];
//2.
int count = 10;
int arr2[count];//這樣的創建數組可不可以呢？
//3.
float arr3[20];//浮點型數組
char ch[10];

數組的創建必須要[]使用常量，不能使用變量。（ps：雖然C99支持變長數組，但一般用常數創建就已經夠用了）同樣，我雖然用const_n表示常量，但可千萬不要誤會為const修飾的變量哦。

為什么呢？

因為數組控制不好容易越界訪問非法內存，用變量的話風險太大，所以一直以來都是用常量創建數組的。

初始化

初始化，顧名思義，在創建數組的同時給予一些合理的初識值。如：

int arr[10] = { 1,2,3 };//不完全初始化

這種是不完全初始化，剩余的元素默認是0

int arr2[] = { 1,2,3,4 };//利用初始化內容，指定數組大小

這種是省略數組的const_n常量表達式

由初始化內容指定數組的大小

那下面這三個有什么不同呢？

第一種是用字符串初始化數組，字符串有\0作為結束標志，雖不算字符串內容，但是可以說是字符串與生俱來的，所以它也被初始化作為數組內容。a b c \0

第二種和第三種是一樣的，因為數組元素類型是字符型，且字符'b'的ACSII碼值是98，自動將98解析為字符。a b c

使用

數組的訪問是通過下標來訪問的，默認下標是從0開始。通過下標引用操作符[]我們可以訪問到數組元素。

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//數組的下標是從0開始的0~9
int sz = sizeof(arr) / sizeof(arr[0]);//10
for (int i = 0; i < sz; i++)
{
    printf("%d ", arr[i]);
}
//1 2 3 4 5 6 7 8 9 10

對于sizeof操作符，sizeof(arr)，即sizeof+數組名，指的是計算整個數組的大小，算出來是40，然后sizeof(arr[0])是計算數組首元素的大小為4，這樣一除就是元素個數啦。

使用變量sz，可以靈活的改變數組的大小，就不用再更改循環條件了。

總結：

• 數組是通過下標訪問的，下標從0開始

• 數組的大小可以通過計算得到

內存存儲

通過printf("&arr[%d]=%p\n", i,&arr[i]);這樣的語句我們可以看到該數組在內存中的存儲情況。

很明顯的是，數組在內存中是連續存放的。

右邊是十六進制的內存編號，可以看見每一個元素之間都相差4個字節，而一個整型元素正好占4個字節。

所以數組在內存中是連續存放的，隨著數組下標的增長，地址也在增長，這也正是為什么指針變量+1，可以訪問到下一個數組元素。

所以數組的本質是什么？

一組內存中連續存放的相同類型的元素。

二維數組

創建

type_t arr_name[const_n][const_n]
//
int arr[3][5];//3行5列
char ch[4][7];//4行5列
double arr2[2][4]//2行4列

如上述代碼所示：二維數組的語法結構就是，類型+數組名+[行][列]。

如圖所示，二維數組在理解上就是這樣的3行5列類似于表格的東西。就像線性代數里的矩陣，矩陣的定義就是一組數組成數表。

初始化

//1.
int arr1[3][5] = { 1,2,3,4,5,6,7,8,9,10,11 };
//2.
int arr2[3][5] = { {1,2},{3,4},{5,6,7} };

第一種初始化，先一行一行填入，第一行是1 2 3 4 5，第二行是6 7 8 9 10，第三行不夠就補零11 0 0 0 0 。第二種的話，把每一行看成一個一維數組，不夠的話還是補零，即第一行1 2 0 0 0，第二行3 4 0 0 0，第三行5 6 7 0 0 。

char ch2[2][4] = { 'a','b' };
char ch3[2][4] = { {'a'},{'b'} };
char ch4[3][4] = { "abc","def","gh" };

當然用字符串去初始化二維數組的話，也是需要注意\0的問題。

第一行：a b c \0；第二行：d e f \0；第三行：g h \0 0

省略

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

像這樣省略行可以，但是不能省略列。

行數可以根據初始化內容來規定，但如果列省略了就會造成歧義。

當然，省略必須在已經初始化的前提之下，不然行和列一概不知，怎么分配空間呢？

使用

當然二維數組同樣是用下標訪問數組內容的，也是從0開始。如：

我們要去訪問這個二維數組的話，我們當然是用兩次循環遍歷這個數組。

內存存儲

當然我們也可以用同樣的辦法打印出每個元素的地址，如：

我們還是能發現每一個元素都是在內存中連續存放的。

這樣的話，二維數組在內存中的存儲形式便是大家想象中的二維的形式，把每一行理解為一個一維數組，這樣的話二維數組在內存中的存儲形式還是一維的。如下圖的對比：

從這里我們也可以理解到，二維數組的初始化里，為什么可以省略行不能省略列。

把行省略了，但是我們知道列，一個一個填滿就是了，能填到多少行就有多少行。

理解方式

對于二維數組，我們可以理解為每一行為一個元素的一維數組，該一維數組的每一個元素又是一個一維數組。

如數組arr[3][5] ，是有3個元素的一維數組，每個元素是一個有5個元素的一維數組。

指向二維數組的指針+1，指向的是下一行。

對于二維數組在內存存儲形式的理解還是很重要的，有了這樣的思想，我們就可以通過指針遍歷得到數組元素，如：

int arr[3][5] = { {1,2,3},{4,5,6},{7,8} };
int* p = &arr[0][0];
for (int i = 0; i < 15; i++)
{
    printf("%d ", *p++);//1 2 3 0 0 4 5 6 0 0 7 8 0 0 0
}

數組越界問題

定義

數組通過下標訪問，那么下標也就可以控制數組的訪問范圍。在數組前后進行訪問的話，就是非法訪問內存，即數組越界。

//1 2 3 4 5 -858993460
int arr[5] = { 1,2,3,4,5 };
for (int i = 0; i <= 5; i++)//越界訪問到第6個
{
    printf("%d ", arr[i]);
}

數組越界訪問到最后一個元素之后的一塊內存，這就屬于越界訪問，-858993460是vs2019自動生成的隨機值。

一般編譯器是不會去檢查數組越界訪問的情況（vs2019太先進），所以我們就要有意識的主動檢查。如果編譯器提示這樣的錯誤信息，那么一般就是數組越界了：

數組作函數參數

在寫代碼時，我們經常會將數組作為參數，比如接下來的兩個應用實例，那么我們這里以冒泡排序的實現作為案例。

排序算法一般有四種：冒泡排序、選擇排序、插入排序和快速排序。

冒泡排序的核心思想：兩兩相鄰的元素進行比較。

• 一趟冒泡排序搞定一個數字，讓其來到最終的位置上。

• n n n 個元素，則總共需要 n ? 1 n-1 n?1 趟冒泡排序，每一趟排序需要進行 n ? 1 ? i n-1-i n?1?i 次判斷大小。

如分析圖所示：

void Print(int* arr, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *arr++);
	}
}
void Sort(int arr[],int sz)//int* arr
//數組作形參本質是指針
{
	//int sz = sizeof(arr) / sizeof(arr[0]);//err//用指針的sizeof值除以另一個值 = 4 / 4 = 1
	for (int i = 0; i < sz - 1; i++)//n-1趟
	{
		for (int j = 0; j < sz - 1 - i; j++)//n-1-i次
		{
			if (arr[j] > arr[j + 1])//目標升序
			{
				//交換
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 1,4,6,3,7,9,3,2,8,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//數組名單獨放在sizeof中，表示整個數組
	//排序
	Sort(arr,sz);
	//打印
	Print(arr,sz);
	return 0;
}

1.定義數組作形參時，本質上是指針。

void Sort(int *arr,int sz)本質上就是void Sort(int arr[],int sz)

所以Sort()函數內，sizeof(arr)也算的就是指針arr的大小，所以只能傳參進去。

2.數組名arr何時代表整個數組何時代表數組首元素地址呢？

• 代表整個數組的情況：

單獨放在sizeof操作符內部時，如sizeof(arr); 。

寫出&arr時，代表的是整個數組，但表面仍為首元素地址。

• 代表首元素地址的情況：

除上面兩以外其他都是代表首元素的地址。

感謝各位的閱讀，以上就是“C語言中數組的介紹及使用”的內容了，經過本文的學習后，相信大家對C語言中數組的介紹及使用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！