静态数组（array）相关

指针修改数组元素

//指针修改数组元素
#include<iostream>
using namespace std;
int main()
{
 int example[5];
 int *ptr=example;
 for(int i=0;i<5;i++)
 {
  example[i]=2;
 }
 example[2]=5;
 cout<<example[2]<<endl;
 *(ptr+2)=6;
 cout<<example[2]<<endl;
} 

关键字new创建新数组

//关键字new创建新数组 
#include<iostream>
using namespace std;
int main()
{
 int example[5];
 for(int i=0;i<5;i++)
 {
  example[i]=2;
 }
 int *another=new int[5];
 for(int i=0;i<5;i++)
 {
  another[i]=2;
 }
 delete[] another;
 } 
/*example创建在stack栈中，another创建在heap中
创建于 stack 中的 example 数组将会被自动删除当程序运行到当前范围内的结束符 “}” 时。
而创建于 heap 中的 another 将会一直存在，直到我们将其删除 “delete[] another” 或者整个程序结束。

数组名赋值给指针

可以将数组名赋值给一个指针，而赋值后的指针是指向数组首元素的，这让数组名看起来确像一个指针。
数组名可以像指针一样运算，对数组的索引和指针的运算看起来也是相同的。

#include <stdio.h>
int main()
{
    int a[] = {1,2,3};
    int * p = a;
    printf("a:\%p, p:%p, &a[0]:%p\n", a, p, &a[0]);
    printf("*a:\%d, *p:%d, a[0]:%d, p[0]:%d\n", *a, *p, a[0], p[0]);
    printf("*(a+1):\%d, *(p+1):%d, a[1]:%d, p[1]:%d\n", *(a+1), *(p+1), a[1], p[1]);
    return 0;
}

运行结果：

a:0x5fcaf0, p:0x5fcaf0, &a[0]:0x5fcaf0
*a:1, *p:1, a[0]:1, p[0]:1
*(a+1):2, *(p+1):2, a[1]:2, p[1]:2

&a 与 &a[0]

&a表示数组地址，其结果是指向该数组的指针。
&a[0]表示数组首元素的地址，其结果是指向该数组首元素的指针。
它们意义不同，但是地址的值相同。因为数组是一连续内存，它的地址是所占内存单元的第一块存储单元地址。而第一块存储单元就是数组的首元素，所以两者相同。
注意：指向数组的指针和指向数组首元素的指针是两种不同类型的指针

#include<stdio.h>
int main()
{
    int a[]={1,2,3};
    int (* pa)[3];
    int *pi;
    pa=&a;
    pi=&a[0]; 
    printf("&a=%p, &a[0]=%p\n",&a, &a[0]);
    printf("pa=%p, sizeof(a)=%d, pa+1=%p\n", pa, sizeof(a), pa+1);
    printf("pi=%p, sizeof(a[0])=%d, pi+1=%p\n", pi, sizeof(a[0]), pi+1);
    return 0;
} 

输出结果：

&a=0x5fcaf0, &a[0]=0x5fcaf0
pa=0x5fcaf0, sizeof(a)=12, pa+1=0x5fcafc
pi=0x5fcaf0, sizeof(a[0])=4, pi+1=0x5fcaf4

取数组地址（&a）得到的指针pa和取数组首元素（&a[0]）得到的指针pi是两种不同类型的指针，pa是一个指向有三个int型元素的数组的指针，pi是一个指向int型对象的指针。虽然pi和pa的值相同，但所指的内存空间不同，pi所指的空间处于pa所指空间的内部，而且是内部最靠前的部分。pi和pa所指内存块的大小显然是不同的，因此我们看到pa+1并不等于pi+1。
由指针运算规则可知，pa+1的值就是pa所指空间的下一个空间的地址，所以pa+1的值就是pa的地址向后偏移一段后的地址，这个偏移量就是pa所指的数组a的大小，即12个内存单元。同样，pi+1的值是pi向后偏移4个单位（int型的大小）后的地址。

传递数组给函数

//传递数组给函数(一维数组) 
int fun(int *param)
{
 ...
} 
int fun(int param[10])
{
 ...
}
int fun(int param[])
{
 ...
}
//传递数组给函数(二维数组)
int fun(int param[][10])
{
 //param实际类型是int(* )[10],即int [10]数组的指针 
 } 
int fun(int (*param)[10])
{
 param实际类型是int(* )[10],即int [10]数组的指针 
 } 

动态数组

从堆上分配的空间，在执行过程中进行分配，所以叫做动态数组。

int n;
scanf("%d",&n);   //手动输入数组长度
int* parr = new int[n]; //动态申请数组内存
//......    //进行必要的操作
delete[] parr;   //手动释放申请的内存

柔性数组

柔性数组也叫伸缩性数组。
声明在结构体的最后一个元素，只作为一个符号地址存在，并不占用空间。
作为一个动态的大小，只能由我们在堆上进行生成。
主要作用于网络传输，因为你若定义一个固定大小的数组，若没有写满等于内存浪费。若数据太多，可能造成溢出。柔性数组则很好的解决了这个问题。

struct MyStruct
{
 int a;
 double b;
 char c[];  // or char c[0]; 也可以用其他数据类型
};