• C++ 基础教程
  • JavaScript入门教程
  • 博客文章
  • 访客留言
  • 联系站长
  • 论坛
  • 3.1 数组 (Arrays)

    数组(Arrays) 是在内存中连续存储的一组同种数据类型的元素(变量),每一数组有一个唯一名称,通过在名称后面加索引(index)的方式可以引用它的每一个元素。

    也就是说,例如我们有5个整型数值需要存储,但我们不需要定义5个不同的变量名称,而是用一个数组(array)来存储这5个不同的数值。注意数组中的元素必须是同一数据类型的,在这个例子中为整型(int)。

    例如一个存储5个整数叫做billy的数组可以用下图来表示:

    这里每一个空白框代表数组的一个元素,在这个例子中为一个整数值。白框上面的数字0 到4 代表元素的索引(index)。注意无论数组的长度如何,它的第一个元素的索引总是从0开始的。

    同其它的变量一样, 数组必须先被声明然后才能被使用。一种典型的数组声明显示如下:

    type name [elements];

    这里type 是可以使任何一种有效的对象数据类型(object type),如 int, float...等,name 是一个有效地变量标识(identifier),而由中括号[]引起来的elements 域指明数组的大小,即可以存储多少个元素。

    因此,要定义上面图中显示的 billy 数组,用一下语句就可以了:

    int billy [5];

    备注:在定义一个数组的时候,中括号[]中的elements 域必须是一个常量数值,因为数组是内存中一块有固定大小的静态空间,编译器必须在编译所有相关指令之前先能够确定要给该数组分配多少内存空间。

     

    初始化数组(Initializing arrays)

    当声明一个本地范围内(在一个函数内)的数组时,除非我们特别指定,否则数组将不会被初始化,因此它的内容在我们将数值存储进去之前是不定的。

    如果我们声明一个全局数组(在所有函数之外),则它的内容将被初始化为所有元素均为0。因此 ,如果全局范围内我们声明:

    int billy [5];

    那么billy 中的每一个元素将会被初始化为0:

    另外,我们还可以在声明一个变量的同时把初始值付给数组中的每一个元素,这个赋值用花括号{ }来完成。例如:

    int billy [5] = { 16, 2, 77, 40, 12071 };

    这个声明将生成如下数组:

    花括号中我们要初始化的元素数值个数必须和数组声明时方括号[ ]中指定的数组长度相符。例如,在上面例子中数组billy 声明中的长度为5,因此在后面花括号中的初始值也有5个,每个元素一个数值。

    因为这是一种信息的重复,因此C++允许在这种情况下数组[ ]中为空白,而数组的长度将有后面花括号{}中数值的个数来决定,如下例所示。

    int billy [] = { 16, 2, 77, 40, 12071 };

    存取数组中数值(Access to the values of an Array)

    在程序中我们可以读取和修改数组任一元素的数值,就像操作其他普通变量一样。格式如下:

    name[index]

    继续上面的例子,数组billy 有5个元素,其中每一元素都是整型int,我们引用其中每一个元素的名字分别为如下所示:

    例如,要把数值75存入数组billy 中第3个元素的语句可以是:

    billy[2] = 75;

    又例如,要把数组billy 中第3个元素的值赋给变量a,我们可以这样写:

    a = billy[2];

    因此,在所有使用中,表达式billy[2]就像任何其他整型变量一样。

    注意数组billy 的第3个元素为billy[2],因为索引(index)从0开始,第1个元素是billy[0],第2个元素是billy[1],因此第3个是 billy[2]。同样的原因,最后一个元素是billy[4]。如果我们写billy[5],那么是在使用billy的第6个元素,因此会超出数组的长度。

    在C++ 中对数组使用超出范围的index是合法的,这就会产生问题,因为它不会产生编译错误而不易被察觉,但是在运行时会产生意想不到的结果,甚至导致严重运行错误。超出范围的index 之所以合法的原因我们在后面学习指针(pointer)的时候会了解。

    学到这里,我们必须能够清楚的了解方括号[ ]在对数组操作中的两种不同用法。它们完成两种任务:一种是在声明数组的时候定义数组的长度;另一种是在引用具体的数组元素的时候指明一个索引号(index)。我们要注意不要把这两种用法混淆。

    int billy[5]; // 声明新数组(以数据类型名称开头)
    billy[2] = 75; // 存储数组的一个元素

    其它合法的数组操作:

    billy[0] = a; // a为一个整型变量
    billy[a] = 75;
    b = billy [a+2];
    billy[billy[a]] = billy[2] + 5;

     

    // arrays example
    #include <iostream.h>

    int billy [ ] = {16, 2, 77, 40, 12071};
    int n, result=0;

    int main () {
    for ( n=0 ; n<5 ; n++ ) {
    result += billy[n];
    }

    cout << result;
    return 0;
    }
    12206

     

    多维数组(Multidimensional Arrays)

    多维数组(Multidimensional Arrays)可以被描述为数组的数组。例如,一个2维数组(bidimensional array)可以被想象成一个有同一数据类型的2维表格。

    jimmy 显示了一个整型(int )的3x5二维数组,声明这一数组的的方式是:

    int jimmy [3][5];

    而引用这一数组中第2列第4排元素的表达式为:jimmy[1][3]

    (记住数组的索引总是从0开始)。

    多维数组(Multidimensional arrays)并不局限于2维。如果需要,它可以有任意多维,虽然需要3维以上的时候并不多。但是考虑一下一个有很多维的数组所需要的内存空间,例如:

    char century [100][365][24][60][60];

    给一个世纪中的每一秒赋一个字符(char),那么就是多于30亿的字符!如果我们定义这样一个数组,需要消耗3000M的内存。

    多维数组只是一个抽象的概念,因为我们只需要把各个索引的乘积放入一个简单的数组中就可以获得同样的结果。例如:

    int jimmy [3][5]; 效果上等价于
    int jimmy [15]; (3 * 5 = 15)

    唯一的区别是编译器帮我们记住每一个想象中的维度的深度。下面的例子中我们就可以看到,两段代码一个使用2维数组,另一个使用简单数组,都获得同样的结果,即都在内存中开辟了一块叫做jimmy的空间,这个空间有15个连续地址位置,程序结束后都在相同的位置上存储了相同的数值,如后面图中所示:

    // multidimensional array
    #include <iostream.h>
    #define WIDTH 5
    #define HEIGHT 3

    int jimmy [HEIGHT][WIDTH];
    int n,m;

    int main (){
    for (n=0; n<HEIGHT; n++) {
    for (m=0; m<WIDTH; m++)
    jimmy[n][m]=(n+1)*(m+1);
    }

    return 0;
    }
    // pseudo-multidimensional array
    #include <iostream.h>
    #define WIDTH 5
    #define HEIGHT 3

    int jimmy [HEIGHT * WIDTH];
    int n,m;

    int main (){
    for (n=0; n<HEIGHT; n++){
    for (m=0; m<WIDTH; m++)
    jimmy[n * WIDTH + m]=(n+1)*(m+1);
    }
    return 0;
    }

    上面两段代码并不向屏幕输出,但都向内存中的叫做jimmy的内存块存入如下数值:

    我们用了宏定义常量(#define)来简化未来可能出现的程序修改,例如,如果我们决定将数组的纵向由3扩大到4,只需要将代码行:

    #define HEIGHT 3

    修改为 :

    #define HEIGHT 4

    而不需要对程序的其他部分作任何修改。

     

    数组参数(Arrays as parameters)

    有时候我们需要将数组作为参数传给函数。在C++ 中将一整块内存中的数值作为参数完整的传递给一个函数是不可能的,即使是一个规整的数组也不可能,但是允许传递它的地址。它们的实际作用是一样的,但传递地址更快速有效。

    要定义数组为参数,我们只需要在声明函数的时候指明参数数组的基本数据类型,一个标识后面再跟一对空括号[]就可以了。例如以下的函数:

    void procedure (int arg[])

    接受一个叫做arg的整型数组为参数。为了给这个函数传递一个按如下定义的数组:

    int myarray [40];

    其调用方式可写为:

    procedure (myarray);

    下面我们来看一个完整的例子:

    // arrays as parameters
    #include <iostream.h>

    void printarray (int arg[ ], int length) {
    for (int n=0; n<length; n++) {
    cout << arg[n] << " ";
    }
    cout << "\n";
    }

    int main () {
    int firstarray[ ] = {5, 10, 15};
    int secondarray[ ] = {2, 4, 6, 8, 10};
    printarray (firstarray,3);
    printarray (secondarray,5);
    return 0;
    }
    5 10 15
    2 4 6 8 10

    可以看到,函数的第一个参数(int arg[ ])接受任何整型数组为参数,不管其长度如何。因此,我们用了第2个参数来告知函数我们传给它的第一个参数数组的长度。这样函数中打印数组内容的for 循环才能知道需要检查的数组范围。

    在函数的声明中也包含多维数组参数。定义一个3维数组 (tridimensional array) 的形式是:

    base_type[ ][depth][depth]

    例如,一个函数包含多维数组参数的函数可以定义为:

    void procedure (int myarray[ ][3][4])

    注意第一对括号[ ]中为空,而后面两对不为空。这是必须的,因为编译器必须能够在函数中确定每一个增加的维度的深度。

    数组作为函数的参数,不管是多维数组还是简单数组,都是初级程序员容易出错的地方。建议阅读章节3.3, 指针(Pointers),以便更好的理解数组(arrays)是如何操作的。