C语言多维数组的申明：long cArr[3][10];
VB语言的多维数组的申明：dim vbArr(2,9) as long,这里假设Option Base 0，这里只说数组数据的实际存储，不考虑SafeArr结构，关于vb数组的SafeArr结构测试在另外一篇文章中。
那么C语言的多维数组和VB语言的多维数组在内存中的存储方式到底是什么样的呢？两个一样还是不一样呢？下面我们来通过实验来验证它们的存储排列方式。
       一、对于一维数组，两种语言在内存中的存储排列方式是一样的，都是按行顺序存储排列的，即：
              C语言：cArr[0][0]->cArr[0][9]->cArr[1][0]->cArr[1][9]->cArr[2][0]->cArr[2][9]

              VB语言：vbArr(0,0)->vbArr(0,9)->vbArr(1,0)->->vbArr(1,9)->->vbArr(2,0)->->vbArr(2,9)

       二、对于多维数组，这两种语言的存储排列方式就有了差别，C语言是按行顺序排列的，VB语言是按列顺序存储排列的，下面使用二维数组的一个实验来证明这一点。
             C语言源码：
int main()
{
 long cArr[3][10];
 int r;
 int i,j;
 int n;
 n=0;
 printf("i=0 ");
 for(i=0;i<3;i++)
 for(j=0;j<10;j++){
 cArr[i][j]=(i*10+j);
 if (n!=i){
 printf("\n");
 n=i;
 printf("i=%d ",i); 
 }
 
 printf("%d ",cArr[i][j]);
 }
 printf("\n-----------------------------------------------------------------------------\n");
 n=0;
 printf("i=0 ");
 for(i=0;i<3;i++)
 for(j=0;j<10;j++){
 if (n!=i){
 printf("\n");
 n=i;
 printf("i=%d ",i); 
 }
 printf("%p ",&cArr[i][j]);
 }
}

             运行结果：

i=0 0 1 2 3 4 5 6 7 8 9
i=1 10 11 12 13 14 15 16 17 18 19
i=2 20 21 22 23 24 25 26 27 28 29
-----------------------------------------------------------------------
i=0 0028FEC0 0028FEC4 0028FEC8 0028FECC  0028FED0 0028FED4  0028FED8  0028FEDC 0028FEE0  0028FEE4
i=1 0028FEE8 0028FEEC 0028FEF0  0028FEF4  0028FEF8  0028FEFC  0028FF00   0028FF04  0028FF08  0028FF0C

i=2 0028FF10 0028FF14 0028FF18  0028FF1C  0028FF20  0028FF24  0028FF28   0028FF2C  0028FF30  0028FF34
从源码和运行结果大家可以看到，使用cArr[0][0]这样下标的方式取得到数据，先是cArr[0][0]->cArr[0][9],然后是cArr[1][0]->cArr[1][9]，再后来是cArr[2][0]->cArr[2][9]，数据是连续存放的，那么它们的存储地址是多少呢？看横线的下面，cArr[0][0]的内存地址从0028FEC0开始，每一个数据都比上一个数据的存储地址都增加了4个字节，证明一维是连续存放的；现在看cArr[0][9]到cArr[1][0]也是连续的，从地址0028FEE4到 0028FEE8，看cArr[1][9]到cArr[2][0]也是连续的，从地址0028FF0C到 0028FF10，通过以上实验可以看出C语言的多维数组在内存中数据存储方式是按行连续存放的。下面看Vb的多维数组存储方式会不会一样呢？
        VB源代码：

Private Sub Command1_Click()
Dim VbArr(2, 9) As Long
Dim i As Integer, j As Integer

Dim p As Long

Debug.Print "输出值:"

For i = 0 To UBound(VbArr, 1)

    Debug.Print i,
    For j = 0 To UBound(VbArr, 2)
    
        VbArr(i, j) = i * 10 + j
        
        Debug.Print Format(VbArr(i, j), "    00    ");
        
    Next
    
    Debug.Print
    
Next

Debug.Print "---------------------------------------------------------------------------------------------------------------------------------"
Debug.Print "输出地址"
For i = 0 To UBound(VbArr, 1)

    Debug.Print i,
    For j = 0 To UBound(VbArr, 2)
    
        p = VarPtr(VbArr(i, j))
        
        Debug.Print Format(p, "00000000 ");
        
    Next
    
    Debug.Print
    
Next
End Sub
VB语言的输出结果如下：
输出值:
 0                00        01        02        03        04        05        06        07        08        09    
 1                10        11        12        13        14        15        16        17        18        19    
 2                20        21        22        23        24        25        26        27        28        29    
---------------------------------------------------------------------------------------------------------------------------------
输出地址
 0     129810376 129810388 129810400 129810412 129810424 129810436 129810448 129810460 129810472 129810484 
 1     129810380 129810392 129810404 129810416 129810428 129810440 129810452 129810464 129810476 129810488 
 2     129810384 129810396 129810408 129810420 129810432 129810444 129810456 129810468 129810480 129810492 

      (1) VbArr(0,0)的存储地址是129810376，VbArr(0,1)的存储地址是129810388，这两个差12个字节，因为数组是长整型数组，每个元素占4个字节，所以说这两个地址不是连续地址,以此类推,按行排列的地址,相邻两地址都差12个字节,正好是三个元素占用的地址,即每列的行数*每个元素占用字节数,正好是12个字节。
     (2) VbArr(0,0)的存储地址是129810376，VbArr(1,0)的存储地址是129810380，这两个差4个字节，因为数组是长整型数组，每个元素占4个字节，所以说这两个地址是连续地址,是列相连。

     (3) VbArr(2,0)的存储地址是129810384，VbArr(0,1)的存储地址是129810388，这两个差4个字节，因为数组是长整型数组，每个元素占4个字节，所以说这两个地址是连续地址。
     (4)  通过对vb字符串多维数组进行分析,数据也是按列的顺序存放的.
以此类推，可以推算出，VB多维数组是按列排列存储，是一列一列的连续存放的。

 
 
在C++ 中，数组在内存的分配情况如何呢？我们可以编写如下程序，可以读取到一个二维数组的每一个元素在内存中的地址，为了更清楚的了解，我在这里采用了两种遍历方式：
 
 
#include "stdafx.h"
#include <iostream>

using namespace std;

/* 查看数组的内存分配 */
void Array_Memory_Allocate()
{
	int Arr[3][4];
	for(int i = 0 ; i < 3 ; i++)
	{
		for(int j = 0 ; j < 4 ; j++)
		{
			cout << "Arr[" << i << "][" << j << "]: " << &Arr[i][j] << endl;
		}
	}

	cout << "\n\n" ;

	for(int j = 0 ; j < 4 ; j++)
	{
		for(int i = 0 ; i < 3 ; i++)
		{
			cout << "Arr[" << i << "][" << j << "]: " << &Arr[i][j] << endl;
		}
	}

}


int _tmain(int argc, _TCHAR* argv[])
{
	Array_Memory_Allocate();
	return 0;
}

 


 
 

 
 
C++中，二维数组中元素排列的顺序是：按行存放,即在内存中先顺序存放第一行的元素，再存放第二行的元素。下图表示对a[3][4]数组存放的顺序｡
 
 
 
 
 
 
 
 

 
C++允许使用多维数组。有了二维数组的基础，再掌握多维数组是不困难的。例如，定义三维数组的方法是：

 
   float a[2][3][4];

 
定义float型三维数组a，它有2×3×4=24个元素。 
 
多维数组元素在内存中的排列顺序：第一维的下标变化最慢，最右边的下标变化最快。例如，上述三维数组的元素排列顺序为：
 a[0][0][0]→a[0][0][1]→a[0][0][2]→a[0][0][3]→a[0][1][0]→a[0][1][1]→a[0][1][2]→a[0][1][3]→a[0][2][0]→a[0][2][1]→a[0][2][2]→a[0][2][3]→a[1][0][0]→a[1][0][1]→a[1][0][2]→a[1][0][3]→a[1][1][0]→a[1][1][1]→a[1][1][2]→a[1][1][3]→a[1][2][0]→a[1][2][1]→a[1][2][2]→a[1][2][3]

 
 
  
 1 Private Declare Sub RtlMoveMemory Lib "kernel32" (Destination As Any, Source As Any, ByVal Length As Long)
 2 
 3 
 4 'code by lichmama from cnblogs.com
 5 Private Sub Form_Load()
 6     Dim a(2) As Byte
 7     Dim b(2, 2) As Byte
 8     Dim c(2, 2, 2) As Byte
 9     
10     Debug.Print "一维数组："
11     Debug.Print VarPtr(a(0)), VarPtr(a(1)), VarPtr(a(2))
12     '数组元素在内存中的排列情况：
13     'a[0]|a[1]|a[2]
14     
15     Debug.Print "二维数组："
16     Debug.Print VarPtr(b(0, 0)), VarPtr(b(1, 0)), VarPtr(b(2, 0))
17     Debug.Print VarPtr(b(0, 1)), VarPtr(b(1, 1)), VarPtr(b(2, 1))
18     Debug.Print VarPtr(b(0, 2)), VarPtr(b(1, 2)), VarPtr(b(2, 2))
19     '数组元素在内存中的排列情况：
20     'b[0,0]|b[1,0]|b[2,0]-->b[0,1]|b[1,1]|b[2,1]-->b[0,2]|b[1,2]|b[2,2]
21     
22     Debug.Print "三维数组："
23     Debug.Print VarPtr(c(0, 0, 0)), VarPtr(c(1, 0, 0)), VarPtr(c(2, 0, 0))
24     Debug.Print VarPtr(c(0, 1, 0)), VarPtr(c(1, 1, 0)), VarPtr(c(2, 1, 0))
25     Debug.Print VarPtr(c(0, 2, 0)), VarPtr(c(1, 2, 0)), VarPtr(c(2, 2, 0))
26     Debug.Print VarPtr(c(0, 0, 1)), VarPtr(c(1, 0, 1)), VarPtr(c(2, 0, 1))
27     Debug.Print VarPtr(c(0, 1, 1)), VarPtr(c(1, 1, 1)), VarPtr(c(2, 1, 1))
28     Debug.Print VarPtr(c(0, 2, 1)), VarPtr(c(1, 2, 1)), VarPtr(c(2, 2, 1))
29     Debug.Print VarPtr(c(0, 0, 2)), VarPtr(c(1, 0, 2)), VarPtr(c(2, 0, 2))
30     Debug.Print VarPtr(c(0, 1, 2)), VarPtr(c(1, 1, 2)), VarPtr(c(2, 1, 2))
31     Debug.Print VarPtr(c(0, 2, 2)), VarPtr(c(1, 2, 2)), VarPtr(c(2, 2, 2))
32     '数组元素在内存中的排列情况：
33     'c[0,0,0]|c[1,0,0]|c[2,0,0]-->c[0,1,0]|c[1,1,0]|c[2,1,0]-->c[0,2,0]|c[1,2,0]|c[2,2,0]
34     '-->c[0,0,1]|c[1,0,1]|c[2,0,1]-->c[0,1,1]|c[1,1,1]|c[2,1,1]-->c[0,2,1]|c[1,2,1]|c[2,2,1]
35     '-->c[0,0,2]|c[1,0,2]|c[2,0,2]-->c[0,1,2]|c[1,1,2]|c[2,1,2]-->c[0,2,2]|c[1,2,2]|c[2,2,2]
36     
37     '我们习惯逻辑上这么给数组赋值，字面上像是b()="lhmimaca!"
38     b(0, 0) = &H6C: b(0, 1) = &H68: b(0, 2) = &H6D
39     b(1, 0) = &H69: b(1, 1) = &H6D: b(1, 2) = &H61
40     b(2, 0) = &H63: b(2, 1) = &H61: b(2, 2) = &H21
41     
42     Dim text As String
43     text = String(9, " ")
44     Call RtlMoveMemory(ByVal StrPtr(text), ByVal VarPtr(b(0, 0)), 9)
45     Debug.Print "但，其实结果是这样的：";
46     Debug.Print StrConv(text, vbUnicode)
47 End Sub
 
 
 
 
 
 
 
看结果说话（内存地址打印）：
 
 
 
  
一维数组：
 2031464       2031465       2031466 
二维数组：
 2048432       2048433       2048434 
 2048435       2048436       2048437 
 2048438       2048439       2048440 
三维数组：
 2059256       2059257       2059258 
 2059259       2059260       2059261 
 2059262       2059263       2059264 
 2059265       2059266       2059267 
 2059268       2059269       2059270 
 2059271       2059272       2059273 
 2059274       2059275       2059276 
 2059277       2059278       2059279 
 2059280       2059281       2059282 
但，其实结果是这样的：lichmama!         
 
 
 
转载于:https://www.cnblogs.com/lichmama/p/3840148.html

 

 

  
 
 
 
什么是数组
 
所谓数组，是具有相同数据类型的若干变量或者数据按照一定排序规则组合起来的一种数据存储格式。数组中的数据称为数组元素，我们使用索引来标识数组元素在数组中的存储位置，索引从0开始，步长是1，其后的索引依次递增：
 

 

  
 
 
 
其中，数据类型包括以下两种：
 
基本数据类：byte,short,int,long,float,double,char,boolean
 
引用数据类型：类,接口,数组，基本数据类型的包装类也数据引用数据类型
 
数组的定义
 
方式1：数据类型[] 数组名; 如：int[] ages; 推荐使用此方式创建数组。
方式2：数组元素的类型 数组名[]; int ages[]; 此方法不推荐
 
数组的初始化
 
数组必须先初始化，才能使用，也就是要先为数组和数组元素在JVM内存模型中分配空间，给每个数组元素赋初始值，初始值可以在创建数组时指定，也可以只指定数组长度，然后使用对应数据类型的默认值作为其初始值，下图是各个数据类型的默认值：
 

 

  
 
 
 
null 表示没有指向任何存储空间，是空值；如果将null赋予对象，则表示该对象引用为空，将会被GC回收，使用此对象调用方法，或者操作数据会触发NullPointerException(空指针异常)。
 
初始化数组有两种方式：静态初始化 和 动态初始化；但是无论以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，数组中的元素个数也就已经固定了，不能改变，所以说数组是固定长度的。
 
数组的静态初始化： 由我们（程序员们）来为每一个数组元素设置初始化值，也就是说知道要在数组中存储哪些数据；此时数组的长度JVM根据设置的初始值来分配，不需要再设置
 
语法如下：
 

 

  
 
 
 
创建数组时，JVM也会为其分配数据存储区域；所以，在JVM中创建一个数组时内存模型是这样的：
 

 

  
 
 
 
数组的动态初始化：由我们（程序员们）来设置数组长度)，而数组中元素的初始值由JVM赋予；语法：
 

 

  
 
 
 
但是， 不能同时使用静态初始化和动态初始化，比如：
 
int[] nums = new int[3]{13, 14, 520}; // 这种写法是错误的。
 
那么什么时候使用静态初始化，什么时候使用动态初始化呢？
 
如果提前知道需要存储的数据,优先选用静态初始化，否则使用动态初始化来创建数组；
知道数组长度时，优先使用动态初始化；
数组长度和需要存储的数据都知道时，两种方式都可以，任选其一即可；
 

 

  
 
 
 
数组基本操作:
 
获取元素: 元素类型 变量 = 数组名[index];
设置元素: 数组名[index] = 值;
数组长度: int len = 数组名.length; 注意这里的length是属性，不是方法，从调用上方式上也能看出来；
索引范围: 从0开始，逐一递增. 直至 length-1：[0，length-1]
最大值：getMax()
最小值：getMin()
 
数组常见异常:
 
NullPointerException：空指针异常，数组或者变量未初始化就直接操作时会触发；
ArrayIndexOutOfBoundsException：数组的索引越界异常，获取数组元素时使用的索引超出了数组的索引范围时会触发。
 
元素在数组中的位置索引：
 
元素在数组中第一次出现的位置的索引：indexOf()
元素在数组中最后一次出现的位置的索引：lastIndexOf()
 
数组在main函数中的应用
 

 

  
 
 
 
可以接收传入的参数，一般是提供给用户传入参数来完成一些特定的操作的。
 
多维数组
 
多维数组：以数组为数据类型创建数组，也就是数组中的数组，如：二维数组可以这样来初始化:
 
静态初始化
 

 

  
 
 
 
动态初始化
 

 

  
 
 
 
多维数组的取值
 
int[1][1] : 表示第2个一维数组的第2个元素；
 
创建多维数组时，JVM为多维数组分配内存；所以，多维数组的内存模型在JVM 中是这样的：
 

 

  
 
 
 
一维数组：数组中的每一个元素都是一个值(基本类型或者引用类型)。
 
二维数组：数组中的每一个元素是一个一维数组。
 
三维数组：数组中的每一个元素是一个二维数组。
 
依次类推。
 
杨辉三角
 
杨辉三角就是一个典型的多维数组实例：它的规律是每行起始和结束两个数都是1，每个数都等于它的上方两个数之和，详情如下图所示：
 

 

  
 
 
 
杨辉三角是二项式系数在三角形中的一种几何排列，最早出现于北宋贾宪的《黄帝九章算经细草》，后被南宋数学家杨辉抄录于《详解九章算法》一书。在Java中可以使用多维数组打印杨辉三角，代码如下：
 

 

  
 
 
 
foreach
 
我们在使用循环迭代数组的时候，有时候并不关心迭代元素的索引，迭代数组元素的时候，直接操作数组元素，不关心操作数组的索引。所以，从Java5开始(JDK1.5)开始，Java提供了一种新的语法，foreach（增强for循环）语法如下:
 

 

  
 
 
 
通过foreach，我们便可以快速迭代出数组中的元素：
 

 

  
 
 
 
接下来，通过反编译字节码文件，看看JVM是如何实现foreach的：
 

 

  
 
 
 
不难发现，foreach其实在底层依然是使用for循环+索引来操作数组的，虽然把foreach称为增强for循环，但其底层依然是使用for循环实现的，我们将其称之为语法糖，目的就是为了吸引开发者，让开发者写更少的代码，这恰恰也是开发者们乐意愿意看到的。
 
foreach虽然会少些很多代码，但论性能，灵活性却不如for循环，所以如果只关心元素而不关心索引，首选foreach，其他情况下还是应该for循环；在集合中也是这样的道理。
 
可变参数
 
Java5还有另一个新特性：方法的可变参数，这里可变说的是参数的个数可变，并不是参数值可变，看如下的代码中，方法getArgsLength便使用了可变参数：
 

 

  
 
 
 
还是将其反编译，查看JVM对可变参数的实现；不难发现，方法的可变参数其实也是一个语法糖，因为其底层还是一个数组，因此，可以把可变参数类型当做一个数组来处理，比如元素输出：
 

 

  
 
 
 
可变参数的使用注意：
 
可变参数必须作为方法的最后一个参数，避免与其他参数产生歧义，引发异常；
 
方法最多只能有一个可变参数。
 
完结。老夫虽不正经，但老夫一身的才华