1. 栈区

数组是底层数据类型，存放在栈中，其内存的分配和释放完全由系统自动完成。

通过如下代码初始化一个全局变量数组，初始化的规则就是不足数组大小的按默认值补位：

int a[5]; //int默认0
int b[5] = {
    
    1，2}; // {1,2,0,0,0} 不足5位的0补位
string c[5] = {
    
    "a", "b"}; // {"a","b","","",""}

如果不明确指出初始化列表，那么基本类型是不会被初始化的（除:全局变量、静态变量）; 类类型如string则会为每个元素调用默认构造函数进行初始化。

所以建议使用如下方式初始化，局部变量也会初始化：

int a[5]{
    
    }; //c++11新写法

2. 动态数组

动态数组是通过new创建在堆上的数组：

int *a = new int[5]; //没有初始化
int *b = new int[5] {
    
    1,2}; // {1,2,0,0,0} 不足5位的0补位
string *c = new string[5]{
    
    "a", "b"}; // {"a","b","","",""}

动态数组如果不明确指出初始化列表，那么基本类型是不会被初始化的（全局变量也没有初始化，静态变量除外），所有的内存都是“脏的”。

new还有一种写法，会初始化:

int* a = new int[5]();//初始化{0,0,0,0,0}

+括号的意思是：使用默认值初始化整个数组

例如：

int *pia = new int[10]; // array of 10 uninitialized ints

此 new 表达式分配了一个含有 10 个 int 型元素的数组，并返回指向该数组第一个元素的指针，此返回值初始化了指针 pia。

在自由存储区中创建的数组对象是没有名字的，只能通过其地址间接地访问堆中的对象。

C++使用new和delete在堆（自由存储区）上分配和释放动态数组。

一维数组

malloc/free:

int* Array = (int*)malloc(ArraySize * sizeof(int));	// 在堆中申请内存
memset(Array, 0, ArraySize * sizeof(int));			// 初始化数组全为 0
free(Array);										// 释放内存

new/delete：

int* Array = new int[ArraySize];					// 仅在自由存储区中申请内存，不初始化
int* Array = new int[ArraySize]();					// 初始化数组全为 0
int* Array = new int[5]{
    
     1,2,3,4,5 };				// 初始化数组为 1,2,3,4,5（VS2015支持）
int* Array = new int[5]{
    
     1 };						// 初始化数组为 1,0,0,0,0
delete[] Array;										// 释放内存

二维数组

本质上并没有二维数组的概念，比如int[2][3]这个二维数组，它会被编译器视作一个元素类型为int[3]的一维数组。

malloc/free:

int **Array = (int**)malloc(ArrayRow * sizeof(int *));		// 先行
for (int i = 0; i < ArrayRow; i++)
{
    
    
    Array[i] = (int*)malloc(ArrayCol * sizeof(int));		// 后列
    memset(Array[i], 0, ArrayCol * sizeof(int));			// 初始化 0
}

for (int i = 0; i < 3; i++)									// 释放内存
{
    
    
	free(Array[i]);
}
free(Array);									

new/delete：

int **Array = new int *[ArrayRow];
for (int i = 0; i < ArrayRow; i++)
{
    
    
	Array[i] = new int[ArrayCol]();							// 初始化 0
}

for(i = 0; i < ArrayRow; i++)  								// 释放内存
{
    
      
    delete[] Array[i];  
}   
delete[] Array;  

3. 赋值

memset

memset可以为上述数组重置，由于memset按字节对内存块进行初始化，所以不能用它将int数组初始化为0和-1之外的其他值（除非该值高字节和低字节相同）。

memset(void *s, int ch,size_t n);
int a[5];
memset(a, 511, sizeof(int)*5);// 511的二进制码后八位都为1，与-1相同
//{-1,-1,-1,-1,-1}

memset赋值采用输入的第四个字节，因为511二进制码 (00000000 00000000 00000001 11111111)，最后一个字节与1的二进制码 (11111111 11111111 11111111 11111111)，四个字节都相同，所以可以赋值。

前面提过，如果我们想初始化的值高位字节和低位字节相同(0和-1的每个字节都相同)，也可以用memset赋值。

fill

fill() 和 fill_n() 算法提供了一种为元素序列填入给定值的简单方式，可以用于多种序列，这里列出初始化数组的样例，感兴趣再做探索。

int a[5];//这里a按全局变量定义，则都初始化为0
fill(a, a+2,1); // {1,1,0,0,0}

4. 数组初始化

   1: 一维数组初始化：
   2: 标准方式一： int value[100]; // value[i]的值不定，没有初始化
   3: 标准方式二： int value[100] = {
    
    1,2}; // value[0]和value[1]的值分别为1和2，而没有定义的value[i>1]
   4:                                  // 则初始化为0
   5: 指针方式： int* value = new int[n]; // 未初始化
   6:            delete []value;  // 一定不能忘了删除数组空间
   7:  
   8: 二维数组初始化：
   9: 标准方式一： int value[9][9]; // value[i][j]的值不定，没有初始化
  10: 标准方式二： int value[9][9] = {
    
    {
    
    1,1},{
    
    2}}； //value[0][0,1]和value[1][0]的值初始化，其他初始化为0
  11: 指针方式一： int (*value)[n] = new int[m][n];
  12:              delete []value; // n必须为常量，调用直观。未初始化
  13: 指针方式二： int** value = new int* [m];
  14:              for(i) value[i] = new int[n];
  15:              for(i) delete []value[i];
  16:              delete []value; // 多次析构，存储麻烦，未初始化
  17: 指针方式三： int * value = new int[3][4]; // 数组的存储是按行存储的
  18:              delete []value; // 一定要进行内存释放，否则会造成内存泄露
  19:  
  20: 多维数组初始化：
  21: 指针方式： int * value = new int[m][3][4]; // 只有第一维可以是变量，其他几维必须都是常量，否则会报错
  22:            delete []value; // 一定要进行内存释放，否则会造成内存泄露

5. 数组作为参数传递

   1: 一维数组参数传递：
   2: void Func(int *value);
   3: 或者是
   4: void Func(int value[]);
   5:  
   6: 二维数组传递：
   7: 定义是 int **value;的传递
   8: void Func(int **value);
   9: 定义是 int (*value)[n] = new int[m][n];的传递
  10: void func(int (*value)[n]); // sizeof(p)=4,sizeof(*value)=sizeof(int)*n;

6. 数组与指针关系

1、数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组；

2、数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量；

3、指向数组的指针则是另外一种变量类型，（在win32平台下，长度为4），仅仅意味着数组存放地址。

4、数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针，而且在其失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

7. 数组的存储格式

多维数组在内存中存储时是按照最低维连续的格式存储的，如二维数组{undefined{1,2}，{3,4}}在内存中的位置是这样顺序的“1,3,2,4”，这跟matlab是有区别的，matlab是按列进行存储的。在使用指针进行索引时很有用。

8. 字符数组

char类型的数组被称作字符数组，通常用来存储字符串。字符串是附加有特殊字符（串尾标志）的字符序列。串终止字符表明字符串已经结束，该字符由转义序列‘\0’定义，有时被称为空字符，占用一个字节，其中8位全为0。这种形式的字符串通常被称为C型字符串，因为以这样的方式定义字符串是在C语言中推出的，在C++一般使用string，而MFC中则定义了CString类。

字符串中每个字符占用一个字节，算上最后的空字符，字符串需要的字节数要比包含的字节数多一个。如：

char movie_star[15] = “Marilyn Monroe”;

这里字符串是14个字符，但是要定义15个字符串的数组。也可以不指定字符数组的个数。如：

char movie_star[] = “Marilyn Monroe”;

9. 内存泄露

我们定义了一个指针，然后给它赋予了一个地址值，然后又不再使用，但是没有delete，那么当给指针赋予其他的地址值时，原来的内存将无法释放，这就叫做内存泄露。

参考：Link Link

加油!

感谢!

努力!