数组

一维数组的定义和引用

定义：一维数组是指数组中的每个元素只带有关下标的数组。

格式：类型说明符 数组名 [ 常量表达式 ]

例如：定义一个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个元素）

数组定义中的下标必须是不可变的

错误示例：

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

 正确操作：

#include<stdio.h>
const int i = 5;  #不允许变量改变关键字const：用常数来描述数组定义中的元素个数
#define NUM 5     #宏定义不可变变量NUM：用符号常量来描述数组定义中的元素个数
int main()
{
    int number[NUM];
    number[0] = 0;
    printf("%d",number[0]);
    return 0;
}

数组初始化

示例1：

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

上面定义和初始化的数组空间大小为6，意思是可以存储6个数据，下表0~5.

示例2：

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

上面两个数组，除了数组名不一样，作用都相同。即发现，在定义数组并且同时对数组进行了完全初始化的情况下，我们可以省略数组大小

在没有规定数组大小的情况下，如果给定的初始值很多，我们怎么知道数组的大小呢？用sizeof来解决：

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

初始化的几种错误示例

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[ ];//没有确定数组大小

字符型数组的初始化

对于字符串的初始化，要注意数组实际分配空间大小事字符串中字符个数加上末尾的’\0’结束符

#include<stdio.h>
#include<iostream>
const int i = 5;
#define NUM 5
int main()
{
    int number[NUM];
    char string[] = "I love you!";
    number[0] = 0;
    printf("%d\n",number[0]);
    printf("%d\n",sizeof(int));
    printf("%d\n",sizeof(number)/4);
    printf("string\n");
    printf("%d\n",sizeof(string)/sizeof(char));
    printf("%d\n",strlen("I love you!"));
    return 0;
}

 数组做参数的函数声明
在调用和定义函数之前，我们需要先声明函数，声明函数的时候可以简写（即不写参数的函数名，只是单单定义类型）。下面我们声明一个求和函数，其函数名为sum,它的第一个参数是数组（代表调用的是这个数组，而不是那个数组），第二个参数是长度（整型）

# include <iostream>

int sum(int [],int);//最简单的正确写法

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

当然也可以换成另外一种可视化程度较高的样子

# include <iostream>

int sum(int array[],int len);//让人知道了你声明的函数想要干什么，但其功能与上面的简单写法无异

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

数组做参数的函数定义

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

数组做参数的函数调用

根据需要定义有无返回值的函数，就上题求和的例子接着，我们定义了一个有返回值的函数，并且准备调用它，一般有返回值的函数，我们都会利用它的返回值，所以对它进行一个赋值操作：

# 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

求数组中储存了东西的长度对于已知类型、已初始化的数组长度

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

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

对于需要输入赋值的字符型数组长度

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    char array[100];
    int size;
    cin>>array;//只有字符型数组可以这样写输入的代码
    size=strlen(array);
    cout<<size<<endl;
    return 0;
}

给数组分配内存空间的问题

从上面代码中我们发现能分配的空间数都是定死的，以下介绍两种在程序运行时申请某个大小的内存空间。
用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;
}

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