静态数组（array）相关

今天药忘吃喽~ 2022-11-25 00:55 120阅读 0赞

### 指针修改数组元素 ###

//指针修改数组元素
    #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]; 也可以用其他数据类型
    };