一維陣列基礎筆記（宣告，定義，呼叫）

阿新 • • 發佈：2018-11-16

前言：自己對於一維陣列的宣告、定義、呼叫、賦初始值……一直弄不清楚格式，這一篇來專門整理一下，當作筆記

1. 陣列定義

1.1 定義一個5個元素的整型陣列

int array[5];

（1） int 表示定義的定義的陣列是整型陣列，即陣列空間裡面存放整形變數

（2） array 是定義陣列的名稱

（3） [5] 是表示定義的陣列有5個元素，每個型別都是整型（需要注意的是陣列的下標都從0開始，所以5個元素分別是array[0]、array[1]、array[2]、array[3]、array[4]）（所以，array[5]是不屬於該陣列的空間範圍的）

（4）

總結出來就是 int array[5] 它是定義一個有5個元素的陣列，所以它是合法存在的。而 array[5] 它是指陣列當中下標為5的一個元素，在本道題的舉例中，它不存在、不合法（因為下標為5，即是陣列的第6個元素）

1.2 定義一個6個元素的字元型陣列

char brray[6];

（1） char 表示定義的定義的陣列是字元陣列，即陣列空間裡面存放字元變數

（2） brray 是定義陣列的名稱

（3） [6] 是表示定義的陣列有6個元素，每個型別都是字元型（同樣需要注意的是陣列的下標都從0開始，所以6個元素分別是array[0]、array[1]、array[2]、array[3]、array[4]、array[5]）（所以，array[6]是不屬於該陣列的空間範圍的）

1.3 陣列定義中的下標必須確定

1.3.1 錯誤示例

int size_overall=50;
int main()
{
    int size_local=50;
    int array[size_overall];//錯誤！！！
    int brray[size_local];//錯誤！！！
}

（1） 無論是全域性變數，還是區域性變數，只要是變數就不能用來描述陣列定義中的元素個數

1.3.2 正確示例

1.3.2.1 用常數來描述陣列定義中的元素個數

const int n_overall=15;
const int n=n_overall*sizeof( 
int);
int main()
{
    const int n_local=10;
    int array[5];//正確，5個元素
    int brray[n_overall];//正確，15個元素
    int crray[n_local];//正確，10個元素
    char drray[n];//正確，60個元素
}

1.3.2.2 用符號常量來描述陣列定義中的元素個數

#define N=10

int main()
{
    int array[N];//正確，10個元素
}

Ps：有人會說，如果一開始就用確定的下標來描述元素個數，萬一記憶體空間申請多了不就浪費了嗎。有沒有什麼辦法是我用多少記憶體空間就申請多少的呢？這個解答可以見下面的第7部分《給陣列分配記憶體空間的問題》

2. 陣列初始化

2.1 初始化的幾種正確示例

2.1.1 示例一

int array[6]={1,2,3,4,5,6};
int brray[6]={1};
int crray[6]={1,2,3};

（1） 在定義的時候直接初始化，即array[0]=1、array[1]=2、array[2]=3、array[3]=4、array[4]=5、array[5]=6
（2） 在定義的時候部分初始化，即brray[0]=1、brray[1]=0、brray[2]=0、brray[3]=0、brray[4]=0、brray[5]=0（注意，這個初始化並不是六個元素全都賦值為1，而是隻給第一個元素賦值為1，其餘的都是初始化為0）
（3） 同理，即crray[0]=1、crray[1]=2、crray[2]=3、crray[3]=0、crray[4]=0、crray[5]=0

2.1.2 示例二

int array[5]={2,4,6,8,10};
int brray[ ]={2,4,6,8,10};

（1） 上面兩個陣列，除了陣列名不一樣，作用都相同。即發現，在定義陣列並且同時對陣列進行了完全初始化的情況下，我們可以省略陣列大小

在沒有規定陣列大小的情況下，如果給定的初始值很多，我們怎麼知道陣列的大小呢？用sizeof來解決

int a[] = {1,2,4,6,8};
int len = sizeof(a)/sizeof(int);

2.2 初始化的幾種錯誤示例

int array[5] = {1,2,3,4,5,6};//錯誤！！！初始化值個數多於陣列元素個數
int brray[5] = {1, ,2,3,4};//錯誤！！！初始化的時候不能跳躍省略，編譯器不會給你自動初始化為0
int crray[5] = {1,2,3, };//錯誤！！！同樣跳躍省略
int drray[5] = {1,2,3};//正確，意味著drray[0]=1,drray[1]=2,drray[2]=3,drray[3]=0,drray[4]=0
int erray[5] = { };//錯誤！！！語法格式錯誤
int frray[ ];//沒有確定陣列大小

2.3 字元型陣列的初始化

對於字串的初始化，要注意陣列實際分配空間大小事字串中字元個數加上末尾的’\0’結束符

#include <iostream>

int main()
{
    char array[]="how are you";//包括空格在內字串長度是11
    cout<<sizeof(array)<<endl;//輸出結果是12
    cout<<strlen("how are you)<<endl;//輸出結果是11
}

3. 陣列做引數的函式宣告

在呼叫和定義函式之前，我們需要先宣告函式，宣告函式的時候可以簡寫（即不寫引數的函式名，只是單單定義型別）。下面我們宣告一個求和函式，其函式名為sum,它的第一個引數是陣列（代表呼叫的是這個陣列，而不是那個陣列），第二個引數是長度（整型）
我們以一道呼叫函式求陣列元素之和的題目為例。

# include <iostream>

int sum(int [],int);//最簡單的正確寫法

int main()
{
    //………………
}

當然也可以換成另外一種視覺化程度較高的樣子

# include <iostream>

int sum(int array[],int len);//讓人知道了你宣告的函式想要幹什麼，但其功能與上面的簡單寫法無異

int main()
{
    //………………
}

4. 陣列做引數的函式定義

# include <iostream>

int sum(int [],int);//求和函式宣告

int main()//主函式，下一部分會把它補全
{
    //………………
}

int sum(int array[],int len)//這裡必須補全，即相當於定義了局部變數
{
    int tempSum=0;
    for(int i=0;i<len;++i)//一般都使用for函式遍歷陣列
        tempSum+=array[i];
    return tempSum;
}

5. 陣列做引數的函式呼叫

根據需要定義有無返回值的函式，就上題求和的例子接著，我們定義了一個有返回值的函式，並且準備呼叫它，一般有返回值的函式，我們都會利用它的返回值，所以對它進行一個賦值操作

# include <iostream>

int sum(int [],int);//函式宣告

int main()
{
    int array[5]={2,3,6,8,10};//初始化
    int sumArray;//為之後的函式返回值賦值做準備
    sumArray=sum(array,5);//函式的返回值賦值給sumArray；
    //最重要的是呼叫函式的時候，如果傳參是一個數組，就只要傳它的陣列名就可以（因為傳遞陣列實際上傳遞的是陣列的首地址），千萬不要寫成array[] !!!
    cout<<sumArray<<endl;
}

int sum(int brray[],int length)//注意：這裡定義的引數只是起區域性變數的意思，你想給它叫什麼名字就什麼名字，不必和主函式中陣列的名字相同
{
    int tempSum=0;
    for(int i=0;i<length;++i)//注意，如果上面引數區域性變數是什麼名字，就用什麼名字
        tempSum+=brray[i];//注意，如果上面引數區域性變數是什麼名字，就用什麼名字
    return tempSum;
}

6. 求陣列中儲存了東西的長度

6.1 對於已知型別、已初始化的陣列長度

6.1.1 方法一

#include <iostream>
using namespace std;
int main()
{
    int array[]={1,4,2,7,13,45,793,32};
    int size;
    size=sizeof(array)/sizeof(int);
    cout<<size<<endl;
    return 0;
}

6.1.2 方法二

#include <iostream>
using namespace std;
int main()
{
    int array[]={1,4,2,7,13,45,793,32};
    int size;
    size=sizeof(array)/sizeof(*array);
    cout<<size<<endl;
    return 0;
}

6.2 對於需要輸入賦值的字元型陣列長度

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    char array[100];
    int size;
    cin>>array;//只有字元型陣列可以這樣寫輸入的程式碼
    size=strlen(array);
    cout<<size<<endl;
    return 0;
}

7. 給陣列分配記憶體空間的問題

在之前的第1部分《陣列定義》中就講了如果給元素分配空間，但發現能分配的空間數都是定死的，以下介紹兩種在程式執行時申請某個大小的記憶體空間。

7.1 用malloc()和free()來獲得和釋放堆記憶體

需要引入標頭檔案 # include <stdlib.h> 來呼叫這兩個函式

#include <iostream>
#include <stdlib.h>
using namespace std;
int main()
{
    int size;//元素個數
    int *array;//一個擁有記憶體的指標可以作為一個數組使用
    cout<<"請輸入陣列長度：";
    cin>>size;
    
   array = (int *)malloc( size*sizeof(int));//分配堆記憶體

    for(int i=0;i<size;++i)
        cin>>array[i];

    for(int i=0;i<size;++i)
        cout<<array[i]<<" ";
    cout<<endl;
    free( array );//釋放堆記憶體
    return 0;
}

7.2 用new[]和delete[]來獲得和釋放堆記憶體

這兩個函式是c++專用的操作符，不需要引入標頭檔案

#include <iostream>
#include <stdlib.h>//因為之後用到了exit(1);
using namespace std;
int main()
{
    int size;//元素個數
    int *array;//一個擁有記憶體的指標可以作為一個數組使用
    cout<<"請輸入陣列長度：";
    cin>>size;
    
   array = new int[size];//分配堆記憶體

    for(int i=0;i<size;++i)
        cin>>array[i];

    for(int i=0;i<size;++i)
        cout<<array[i]<<" ";
    cout<<endl;
    delete[]array ;//釋放堆記憶體
    return 0;
}