数组是几乎所有编程语言都提供的基础数据结构。访问数组元素虽然看起来只是写一个方括号加下标，但背后的寻址过程、不同语言的实现差异以及多维数组的存储顺序，会直接影响程序的正确性和性能。理解数组元素是如何被定位的，有助于写出更高效、更安全的代码。
一、一维数组的连续存储与下标偏移
一维数组在内存中占据一段连续空间。声明一个整型数组后，系统会为它分配一块大小等于元素个数乘以单个元素字节数的内存。数组名通常代表这段空间的首地址，也就是第0个元素的起始位置。访问第i个元素时，程序并不需要从头遍历，而是直接通过地址计算公式定位。
以C语言为例，假设int类型占4字节，数组首地址为base，那么下标为i的元素地址可以表示为base + i * 4。这里下标从0开始，刚好让偏移量等于i与元素大小的乘积。如果下标从1开始，计算时就还要减去1，增加额外开销。因此C、Java、Python等语言普遍采用从0开始的下标规则。
#include <stdio.h>
int main() {
int arr[5] = {10, 20, 30, 40, 50};
printf("%dn", arr[0]);
printf("%dn", arr[2]);
printf("%dn", arr[4]);
return 0;
}
这段代码依次访问数组的第一个、第三个和最后一个元素。虽然方括号中写的是下标，但编译器在生成机器码时，会把它转换为基础地址加上偏移量的寻址操作。对连续内存来说，这种计算复杂度是常数级别，与数组长度无关，这也是数组随机访问效率高的根本原因。
需要注意的是，下标本身不一定是整数常量，也可以是变量或表达式。只要表达式的结果是合法的下标范围，就能访问对应元素。例如arr[i + 1]会先计算i + 1的值，再按照同样公式定位。这个特性让循环遍历数组变得非常方便。
二、不同编程语言中的下标访问语法
主流语言大多使用方括号加下标的方式访问数组，但细节上存在差异。C和Java要求数组在声明时确定长度，访问时必须使用整数下标，且不会自动检查下标是否越界。Python的列表虽然支持负数下标和切片，但其底层仍然是连续指针数组，负数下标只是对正向下标的一种换算。
Java数组是对象，拥有length属性，可以通过arr.length获取长度。Java在数组访问时也会执行越界检查，一旦下标为负数或超出范围，会抛出ArrayIndexOutOfBoundsException。Python的列表访问更加灵活，arr[-1]表示最后一个元素，arr[-2]表示倒数第二个元素，这在处理序列数据时很方便。
public class ArrayAccess {
public static void main(String[] args) {
int[] arr = {10, 20, 30, 40, 50};
System.out.println(arr[0]);
System.out.println(arr[arr.length - 1]);
}
}
JavaScript的数组同样使用方括号访问，但它本质上是一种对象，下标会被转换成字符串键。访问不存在的下标不会报错，而是返回undefined。这与C、Java的严格数组模型不同。不过在现代JavaScript引擎中，连续数字下标的数组仍然会使用优化后的连续内存存储，以提升访问速度。
const arr = [10, 20, 30, 40, 50]; console.log(arr[0]); console.log(arr[arr.length - 1]); console.log(arr[10]);
无论语法如何变化，常见的下标访问最终都可以归结为对连续内存或引用数组的定位。理解语言差异有助于在跨语言开发时避免把一种语言的习惯误用到另一种语言中。
三、指针访问：C/C++中的另一种方式
C和C++允许直接操作内存地址，因此数组元素除了通过下标访问，还可以通过指针运算访问。数组名在大多数表达式中会退化为指向首元素的指针。对一个指向数组首地址的指针执行加法，并不是简单地在地址值上加一个数字，而是加上元素大小乘以偏移量。
例如arr + 2并不是把首地址加2字节，而是加上2个int的大小。如果int占4字节，那么实际地址增加8字节。因此*(arr + 2)与arr[2]完全等价。反过来，arr[2]在编译器内部也会被转换为*(arr + 2)的形式。这种等价关系说明下标访问和指针访问只是同一操作的两种写法。
#include <stdio.h>
int main() {
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;
for (int i = 0; i < 5; i++) {
printf("%d ", *(p + i));
}
printf("n");
for (int i = 0; i < 5; i++) {
printf("%d ", p[i]);
}
printf("n");
return 0;
}
上面两个循环输出完全相同。第一个循环显式使用指针加法和解引用，第二个循环在指针变量上使用下标语法。C语言标准规定，p[i]等价于*(p + i)，所以即使p不是数组名而是一个指针，也可以使用下标访问。
指针访问的优势在于可以方便地移动遍历起点，例如p++后再次解引用，就能访问下一个元素。但这种灵活性也带来了风险：指针可以指向数组之外的地址，一旦解引用就会产生未定义行为。使用指针访问时必须由程序员自己保证偏移量不越界，这也是很多缓冲区溢出漏洞的来源。
四、多维数组的访问方式与遍历顺序
多维数组可以理解为一维数组的嵌套。以二维数组为例，它在内存中仍然是一段连续空间，但需要约定行和列的排列方式。C、C++、Java等语言采用行优先存储，即先存放第一行的所有元素，再存放第二行，以此类推。Fortran和MATLAB则采用列优先存储，先存放第一列的所有元素。
行优先意味着二维数组a[2][3]在内存中的顺序是a[0][0]、a[0][1]、a[0][2]、a[1][0]、a[1][1]、a[1][2]。访问a[i][j]时，偏移量等于i乘以列数再加上j。因此，遍历时按照行优先顺序访问，可以让内存访问基本保持连续，提高缓存命中率。如果反过来按列遍历，每次访问可能跳跃一段内存，性能会明显下降。
#include <stdio.h>
int main() {
int a[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", a[i][j]);
}
printf("n");
}
return 0;
}
在上面的代码中，外层循环按照行变化，内层循环按照列变化。由于C语言使用行优先存储，访问顺序与内存排列顺序一致，因此空间局部性很好。如果交换循环顺序，先固定列再变化行，访问的地址就会跳跃，数据量较大时会产生大量缓存未命中。
除了静态二维数组，Java中还可以使用数组的数组来表示二维结构。这种结构每一行是一个独立的一维数组，行的长度可以不同。访问方式仍然是a[i][j]，但它实际是先找到第i个行引用，再在该行内通过下标j定位元素，与C语言中连续二维数组的单纯地址计算略有区别。
五、越界访问与安全访问方式
数组访问最常见的问题就是越界。下标为负数或超过数组长度时，C和C++不会在运行时检查，程序可能读取到相邻内存的数据，或者覆盖其他变量，造成难以排查的错误。这类问题在大型系统中尤其危险，因为错误不一定立即暴露，可能在后续运行中才表现出异常。
Java、C#、Python、JavaScript等语言对普通下标访问提供了不同程度的保护。Java和C#会抛出异常，Python会抛出IndexError，JavaScript访问不存在下标时返回undefined而不会崩溃。虽然检查会带来一定运行时开销，但现代虚拟机可以通过优化减少大部分成本，对大多数应用来说，安全性收益远大于性能损失。
arr = [10, 20, 30, 40, 50]
print(arr[0])
print(arr[-1])
try:
print(arr[10])
except IndexError as e:
print("访问越界:", e)
为了避免越界，访问前应先确认下标范围。对C和C++来说，可以显式比较下标与数组长度；在C++中还可以使用std::array或std::vector的at()成员函数，它会在越界时抛出std::out_of_range异常。普通下标访问operator[]则不做检查，性能更高但需要开发者自行保证。
安全访问的另一个思路是使用迭代器或范围for循环，避免手动管理下标。C++的范围for、Java的增强for、Python的for-in以及JavaScript的for-of，都能在不直接接触下标的情况下遍历数组。这样既能减少越界概率，也能让代码意图更清晰。