一维数组基础笔记（声明，定义，调用）

前言：自己对于一维数组的声明、定义、调用、赋初始值……一直弄不清楚格式，这一篇来专门整理一下，当作笔记

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;
}