c語法7 - 數組與字符串

概述

定義：把具有相同類型的若干變量按有序形式組織起來稱為數組。

C語言數組屬于構造數據類型。一個數組可以分解為多個數組元素，這些數組元素可以是基本數據類型或是構造類型。因此按數組元素的類型不同，數組又可分為數值數組、字符數組、指針數組、結構數組等各種類別。

一維數組

數組的概念和定義

我們知道，要想把數據放入內存，必須先要分配內存空間。放入4個整數，就得分配4個int類型的內存空間：

int?a[4];

這樣，就在內存中分配了4個int類型的內存空間，共 4×4=16 個字節，并為它們起了一個名字，叫a。

我們把這樣的一組數據的集合稱為數組(Array)，它所包含的每一個數據叫做數組元素(Element)，所包含的數據的個數稱為數組長度(Length)，例如int a[4];就定義了一個長度為4的整型數組，名字是a。

數組中的每個元素都有一個序號，這個序號從0開始，而不是從我們熟悉的1開始，稱為下標(Index)。使用數組元素時，指明下標即可，形式為：

arrayName[index]

arrayName 為數組名稱，index 為下標。例如，a[0] 表示第0個元素，a[3] 表示第3個元素。

接下來我們就把第一行的4個整數放入數組：

a[0]=20;
a[1]=345;
a[2]=700;
a[3]=22;

這里的0、1、2、3就是數組下標，a[0]、a[1]、a[2]、a[3] 就是數組元素。

下列實現一個輸入多個數字，并存入數組輸出：

#include?
int?main(){
????int?nums[10];
????int?i;
????//從控制臺讀取用戶輸入
????for(i=0;?i<10;?i++){
????????scanf("%d",?&nums[i]);?
????}
????//依次輸出數組元素
????for(i=0;?i<10;?i++){
????????printf("%d?",?nums[i]);
????}
????return?0;
}

數組的定義方式：

dataType??arrayName[length];

dataType 為數據類型，arrayName 為數組名稱，length 為數組長度。例如：

char?ch[9];??//定義一個長度為?9?的字符型數組
float?m[12];??//定義一個長度為?12?的浮點型數組char?ch[9];??//定義一個長度為?9?的字符型數組

需要注意的是：

數組中每個元素的數據類型必須相同，對于int a[4];，每個元素都必須為 int。

數組長度 length 最好是整數或者常量表達式，例如 10、20* 4 等，這樣在所有編譯器下都能運行通過；如果 length 中包含了變量，例如 n、4*m 等，在某些編譯器下就會報錯

訪問數組元素時，下標的取值范圍為 0 ≤ index < length，過大或過小都會越界，導致數組溢出，發生不可預測的情況

數組內存是連續的

數組是一個整體，它的內存是連續的；也就是說，數組元素之間是相互挨著的，彼此之間沒有一點點縫隙。下圖演示了int a[4];在內存中的存儲情形：「數組內存是連續的」這一點很重要，所以我使用了一個大標題來強調。連續的內存為指針操作(通過指針來訪問數組元素)和內存處理(整塊內存的復制、寫入等)提供了便利，這使得數組可以作為緩存(臨時存儲數據的一塊內存)使用。大家暫時可能不理解這句話是什么意思，等后邊學了指針和內存自然就明白了。

數組的初始化

上面的代碼是先定義數組再給數組賦值，我們也可以在定義數組的同時賦值，例如：

int?a[4]?=?{20,?345,?700,?22};

數組元素的值由{ }包圍，各個值之間以,分隔。

對于數組的初始化需要注意以下幾點：

可以只給部分元素賦值。當{ }中值的個數少于元素個數時，只給前面部分元素賦值。例如：

int?a[10]={12,?19,?22?,?993,?344};

表示只給 a[0]~a[4] 5個元素賦值，而后面 5 個元素自動初始化為 0。

當賦值的元素少于數組總體元素的時候，剩余的元素自動初始化為 0：

• 對于short、int、long，就是整數 0；
• 對于char，就是字符 '\0'；
• 對于float、double，就是小數 0.0。

我們可以通過下面的形式將數組的所有元素初始化為 0：

int?nums[10]?=?{0};
char?str[10]?=?{0};
float?scores[10]?=?{0.0};

由于剩余的元素會自動初始化為 0，所以只需要給第 0 個元素賦值為 0 即可。

只能給元素逐個賦值，不能給數組整體賦值。例如給 10 個元素全部賦值為 1，只能寫作：

int?a[10]?=?{1,?1,?1,?1,?1,?1,?1,?1,?1,?1};

而不能寫作：

int?a[10]?=?1;

如給全部元素賦值，那么在定義數組時可以不給出數組長度。例如：

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

等價于

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

可以使用數組輸出一個4x4的矩陣

#include?
int?main(){
????int?a[4]?=?{1,?2,?3,?4};
????int?b[4]?=?{5,?6,?7,?8};
????int?c[4]?=?{9,?10?,11,?12};
????int?d[4]?=?{13,?14,?15,?16161616};
????printf("%-9d?%-9d?%-9d?%-9d\n",?a[0],?a[1],?a[2],?a[3]);
????printf("%-9d?%-9d?%-9d?%-9d\n",?b[0],?b[1],?b[2],?b[3]);
????printf("%-9d?%-9d?%-9d?%-9d\n",?c[0],?c[1],?c[2],?c[3]);
????printf("%-9d?%-9d?%-9d?%-9d\n",?d[0],?d[1],?d[2],?d[3]);
????return?0;
}

數組元素逆序

#include

int?main(void){
?int?arr[]?=?{1,?6,?7,?5,?9,?4,?3};
?int?i?=?0;?//?數組首元素下標
?int?j?=?sizeof(arr)/sizeof(arr[0])?-?1;?//數組最后一個元素下標
?int?temp?=?0;
?//打印原始數組
?for?(size_t?m?=?0;?m?sizeof(arr)?/?sizeof(arr[0]);?m++){
??printf("%d?",?arr[m]);
?}
?printf("\n");
?
?while(i???temp?=?arr[i];
??arr[i]?=?arr[j];
??arr[j]?=?temp;
??i++;??j--;
?}
?for?(size_t?n?=?0;?n?sizeof(arr)?/?sizeof(arr[0]);?n++){
??printf("%d?",?arr[n]);
?}
?printf("\n");
?return?0;
}

sizeof(arr)獲取到所有的數組元素的下標，而sizeof(arr)/sizeof(arr[0]) - 1獲取到最后一位的元素下標

通過for循環打印數組

while進行數組前后元素的交換，并向中間遞進。

冒泡排序

1、比較相鄰的元素。如果第一個比第二個大(小)，就交換他們兩個。

2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大(小)的數。

3、針對所有的元素重復以上的步驟，除了最后已經選出的元素(有序)。

4、持續每次對越來越少的元素(無序元素)重復上面的步驟，直到沒有任何一對數字需要比較，則序列最終有序。

#include?

int?main(void){
?
?int?guo[]?=?{?4,554,48,49,487,56,12};
?int?n?=?sizeof(guo)?/?sizeof(guo[0]);?//數組元素個數
?int?temp?=?0;?//臨時變量
?
?for?(size_t?i?=?0;?i?-1;?i++){??//?控制行
??for?(size_t?j?=?0;?j?-1-i;?j++?){?//?控制內層列
???if(guo[j]?>?guo[j+1]){
????temp?=?guo[j];
????guo[j]?=?guo[j+1];
????guo[j+1]?=?temp;
???}
??}
?}
????for?(size_t?i?=?0;?i??????printf("%d?",?guo[i]);
?}
?printf("\n");
?return?0;
}

二維數組

二維數組概念與形式

二維數組定義的一般形式是：

dataType?arrayName[length1][length2];

其中，dataType 為數據類型，arrayName 為數組名，length1 為第一維下標的長度，length2 為第二維下標的長度。

我們可以將二維數組看做一個 Excel 表格，有行有列，length1 表示行數，length2 表示列數，要在二維數組中定位某個元素，必須同時指明行和列。例如：

int?a[3][4];

定義了一個 3 行 4 列的二維數組，共有 3×4=12 個元素，數組名為 a，即：

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[2][0],?a[2][1],?a[2][2],?a[2][3]

如果想表示第 2 行第 1 列的元素，應該寫作 a[2][1]。

也可以將二維數組看成一個坐標系，有 x 軸和 y 軸，要想在一個平面中確定一個點，必須同時知道 x 軸和 y 軸。

二維數組在概念上是二維的，但在內存中是連續存放的；換句話說，二維數組的各個元素是相互挨著的，彼此之間沒有縫隙。那么，如何在線性內存中存放二維數組呢？有兩種方式：

• 一種是按行排列， 即放完一行之后再放入第二行；
• 另一種是按列排列， 即放完一列之后再放入第二列。

在C語言中，二維數組是按行排列的。也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 個元素也是依次存放。數組 a 為 int 類型，每個元素占用 4 個字節，整個數組共占用 4×(3×4)=48 個字節。

你可以這樣認為，二維數組是由多個長度相同的一維數組構成的。

二維數組初始化

常規初始化

int?arr?[3][5]?=?{{?2,?3,?54,?56,?7?},{2,?67,?4,?35,?9},?{1,?2,?3,?4,?5}}

不完全初始化

int?arr[3][5]?=?{{2,?3},{2,?3,?4},{1,?2,?3,?4}}

未被初始化的賦值為0

int?arr[10]?=?0;
則該10個元素均被賦值為0

同理

二維數組也可賦值為0

int?arr[10][5]?=?{0}

此時獲取到50個0組成的二維數組

系統自動分配行列

int?arr[3][5]?=?{1,2,3,4,5,6,7}

無法使用下列形式的定義**

int?arr[][]?=?{{1,2,3},{4,5,6}}

二維數組必須指定列值，可以不使用行值

int?arr[][4]?=?{1,?3,?4,?6,?7};

輸出

1 ? 3

4 ? 6

7 ? 0

打印二維數組

#include

int?main(void){
????int?arr[5][3]?=?{?{1,2,3},
?????????{4,5,6},
?????????{7,8,9},
???????{10,11,12},
???????{13,14,15}?};
????int?arr2[3][5]?=?{
?????????{1,2,3,4,5},
??????{6,7,8,9,10},
??????{11,12,13,14,15}};
????printf("第一個數組打印\n");
????for(size_t?i?=?0;i?sizeof(arr)/sizeof(arr[0]);?i++){
?????for?(size_t?j?=?0;?j?sizeof(arr[i])/sizeof(arr[i][0]);j++){
??????printf("%d?",arr[i][j]);
??}
??printf("\n");
?}
?printf("第二個數組打印\n");
??for(size_t?i?=?0;i?sizeof(arr2)/sizeof(arr2[0]);?i++){
?????for?(size_t?j?=?0;?j?sizeof(arr2[i])/sizeof(arr2[i][0]);j++){
??????printf("%d?",arr2[i][j]);
??}
??printf("\n");
?}
?return?0;
}

二維數組輸入輸出

#include

int?main(void){
?int?scores[5][3];
?
?int?row?=?sizeof(scores)?/?sizeof(scores[0]);
?int?col?=?sizeof(scores[0])?/?sizeof(scores[0][0]);
?
?for?(size_t?i?=?0;?i???????for?(size_t?j?=?0;?j?//????????????取地址輸入
???????scanf("%d",?&scores[i][j]);
???}
?}
?for?(size_t?i?=?0;?i???????for?(size_t?j?=?0;?j?//????????????取地址輸入
???????printf("%d?",?scores[i][j]);
???}
???printf("\n");
?}
?return?0;
}

修改為輸出按二維數組行成績求和

#include
int?main(void){
?int?scores[5][3];
?int?row?=?sizeof(scores)?/?sizeof(scores[0]);
?int?col?=?sizeof(scores[0])?/?sizeof(scores[0][0]);
?for?(size_t?i?=?0;?i???????for?(size_t?j?=?0;?j????????scanf("%d",?&scores[i][j]);
???}
?}
?for?(size_t?i?=?0;?i???int?sum?=?0;
??for?(size_t?j?=?0;?j????sum?+=?scores[i][j];
??}
??printf("第%d行求和為：%d\n",?i+1,?sum);
?}
?
?return?0;
}

修改為按列求和

#include

int?main(void){
?int?scores[5][3];

?int?row?=?sizeof(scores)?/?sizeof(scores[0]);
?int?col?=?sizeof(scores[0])?/?sizeof(scores[0][0]);

?for?(size_t?i?=?0;?i???????for?(size_t?j?=?0;?j?//????????????取地址輸入
???????scanf("%d",?&scores[i][j]);
???}
?}
?for?(size_t?i?=?0;?i???int?sum?=?0;
??for?(size_t?j?=?0;?j????sum?+=?scores[j][i];
??}
??printf("第%d列總和：%d\n",?i+1,?sum);
?}
?return?0;
}

多維數組

三維數組

行列層

【層】【行】【列】
int?arr[2][3][4];?//?兩層三行四列

三維數組大小為 ?：

層*行*列*類型大小

三位數組打印與定義

#include

int?main(void){
//??定義一個兩層三行四列的三維數組
//?int?arr[2][3][4];
//?{
//?????{?{11,?2,?3,?4},?{1,?2,?3,?4},?{1,?2,?3,?4}?},
//?????{?{21,?2,?3,?4},?{1,?2,?3,?4},?{1,?2,?3,?4}?},
//????{?{31,?2,?3,?4},?{1,?2,?3,?4},?{1,?2,?3,?4}?},
//?}

????int?arr[2][3][4]?=
?{
?????{?{11,?2,?3,?4},?{1,?2,?3,?4},?{1,?2,?3,?4}?},
?????{?{21,?2,?3,?4},?{1,?2,?3,?4},?{1,?2,?3,?4}?}
?};
?//?打印維數組
?for?(size_t?i?=?0;?i?2;?i++){
??for?(size_t?j?=?0;?j?3;?j++){
???for(size_t?k?=?0;k?4;?k++){
????printf("%d?",arr[i][j][k]);
???}
???printf("\n");
??}
??printf("換層\n\n");
?}
?return?0;
}

特殊初始化

int?arr[2][3][5]?=?{1,2,3,4,5,6,7,8,9,10,11};??//可自動化定義
int?arr[][3][5];??//可省略層數

字符數組和字符串

字符數組

#include

int?main(void){
?char?str[5]?=?{'h',?'e',?'l',?'l',?'o'};
?
?printf("%s\n",?str);
?
?return?0;
}

字符串

char?str[5]?=?{'h',?'e',?'l',?'l',?'o',?'\0'};?//最后一位可以自動補0
char?str[]?=?"hello";

printf(“%s”) ==> 使用printf 打印字符串的時候必須碰到 ?**\0 **才結束,字符串和字符串數組自動補 \0

字符串數組輸入

#include
int?main(void){
?char?str[100]?=?{0};
?
?for?(size_t?i?=?0;?i?10;?i++){
??scanf("%c",?&str[i]);
?}
?printf("str?=?%s\n",str);
?return?0;
}

統計字符串中字符出現次數

#include

int?main(void){
????int?count[26]?=?{0};
?//?判斷字符串中的每個次數
//???? a：97
//?????z:?123
//?通過給一個數組下標添加累計數量的方式，記錄字符串的出現次數，通過asic碼
???char?str[11]?=?{0};
???for?(size_t?i?=?0;?i?10;?i++){
????scanf("%c",?&str[i]);
???}
???
???for?(size_t?i?=?0;?i?11;?i++){
????int?index?=?str[i]?-?'a';?//?用戶輸入字符下標在count數組中的下標值
????count[index]++;
???}
???
???for?(size_t?i?=?0;?i?26;?i++){
????if(count[i]?!=?0){
?????printf("%c?字符在字符串中出現的次數%d\n",?i+'a',?count[i]);
????}
???}


?return?0;
}

字符串操作

字符串獲取帶空格的字符串

一般情況下：

• 獲取字符串%s， 遇到空格和\n終止
• 用于存儲字符串的空間必須足夠大，防止溢出

若需要獲取空格，需借助正則表達式

scanf("%[^\n]",?str);
//?除換行之外的字符

如下代碼接收空格示例：

#include

int?main(void){
?char?str[100];
?scanf("%[^\n]s",?str);
?printf("%s\n",?str);
?return?0;
}

gets()函數

獲取一個字符串，返回字符串的首地址

原型

char?*gets(char?*s);

輸入參數，用來存儲字符串的空間

返回一個字符串的首地址

#include
#include
#include


int?main(void){
?char?str[100];
?printf("獲取字符串為：%s\n",?gets(str));
?return?0;
}

注意:由于scanf()和gets()無法知道字符串s大小，必須遇到換行符或讀到文件結尾為止才接收輸入，因此容易導致字符數組越界(緩沖區溢出)的情況。不安全的。

fgets()

char?*fgets(char?*s,?int?size,?FILE?*stream);

參數:獲取一個字符串。

s ：存儲字符串的空間地址

size ：描述空間大小，會預留**/0**的存儲空間，使得輸入不會越界

stream：讀取字符串的位置，標準輸入：stdin，表示鍵盤

返回值：返回實際獲取到的字符串首地址。

使用方法：

#include
#include
#include


int?main(void){
?char?str[10];
?printf("獲取字符串為：%s\n",?fgets(str,?sizeof(str),?stdin));
?return?0;
}

puts()

將字符串寫出屏幕

int?puts(coust?char?*s);

• 參數：待寫出到屏幕的字符串

• 返回值：**成功：**非負數， 失敗： -1

• puts函數會默認換行

#include
#include
#include


int?main(void){
?char?str[]?=?"hello?plotycodon\n";
?int?code?=?puts(str);
?printf("code?=?%d\n",?code);
?return?0;
}

fputs()

?int?fputs(const?char?*str,?FILE?*stream);

參數：輸出后不默認添加\n換行

str ：待輸出的字符串

stream：輸出位置(屏幕標準輸出 ==> stdout)

返回：成功0， 失敗-1

#include
#include
#include


int?main(void){
?char?str[]?=?"hello?plotycodon";
?int?code?=?fputs(str,?stdout);
?printf("code?=?%d\n",?code);
?return?0;
}

strlen()

求字符串的長度

size_t?strlen(const?char?*s);

參數

代求長度的字符串

返回一個有效的字符個數

碰到\0結束

#include
#include
#include


int?main(void){
?char?str[]?=?"hello?\n?plotycodon\n";
?printf("str?=?%s",?str);
?printf("sizeof(str)?=?%u?\n",?sizeof(str));
?printf("strlen(str)?=?%u",?strlen(str));
?return?0;
}

實現strlen()函數

#include
#include
#include

//實現strlen()

int?main(void){
?char?str[]?=?"hello?\n?plotycodon\n";
?int?i?=?0;
?
?while(str[i]?!=?'\0'){
??i++;
?}
?printf("strlen(str)?==?%d",?i);
}

strcat()

拼接兩個字符串

char*strcat(char*?strDestination,?const?char*?strSource);

參數為兩個需要拼接的字符串，其中第一個字符串將被覆蓋成新的字符串

#include?
#include?
int?main(){
????char?str1[101]?=?{?0?};
????char?str2[50]?=?{?0?};
????gets(str1);
????gets(str2);
????strcat(str1,?str2);
????puts(str1);
????return?0;
}

實現strcat

#include
#include
#include


int?main(void){
?char?str1[]?=?"guo";
?char?str2[]?=?"jia";
?char?str3[100]?=?{0};
?
?int?i?=?0;
?while?(str1[i]?!=?'\0'){
??str3[i]?=?str1[i];
??i++;
?}
?//?將str1?給str3
?printf("第一次循環結束的時候,?i?=?%d,?str3?==?%s\n",?i,?str3);
?
?int?j?=?0;
?while(str2[j]){
??str3[i+j]?=?str2[j];
??j++;
?}
?printf("第二次循環結束的時候,?i?=?%d,?str3?==?%s\n",?i+j,?str3);
?
?return?0;
}

往期文章

2020-9-17

• C++語法1、類與對象

• c++語法2、c執行-命名空間-輸入輸出

• c++ 3、語法 數據類型

• c++ 4、語法 數組

• c++ ?c語言- 概述

• c++ ?c語言 - 控件及概述補充

• c++? c語言 - 數據類型

• c++ ?c語言 - 進制、原反補碼、輸入輸出函數

• c++ ?c語言 - 運算符和類型轉換

• c++ ?c語言 - 控制語句

圖 | 郭嘉

文 | 郭嘉

掃碼關注桔梗與少年

微信號 : if-u-remembers

新浪微博：桔梗與少年

總結

以上是生活随笔為你收集整理的js二维数组arr中表示读取第i行第j列的是:_c++ c语言 数组与字符串的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。