数组是程序设计中是一个非常重要的概念。数组是一个用于收集大量类似数据的容器，
以及其每一个元素能被相同处理过程迭代来处理的一个抽象体。
创建数组一般有三种方式：全局/静态范围的数组，局部变量数组，申请堆空间来创建数组。
其中，全局/静态范围的数组，以及局部变量属于静态数组。
而申请堆空间来创建数组的属于动态数组。

1. a[7]与p1_a[7]是一样的么？
2. 静态两维数组的排列顺序
3. 动态两维数组的排列顺序
4. 数组与指针
5. 各种数组的声明方式
6. 静态数组和动态数组在内存的组织方式
7. 杂谈，不为人知的数组表达方式
8. 数组的迭代与性能影响

a[7]与p1_a[7]是一样的么？

首先声明几个数组：

int g_a[10];    // 全局变量数组int main(int argc, char** argv)
{int a[10];    // 局部变量数组static int s_a[10];    // 静态局部变量数组int *p1_a, *p2_a;    // 数组指针// 为动态数组申请空间p1_a = (int*)malloc(sizeof(int) * 10);p2_a = new int[10];// 为数组赋值a[7] = 0;s_a[7] = 0;g_a[7] = 0;p1_a[7] = 0;p2_a[7] = 0;// 释放空间，并且将指针置0delete[] p2_a;free(p1_a);p1_a = p2_a = 0;
}

上述程序中，5个数组的在赋值的时候除了变量名以外几乎都是一模一样的，是不是他们的实现也一样了呢？
答案是否定的，动态数组和静态数组虽然在使用时看起来没有什么差别，但他们 实现是不一样的。
反汇编看一下他们的代码。

根据汇编的结果可见，静态数组都采用了一次寻址，
而动态数组都是两次寻址，这和动态数组本身实现是有关系的。
静态数组的变量本身就是数组第一个元素的地址。
动态数组的变量存放的是一根指向到申请空间的首址指针。

静态两维数组的排列顺序

首先是静态数组，在C/C++中，其实没有正真的两维概念，
对于所有静态数组来说，都是一维的，考虑以下的例子
int a[35]和int b[7][5]
对于前者，就是 包含35个int类型值的数组
而对于后者，可以理解为b是一个拥有 7个数组类型的数组，
每个数组类型又是一个拥有 5个int类型值的数组。
可以得出的结果就是两个数组在内存中的分布其实是一样的。

用简单的程序来验证一下：

int a[35];
int b[7][5];a[0] = 4;
a[1] = 5;
a[34] = 6;
b[0][0] = 7;
b[0][1] = 8;
b[1][0] = 9;
b[6][4] = 10;

以上汇编的结果表明，两维数组的实现就是转化成了一维。

如果对两维的概念比较清楚的话，再看两维的排列顺序就不难了
首先是一维的情况（在内存中a[0]和a[1]是连续的）

接着是两维（ 在内存中b[0][0]和b[0][1]是连续的，b[0][4]与b[1][0]是连续的，但b[0][0]和b[1][0]不是连续的）

以此类推，三维的情况下，首先是第三维的增长，然后再是第二维，最后才是第一维

动态两维数组的排列顺序

首先动态两维数组的创建方式有所不同，以下是经典的创建方法：

int* pa;
int** pb;// 申请空间
pa = new int[35];
pb = new int*[7];
for (int i = 0; i < 7; i++)
{pb[i] = new int[5];
}// 赋值操作
pa[0] = 4;
pa[1] = 5;
pa[34] = 6;
pb[0][0] = 7;
pb[0][1] = 8;
pb[1][0] = 9;
pb[6][4] = 10;// 释放空间
delete[] pa;
for (int i = 0; i < 7; i++)
{delete[] pb[i];
}
delete[] pb;

汇编分析

动态数组在内存中的分布大致如下，首先来看看一维：（pa[0]和pa[1]还是连续的）

两维的话就和静态数组有比较大的区别了：（ 连续性问题请参考上面的汇编分析）

数组与指针

在C/C++中，数组与指针的关系非常密切，
要清楚理解两者任一个的概念的话，不清楚了解另一个的概念是不可能的。
所以在这里阐述一下他们的关系。

从最简单的开始：

int a[10];
int *pa = a;

声明完这两个变量后，我们可以：
a[0] = 0;
同样我们可以：
*a = 0; // 一次寻址
*pa = 0; // 两次寻址
pa[0] = 0; // 两次寻址

对于*a和*pa来说，其实原型为：
*(a + 0)
*(pa + 0)

因为存在这样一个事实：
在指针上加上一个值后，并不是单纯在地址上加上该值，
而是表示一个偏移量，根据类型不同，偏移单位量也是不同的。

如果以上述例子来说的话，因为int在VC中是4个字节，
那么每+1，在地址上所加的是sizeof(int)也就是4个字节。
这样，就和数组的索引值就陪对了起来。即：
*a 等价于 *(a + 0) 等价于 a[0]
*(a + 5) 等价于 a[5]

从另一个方面来说的话，对于
pa = a;
也可以写为：
pa = &a[0];
同样，并不一定要指向索引为0的元素，
pa = a + 7;
pa = &a[7];

接下来考虑稍微复杂一点的静态两维数组：

int b[7][5];
int (*pb)[5] = b; // 声明和赋值写在同一行可能比较混乱，如果单独写的话，应该是 pb = b;
int (*pb1)[5] = b + 1; // 或者&b[1]
int *pvalue = (*b) + 1; // 或者&(*b)[1]
int *pvalue1 = (*pb) + 1; // 或者&(*pb)[1]

首先解释一下一个常见的问题：
int **pb = b;
如果这么写的话，编译器会不客气地扔出一个错误：
error C2440: '=' : cannot convert from 'int [7][5]' to 'int **'

猜想的原因可能是因为：
静态数组和动态数组的结构不同，如果同样采用int** 指针来引用的话，
在访问具体元素的时候，会产生二义性（指针并不知道引用的数组类型）

而一旦明确了声明后，对指针的操作时采用两次*取值操作就不会受到太大阻碍。
以下几种写法都是等价的：
b[1][1]
pb1[1][1]
*(b[1] + 1)
*(pb1[1] + 1)
*(*(b + 1) + 1)
*(*(pb1 + 1) + 1)

唯一被编译器隐藏的区别就是，与b相关的操作一次寻址，而pb1每次都是两次寻址。

然后看看那个声明就比较混乱的pb
在声明中， 指明了它是一个指针，指向一个含有5个元素的数组。
回忆一下 第二节.静态两维数组的排列顺序中一句话：

而对于后者，可以理解为b是一个拥有7个数组类型的数组，
每个数组类型又是一个拥有5个int类型值的数组。

两边要表达的意思是一致的，所以， pb的值可以为&b[0] ～ &b[6]中任一个。

接着我们又声明了一个int指针，用来接具体的值，
由于pb固定了b的第一维索引值，所以对其解引用（即*操作），
操作层从第一维转换到了第二维上，所以我们可以用&(*pb)[1]的形式，
或者(*pb) + 1的形式来获得某个元素的指针。

对于动态两维数组，因为其本身声明就是int **pb，所以也不存在什么编译器报错的问题。
而且对其做两次解引用（*求值操作），也确实根据地址求了两次值。
如果算上指针本身是地址，需要间接引用的话，所以一共是做了三次间接引用。

各种数组的声明方式

对于数组的声明，以及在函数参数中的声明，经常会被编译器拦截，
被告知声明不符合要求，所以经常会摸不着头脑最后改变数组的形式。
其实每种声明都可以通过语法实现，只不过因为数组的特殊性，
所以要说明数组的语法通常都比较复杂一点罢了。

下表是对各种情况做了一下整理： （假设对函数的调用为func(a)）

静态数组和动态数组在内存的组织方式

前面也提到过，静态数组在栈内或者在数据段.data内分配空间，
而动态数组在堆内分配空间。下面从内存角度来说明各自的特点。

全局变量数组/静态局部变量数组

这两个数组的生命期都和程序一样长，因为它们的空间是程序运行前就指定完毕的，
在程序执行过程中，也是通过直接寻址，地址一已经硬编码写在了程序代码中。

因为运行前就被分配了空间，所以 所有元素的初始值被设为0。

有一种特殊的全局变量数组——字符串
他们是一种末尾必定以'/0'结尾的特殊的char型数组。
虽然也属于全局变量数组，但他们被放在了只读的.rdata段中，
放在只读段中是因为他们是不应该被程序的错误代码而改写的。
看看下面的例子：

char* c1 = "abcde";
char c2[] = "abcde";c1[0] = 'b'; // 错误
c2[0] = 'b'; // 正确

c1是指针，指向一个全局的字符串数组
c2是一个局部变量数组
当c1想改写全局字符串数组中某个元素的值的时候，
会发生Access Violation的异常，因为在该内存区的数据全是只读的。

局部变量数组

局部变量数组的空间是从栈上被分配出来的。
局部变量数组的生命周期只和函数一样长，当然如果声明在某个循环里的时候，
虽然堆内预留的空间还是存在的，但编译器可能会把这个空间用于其他不和这个变量冲突的变量。
这样做的目的是为了节省堆栈空间。所以，在循环内的数组变量声明周期也就到循环的结束。

在栈上分配空间的时候，由于PUSH的效率很低，特别是遇到数组这种大量数据集合的时候，
所以编译器一般直接通过移动ESP指针来达到分配空间的目的。但编译器做的仅仅是移动指针，
而分配出来的空间中有些什么垃圾数据，编译器是不会去管的，这个C/C++本身实现目标有关系，
C/C++是为了性能而设计出来的一种语言。
它的目标是做最少的事情，用最少的时间完成最多的工作，
所以，初始化内存的责任就转移到了程序员的身上，
另外不仅分配内存如此，从很多方面都能感受到C/C++的这个思想。

栈中的数据不单单有普通变量，数组变量，还有比如返回地址，栈帧，SEH链表，调用参数都在这块空间内。
其中最重要的是 返回地址。
为什么这么说，首先介绍一个概念—— 栈溢出。
栈溢出就是因为不当的操作，把值写到了不应该写的栈地址上面。
而返回地址决定了程序执行的方向，一旦返回地址被修改，导致程序跳到了其他地方，
首先是程序出错这是肯定的，此外由于操作系统最终捕获到错误会利用堆栈的返回地址链，
打印出栈中函数的调用关系，如果返回地址都没有了的话，那就不可能追踪最末层的函数，
也就会给调试带来的一定的困难。

说了那么多，其实反过来想说明的问题是， 局部变量数组是一个很容易导致堆栈溢出的变量。
因为数组会有循环迭代，一旦没有控制住，就会越界，越界就有可能发生堆栈溢出。
关于这点，在下一节 杂谈，不为人知的数组表达方式中有简略的实例演示。

动态数组（数组指针）

动态数组虽然也有局部的——它的指针，
但一旦new过了之后，它所 指向的实际分配空间是在堆里面的。

在堆中申请空间有两种方式：C的malloc和C++的new。
对于基本数据类型的数组来说，这两种申请空间的方式没有什么太大的区别。

int *pa, *pb;
pa = (int *)malloc(sizeof(int) * 10); // 正确
pb = new int[10]; // 正确

但是，如果类数组的话，一定要用new来分配空间，而不是malloc。

MyClass *pa, *pb;
pa = (MyClass *)malloc(sizeof(MyClass) * 10); // 错误
pb = new MyClass[10]; // 正确

采用malloc调用的只是分配了一块sizeof(MyClass) * 10大小的空间，其他什么事情都没做。
采用new调用，不但分配了空间（自动计算），而且还 调用了每个MyClass的构造函数。
对于类来说，构造函数是很重要的，如果没有调用构造函数而使用该类变量的话，可能会出现预想不到的结果。
同样，在用new []申请空间后，需要用delete []释放空间。
为什么不是delete，而是delete []？
对于 基本数据类型的数组来说， delete只释放了pa[0]的空间，而delete []正确地释放了所有的空间。
对于 类的数组来说， delete只调用了pa[0]的析构函数，并是放了空间，
而delete []调用了所有元素的析构函数，并且正确地释放了所有的空间。

如果有疑问的话，这样一段小小的程序会告诉你答案的:-)

#include <iostream>
using namespace std;class MyClass
{public:MyClass() {_i = _s_i++; cout << "MyClass(). " << _i << endl;}~MyClass() {cout << "~MyClass(). " << _i << endl;}private:int _i;static int _s_i;
};
int MyClass:: _s_i = 0;int main(int argc, char** argv)
{MyClass *pa, *pb;cout << "[malloc]" << endl;pa = (MyClass *)malloc(sizeof(MyClass) * 10);cout << "[new]" << endl;pb = new MyClass[10];delete[] pb;pb = 0;free(pa);pa = 0;
}

[malloc]
[new]
MyClass(). 0
MyClass(). 1
MyClass(). 2
MyClass(). 3
MyClass(). 4
MyClass(). 5
MyClass(). 6
MyClass(). 7
MyClass(). 8
MyClass(). 9
~MyClass(). 9
~MyClass(). 8
~MyClass(). 7
~MyClass(). 6
~MyClass(). 5
~MyClass(). 4
~MyClass(). 3
~MyClass(). 2
~MyClass(). 1
~MyClass(). 0

杂谈，不为人知的数组表达方式

先看程序=v=

int i = 4;
int a[10];
int j = 5;
int b[7][5];0[a] = 6;
9[a] = 7;
0[b][0] = 1;
0[1[b]] = 2;
0[b[2]] = 3;cout << (-1)[a] << endl;

看完之后，有什么想法么？
多数人可能会认为这个东西还是C/C++么？
不过很可惜……
这段程序在M$的编译器中 编译成功。

为什么这样？！可能有人要疯了。
慢，其实这个表达方式能够被认可，和第四节 数组与指针中的概念有关。

*a 等价于 *(a + 0) 等价于 a[0]
*(a + 5) 等价于 a[5]

有这样一个事实：
*(a + 0) 和 *(0 + a)要表达的东西是一样的。
所以可以推导出：
a[0] 等价于 *(a + 0) 等价于 *(0 + a) 等价于 0[a]
所以不难可以推导出二维的表达方式：
b[0][1] = *(b[0] + 1) = *(1 + b[0]) = 1[b[0]]
b[0][1] = *(b[0] + 1) = *(*(b + 0) + 1) = *(*(0 + b) + 1) = *(0[b] + 1) = 0[b][1]
b[0][1] = *(b[0] + 1) = *(*(b + 0) + 1) = *(*(0 + b) + 1) = *(1 + *(0 + b)) = *(1 + 0[b]) = 1[0[b]]

从这个例子可以看出，数组和指针有着非常亲密的关系^^

好，让我们喘一口气，怪谈还没完呢～
看看最后一个cout输出语句：
cout << (-1)[a] << endl;
(-1)[a]根据刚才的知识我们可以得出： (-1)[a] = a[-1] ……等等，-1？编译器怎么没报错？？

在C/C++里当然不会报，因为报了就违背C/C++的设计目标了——多管不用管的
那么再把这个式子转换一下，可以得到*(a - 1)
按照指针的概念，也就是前一个元素的东西，
因为a[0]是数组头了，-1会指向哪里呢？猜猜看～
或许有人会说是i，因为按照书写的顺序，i在数组a上面。
但代码书写并非编译器的实现，根据编译器的实现，还有有没有开启优化，结果是不一样的
按照我目前手头的编译器（见文章的开头），采用DEBUG模式编译出来，输出的结果是5
也就是指向了j。

在80x86体系结构，Windows系列操作系统下，栈在内存中从大地址->小地址方向扩展。
换句话说，栈底在大地址，栈顶在小地址。
这样，压入参数的时候，i被压在了大地址上，也就是下方，
然后数组a压在i的上方，因为数组的顺序还是要沿着地址增长的方向扩展
所以a[0]在上方，a[9]在下方，
然后j又压在了a[0]的上方，所以a[-1]也就是j了。

再换句话说，这也就是所谓的栈溢出！
列出该程序执行该段程序时，栈的情况的话：

刚才我们在a[-1]，也就是j，现在我们把矛头转一下，直接对准返回地址。
按照栈的情况来看，返回地址用数组a来解释就是a[12]，稍微修改一下程序。
在函数结束前增加一行代码：
a[12] = 0;

顺利通过编译，嗯
执行……！调试器跳出，说有Access Violation
看一下当前EIP指针，果然等于0
程序也就这么被栈溢出给抹杀掉了（其实是操作系统抹杀了该程序，栈溢出的行为应该属于借刀杀人=v=）

不过一般非故意的栈溢出不会这么有针对性，都是循环失控导致的，这样会把栈一路上的地址全部破坏掉。
所以一般那些检查栈溢出的代码（DEBUG模式下有些编译器会插入），在栈帧两端设防，
一旦设防标志被破坏就认为发生了栈溢出，所以大多数非故意的栈溢出还是能够通过特定代码监测出来的:-)

数组的迭代与性能影响

从简单的角度出发，我们考虑两维静态数组。
对于数组a[i][j]，采用两层循环来迭代，应该把个索引放外面，哪个索引放里面？
如果从理论上来讲，我们知道m固定的情况下，j中的元素是连续的，
又因为高速缓存读入数据时候按块来读，所以尽量应该使最近访问的数据都在连续的内存上。
那么我们得出了答案， 也就是i放外面，j放里面，写成程序就是：

#define MAX_I 1024 * 1024
#define MAX_J 1024 * 512
int a[MAX_I][MAX_J];
for (int i = 0; i < MAX_I; i++)for (int j = 0; j < MAX_J; j++)a[i][j] = 1;

但理论归理论，还是需要实践才是真理！
编写程序，对a[i][j]进行写入测试，测量工具采用CPU指令RDTSC

RDTSC
卷绕周期为172年
精度±0.001微妙（3.4GHz处理器）（受电源管理和乱序执行的影响）
秒转换：秒数 = 两次测试的差值 / 计算机CPU的频率

测试程序：

#define MAX_I 32 * 512
#define MAX_J 32 * 512
int g_array[MAX_I][MAX_J];inline unsigned __int64 GetTick()
{__asm RDTSC
}int main(int argc, char** argv)
{__int64 t1;t1 = GetTick();for (int i = 0; i < MAX_I; i++)for (int j = 0; j < MAX_J; j++)g_array[i][j] = 1;cout << GetTick() - t1 << endl;t1 = GetTick();for (int j = 0; j < MAX_J; j++)for (int i = 0; i < MAX_I; i++)g_array[i][j] = 1;cout << GetTick() - t1 << endl;
}

测试用机：
Intel(R) Core(TM)2 CPU T7400 2.16GHz 2.16GHz
2.00GB内存

通过测试可见，两种方式导致的性能差别几乎达到了10倍。
虽然现在机器越来越快，但不良的数据结构或者错误的算法导致的延迟还是存在的。
要消除各种耗时操作确实不是一项简单的事情，因为优化需要很多知识和经验。
由于主要还是讲数组的问题，这小节也不能扩展得太大，
至于如何优化程序结构，这还是一个比较大的主题，如果有机会的话就写写看吧^^

静态数组和动态数组 内存分布相关推荐

1. C++数组之动态数组

   目录 1.摘要 2.动态数组内存分配 1一维数组 2多维数组(以2维为例) 3.动态数组初始化 1默认初始化 2.自定义初始化 4.动态数组释放 5.例子 Gradebook类的实现 6.参考文章 1 ...

2. java封装数组_Java封装数组之动态数组实现方法详解

   本文实例讲述了Java封装数组之动态数组实现方法.分享给大家供大家参考,具体如下: 前言:在此之前,我们封装的数组属于静态数组,也即数组空间固定长度,对于固定长度的数组当元素超过容量时会报数组空间不足 ...

3. 数据结构之数组及动态数组剖析

   数据结构之数组及动态数组剖析 文章目录 数据结构之数组及动态数组剖析 概述 动态数组实现的原理 实践编写动态数组类 时间复杂度分析 数组对数器 参考代码 相关链接 公众号 参考 概述 数组是在程序设计 ...

4. java二维数组添加元素_Java二维数组与动态数组ArrayList类详解

   java二维数组 java 语言中提供的数组是用来存储固定大小的同类型元素. 1.二维数组初始化和声明 数组变量的声明,和创建数组可以用一条语句完成,如下所示: int a[][] = new int ...

5. vector，数组，动态数组效率测试

   对vector.数组.new创建的动态数组.预先reverse的vector测试代码如下: #include <iostream> #include <vector> #inc ...

6. 多维数组的组织结构和内存分布规律

   1  数组是什么? 多个相同数据类型变量构成的集合就是数组,比如int a[2]; int b[6]. 2  为什么C语言要设计数组这个概念? 因为很多场合下需要把一堆相同类型的数据存放在内存中,而数 ...

7. c++ 构造函数数组_“动态数组”的设计与实现

   引言 数据结构是计算机存储.组织数据的方式.常见的数据结构有: (1)线性结构 如:线性表(包括:数组.链表.栈.队列.哈希表). (2)树形结构 如:二叉树.AVL树.红黑树.B树.堆.Trie.哈 ...

8. java 动态二维数组_Java数组、动态数组、二维数组的应用

   一.认识数组 1.容器的概念 ​用于存储数据的一块内存称为容器,生活中有很多容器,例如水杯,衣柜,以及存放"东西" ​存放在容器中的数据,称为"元素" 2.为什 ...

9. arraylist 初始化_Java二维数组和动态数组ArrayList 类

   Java二维数组 Java 语言中提供的数组是用来存储固定大小的同类型元素. 1.二维数组初始化和声明 数组变量的声明,和创建数组可以用一条语句完成,如下所示: int a[][] = new int ...

最新文章

1. Python字节到大整数的打包与解包
2. 基于注解的Spring MVC整合Hibernate（所需jar包，spring和Hibernate整合配置，springMVC配置，重定向，批量删除）
3. .net core MongoDB 初试
4. C++模板类嵌套类内部类局部类的区别
5. mongoVUE查询
6. ASCII码16进制对照表
7. winrar5.31 专用激活key
8. win10系统CUDA10.0安装教程（for tensorflow2.0）
9. SQL2008升级SQL2008R2完全教程
10. PHP call_user_func_array回调函数 call_user_func_array函数详解
11. nginx服务器添加微信小程序校验文件
12. 2014第六届云计算大会参会体会和个…
13. 输入一个字符串，判断它的所有字符中否全部是大写字母，如不是，统计小写字母个数，并将其转换成大写字母后输出
14. python编程期末试题_大学moocPython编程基础期末考试答案
15. Godaddy无缝切换SSL，无需续费可省12美元
16. Docker容器之间数据传输
17. 成长的力量－－销售技巧
18. 9 个美观大气的后台管理系统（收藏备用）
19. 退出华为的时候,我在想些什么
20. shiro使用md5salt哈希散列加密

热门文章

1. 清空缓存的命令_最实用的6个网络命令，网络故障不求人
2. 七桥问题属于计算机科学方法论中的,计算机科学与技术方法论-计算学科中的科学问题ppt...
3. 正则表达式给html添加属性,正则表达式替换html元素属性的方法
4. android可点击的列表,如何在Android的可扩展列表视图中的子点击...
5. hibernate版本_Myeclipse 2020.5 版本首发！支持 Java14
6. json文件转为excel_2分钟上手、3小时学会无代码软件开发---XML、Json处理
7. 简述一下动态sql的执行原理_简述一下Pogo Pin电连接器的设计原理和考虑因素
8. 我们学的技术会过时吗？甚至被淘汰？
9. 华为被超越！这家公司成中国最大智能手机制造商，不是小米！
10. java 文件通配符_Java中泛型通配符的使用方法示例