详解C++中的一维数组和二维数组

C++一维数组
定义一维数组

定义一维数组的一般格式为:
    类型标识符  数组名[常量表达式];
例如:

  int a[10];

它表示数组名为a,此数组为整型,有10个元素。

关于一维数组的几点说明:
1) 数组名定名规则和变量名相同,遵循标识符定名规则。

2) 用方括号括起来的常量表达式表示下标值,如下面的写法是合法的:

  int a[10];
  int a[2*5];
  int a[n*2]; //假设前面已定义了n为常变量

3) 常量表达式的值表示元素的个数,即数组长度。例如,在“int a[10];”中,10表示a数组有10个元素,下标从0开始,这10个元素是: a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7], a[8],a[9]。注意最后一个元素是a[9]而不是a[10]。

4) 常量表达式中可以包括常量、常变量和符号常量,但不能包含变量。也就是说,C++不允许对数组的大小作动态定义,即数组的大小不依赖于程序运行过程中变量的值。例如,下面这样定义数组是不行的:

  int n;
  cin>>n; //输入a数组的长度
  int a[n]; //企图根据n的值决定数组的长度

如果把第1,2行改为下面一行就合法了:

  const int n=5;

引用一维数组的元素

数组必须先定义,然后使用。只能逐个引用数组元素的值而不能一次引用整个数组中的全部元素的值。

数组元素的表示形式为:
    数组名[下标]
下标可以是整型常量或整型表达式。例如:

  a[0]= a[5]+ a[7]- a[2*3]

【例】数组元素的引用。

#include <iostream>
using namespace std;
int main( )
{
  int i, a[10];
  for (i=0;i<=9;i++)
   a[i]=i;
  for (i=9;i>=0;i--)
   cout<<a[i]<<" ";
  cout<<endl;
  return 0;
}

运行结果如下:

9 8 7 6 5 4 3 2 1 0

程序使a[0]~a[9]的值为0~9,然后按逆序输出。
一维数组的初始化

1) 在定义数组时分别对数组元素赋予初值。例如:

  int a[10]={0,1,2,3,4,5,6,7,8,9};

2) 可以只给一部分元素赋值。例如:

  int a[10]={0,1,2,3,4};

3) 如果想使一个数组中全部元素值为1,可以写成:

  int a[10]={1,1,1,1,1,1,1,1,1,1};

不能写成

  int a[10]={1*10};

不能给数组整体赋初值。

4) 在对全部数组元素赋初值时,可以不指定数组长度。例如:

  int a[5]={1,2,3,4,5};

可以写成

  int a[]={1,2,3,4,5};

一维数组程序举例

【例】用数组来处理求Fibonacci数列问题。

可以用20个元素代表数列中的20个数,从第3个数开始,可以直接用表达式f[i]=f[i-2]+f[i-1]求出各数。程序如下:

#include <iostream>
#include <iomanip>
using namespace std;
int main( )
{
  int i;
  int f[20]={1,1}; //f[0]=1,f[1]=1
  for(i=2;i<20;i++)
   f[i]=f[i-2]+f[i-1]; //在i的值为2时,f[2]=f[0]+f[1],依此类推
  for(i=0;i<20;i++) //此循环的作用是输出20个数
  {
   if(i%5==0) cout<<endl; //控制换行,每行输出5个数据
   cout<<setw(8)<<f[i]; //每个数据输出时占8列宽度
  }
  cout<<endl; //最后执行一次换行
  return 0;
}

运行结果如下:

【例】编写程序,用起泡法对10个数排序(按由小到大顺序)。

起泡法的思路是:将相邻两个数比较,将小的调到前头。见图5.2。然后进行第2趟比较,对余下的前面5个数按上法进行比较,见图。


可以推知,如果有n个数,则要进行n-1趟比较(和交换)。在第1趟中要进行n-1次两两比较,在第j趟中要进行n-j次两两比较。

根据以上思路写出程序,今设n=10,本例定义数组长度为11,a[0]不用,只用a[1]~a[10],以符合人们的习惯。从前面的叙述可知,应该进行9趟比较和交换。

#include <iostream>
using namespace std;
int main( )
{
  int a[11];
  int i, j, t;
  cout<<"input 10 numbers :"<<endl;
  for (i=1;i<11;i++) //输入a[1]~a[10]
   cin>>a[i];
  cout<<endl;
  for (j=1;j<=9;j++) //共进行9趟比较
   for(i=1;i<=10-j;i++)//在每趟中要进行(10-j)次两两比较
     if (a[i]>a[i+1]) //如果前面的数大于后面的数
     {
      t=a[i];a[i]=a[i+1];a[i+1]=t;
     }//交换两个数的位置, 使小数上浮
  cout<<"the sorted numbers :"<<endl;
  for(i=1;i<11;i++) //输出10个数
   cout<<a[i]<<" ";
  cout<<endl;
  return 0;
}

运行情况如下:

input 10 numbers:
3 5 9 11 33 6 -9 -76 100 123
the sorted numbers:
-76 -9 3 5 6 9 11 33 100 123

C++二维数组
具有两个下标的数组称为二维数组。有些数据要依赖于两个因素才能惟一地确定,例如有3个学生,每个学生有4门课的成绩,显然,成绩数据是一个二维表,如书中表所示。


想表示第3个学生第4门课的成绩,就需要指出学生的序号和课程的序号两个因素,在数学上以S3,4表示。在C++中以s[3][4]表示,它代表数据73。
定义二维数组

定义二维数组的一般形式为:
    类型标识符 数组名[常量表达式][常量表达式];
例如:

  float a[3][4], b[5][10];

定义a为3×4(3行4列)的单精度数组,b为5×10(5行10列)的单精度数组。注意不能写成“float a[3,4], b[5,10];”。C++对二维数组采用这样的定义方式,使我们可以把二维数组看作是一种特殊的一维数组:它的元素又是一个一维数组。例如,可以把a看作是一个一维数组,它有3个元素:a[0],a[1],a[2],每个元素又是一个包含4个元素的一维数组,见图5.4。a[0],a[1],a[2]是3个一维数组的名字。


上面定义的二维数组可以理解为定义了3个一维数组,即相当于:

  float a[0][4], a[1][4], a[2][4];

此处把a[0],a[1],a[2]作一维数组名。C++的这种处理方法在数组初始化和用指针表示时显得很方便,这在以后会体会到。

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

上面定义的二维数组可以理解为定义了3个一维数组,即相当于:

  float a[0][4], a[1][4], a[2][4];

此处把a[0],a[1],a[2]作一维数组名。C++的这种处理方法在数组初始化和用指针表示时显得很方便,这在以后会体会到。

C++中,二维数组中元素排列的顺序是:按行存放,即在内存中先顺序存放第一行的元素,再存放第二行的元素。图5.5表示对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]

二维数组的引用

二维数组的元素的表示形式为:

 数组名 [下标][下标]

如:

  a[2][3]

下标可以是整型表达式,如a[2-1][2*2-1]。不要写成a[2,3],a[2-1,2*2-1]形式。

数组元素是左值,可以出现在表达式中,也可以被赋值,例如:

  b[1][2]=a[2][3]/2;

在使用数组元素时,应该注意下标值应在已定义的数组大小的范围内。常出现的错误是:

  int a[3][4]; //定义3行4列的数组
  ┆
  a[3][4]=15; //引用a[3][4]元素

定义a为3×4的数组,它可用的行下标值最大为2,列坐标值最大为3。最多可以用到a[2][3],a[3][4]就超过了数组的范围。

请严格区分在定义数组时用的a[3][4]和引用元素时的a[3][4]的区别。前者a[3][4]用来定义数组的维数和各维的大小,后者a[3][4]中的3和4是下标值,a[3][4]代表某一个元素。
二维数组的初始化

可以用下面的方法对二维数组初始化:
1) 分行给二维数组赋初值。如

   int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

这种赋初值方法比较直观,把第1个花括号内的数据赋给第1行的元素,第2个花括号内的数据赋给第2行的元素……即按行赋初值。

2) 可以将所有数据写在一个花括号内,按数组排列的顺序对各元素赋初值。如

  int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

效果与前相同。但以第1种方法为好,一行对一行,界限清楚。用第2种方法如果数据多,写成一大片,容易遗漏,也不易检查。

3) 可以对部分元素赋初值。如:

  int a[3][4]={{1},{5},{9}};

它的作用是只对各行第1列的元素赋初值,其余元素值自动置为0。赋初值后数组各元素为:

1 0 0 0
5 0 0 0
9 0 0 0

也可以对各行中的某一元素赋初值:

  int a[3][4]={{1},{0,6},{0,0,11}};

初始化后的数组元素如下:

1 0 0 0
0 6 0 0
0 0 11 0

这种方法对非0元素少时比较方便,不必将所有的0都写出来,只需输入少量数据。也可以只对某几行元素赋初值:

  int a[3][4]={{1},{5,6}};

数组元素为:

1 0 0 0
5 6 0 0
0 0 0 0

第3行不赋初值。也可以对第2行不赋初值:

  int a[3][4]={{1},{},{9}};

4) 如果对全部元素都赋初值(即提供全部初始数据),则定义数组时对第一维的长度可以不指定,但第二维的长度不能省。如:

  int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

可以写成

  int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};

系统会根据数据总个数分配存储空间,一共12个数据,每行4列,当然可确定为3行。

在定义时也可以只对部分元素赋初值而省略第一维的长度,但应分行赋初值。如

  int a[][4]={{0,0,3},{},{0,10}};

这样的写法,能通知编译系统: 数组共有3行。数组各元素为:

0 0 3 0
0 0 0 0
0 10 0 0

C++在定义数组和表示数组元素时采用a[][]这种两个方括号的方式,对数组初始化时十分有用,它使概念清楚,使用方便,不易出错。
二维数组程序举例

【例】将一个二维数组行和列元素互换,存到另一个二维数组中。例如:


程序如下:

#include <iostream>
using namespace std;
int main( )
{
  int a[2][3]={{1,2,3},{4,5,6}};
  int b[3][2],i,j;
  cout<<"array a:"<<endl;
  for (i=0;i<=1;i++)
  {
   for (j=0;j<=2;j++)
   {
     cout<<a[i][j]<<" ";
     b[j][i]=a[i][j];
   }
   cout<<endl;
  }
  cout<<"array b:"<<endl;
  for (i=0;i<=2;i++)
  {
   for(j=0;j<=1;j++)
     cout<<b[i][j]<<" ";
   cout<<endl;
  }
  return 0;
}

运行结果如下:

array a:
 1 2 3
 4 5 6
array b:
 1 4
 2 5
 3 6

【例】有一个3×4的矩阵,要求编程序求出其中值最大的那个元素的值,以及其所在的行号和列号。

开始时把a[0][0]的值赋给变量max,然后让下一个元素与它比较,将二者中值大者保存在max中,然后再让下一个元素与新的max比,直到最后一个元素比完为止。max最后的值就是数组所有元素中的最大值。程序如下:

#include <iostream>
using namespace std;
int main( )
{
  int i,j,row=0,colum=0,max;
  int a[3][4]={{5,12,23,56},{19,28,37,46},{-12,-34,6,8}};
  max=a[0][0];//使max开始时取a[0][0]的值
  for (i=0;i<=2;i++)//从第0行~第2行
   for (j=0;j<=3;j++) //从第0列~第3列
     if (a[i][j]>max) //如果某元素大于max
     {
      max=a[i][j]; //max将取该元素的值
      row=i; //记下该元素的行号i
      colum=j;//记下该元素的列号j
     }
  cout<<"max="<<max<<",row="<<row<<",colum="<<colum<<endl;
  return 0;
}

输出结果为

max=56,row=0,colum=3
(0)

相关推荐

  • C++对数组的引用实例分析

    C++中所谓数组引用,即指向数组的引用: 如: int a[10] ; int (&b)[10] = a ; 如果写成: int a[10] ; int* &b = a ; 系统将会报错: cannot convert from 'int [10]' to 'int *&'. 或许你会说在数组名不就是指向这个数组的一个指针吗?题中a是int*类型的,b是指向int*的引用,按理应该是正确的啊,为什么会报错呢?这是因为编译器对指向数组的引用检查更加严格,需要检查数组的维数,在这里a被

  • C/C++中获取数组长度的方法示例

    学过C/C++的人都知道,在C/C++中并没有提供直接获取数组长度的函数,对于存放字符串的字符数组提供了一个strlen函数获取其长度,那么对于其他类型的数组如何获取他们的长度呢? 其中一种方法是使用sizeof(array) / sizeof(array[0]), 在C语言中习惯上在使用时都把它定义成一个宏,比如: #define GET_ARRAY_LEN(array,len) {len = (sizeof(array) / sizeof(array[0]));} 而在C++中则可以使用模板

  • C++结构体数组详细解析

    1.定义结构体数组 和定义结构体变量类似,定义结构体数组时只需声明其为数组即可.如: 复制代码 代码如下: struct Student{     int num;     char name[20];     char sex[5];     int age;     float score;     char addr[30];};Student stu[3]; //定义Student类型的数组stu 2.结构体数组的应用举例 题目:对候选人的票的统计程序. 设有3个候选人,最终只能有一个当

  • C++按照正态分布来排列整型数组元素

    题目要求如下: 给定一个数组input[], 如果数组长度n为奇数,则将数组中最大的元素放到output[]数组最中间的位置, 如果数组长度n为偶数,则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上, 然后再按从大到小的顺序,依次在第一个位置的两边,按照一左一右的顺序,依次存放剩下的数. 这种处理后结果,如果按照元素的值表示一种分布的图形的话,那绘制后的图形应该是正态分布. 关于正态分布: 正态分布(Normal distribution)又名高斯分布(Gaussia

  • C++指针数组、数组指针、数组名及二维数组技巧汇总

    本文较为详细的分析了关于理解C++指针数组,数组指针,数组名,二维数组的一些技巧.是比较重要的概念,相信对于大家的C++程序设计有一定的帮助作用. 一.关于数组名 假设有数组: int a[3] = {1, 2, 3} 1.数组名代表数组第一个元素的地址,注意,不是数组地址(虽然值相等),是数组第一个元素地址,a 等同于 &a[0]; a+1是第二个元素的地址.比第一个元素地址a(或者&a[0])超出了一个整型指针的大小,在这里是4个字节(byte) cout << a <

  • C++动态数组类的封装实例

    C++中的动态数组(Dynamic Array)是指动态分配的.可以根据需求动态增长占用内存的数组.为了实现一个动态数组类的封装,我们需要考虑几个问题:new/delete的使用.内存分配策略.类的四大函数(构造函数.拷贝构造函数.拷贝赋值运算符.析构函数).运算符的重载.涉及到的知识点很多,对此本文只做简单的介绍. 一.内存分配策略 当用new为一个动态数组申请一块内存时,数组中的元素是连续存储的,例如 vector和string.当向一个动态数组添加元素时,如果没有空间容纳新元素,不可能简单

  • C++中求旋转数组中的最小数字(经典面试题)

    面试题:旋转数组的最小数字 题目:把一个数组的最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增数组的旋转,输出旋转数组的最小元素.例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1. 算法: (1)当输入的旋转数组非法时:处理! (2)当输入的旋转数组正常时,index1 = 0:index2=length-1: a:如果arry[index1] <arry[index2]时:说明数组为原数组,并没有进行旋转:    b:如果arry[ind

  • C++实现从数组中同时取出最大最小元素算法示例

    本文实例讲述了C++实现从数组中同时取出最大最小元素的方法.分享给大家供大家参考,具体如下: 算法思想:先相邻两个两个比较,较大的放入数组max[],较小的放入数组min[],然后从max[]数组求出最大,min[]数组求出最小即可. 比较n+[(n+1)/2] =1.5n次 #include <iostream> #define n 11 #define m ((n+1)/2) using namespace std; void main(void) { int num[] = {11,2,

  • C++中的对象数组详细解析

    类是对象的抽象,我们可以使用一个类来定义很多的对象,然后每个对象都有自己的属性. 当我们使用类来定义很多相同结构的对象的时候,我们可以采取对象数组的方法. 例如,一个班有50个学生,我们定义了一个学生类,该类的学生具有相同的数据成员和成员函数,我们就可以定义一个这样的数组. 复制代码 代码如下: Student stdu[50];//假设已经声明了Student类,定义stud数组,有50个元素 ======================对象数组的初始化====================

  • c++将数组名作为函数参数对数组元素进行相应的运算

    用数组名做函数参数与用数组元素作实参有几点不同: (1)用数组元素作实参时,只要数组类型和函数的形参变量的类型一致,那么作为下标变量的数组元素的类型也和函数形参变量的类型是一致的.因此,并不要求函数的形参也是下标变量.换句话说,对数组元素的处理是按普通变量对待的.用数组名作函数参数时,则要求形参和相应的实参都必须是类型相同的数组,都必须有明确的数组说明.当形参和实参两者类型不一致时,将会发生错误. (2)用普通变量或下标变量作函数参数时,形参变量和实参变量都是由编译系统分配的两个不同的内存单元.

  • 深入解析C++中的字符数组和处理字符串的方法

    C++字符数组 用来存放字符数据的数组是字符数组,字符数组中的一个元素存放一个字符.字符数组具有数组的共同属性.由于字符串应用广泛,C和C++专门为它提供了许多方便的用法和函数. 字符数组的定义和初始化 定义字符数组的方法与前面介绍的类似.例如: char c[10]; c[0]=′I′;c[1]=′ ′;c[2]=′a′;c[3]=′m′;c[4]=′ ′;c[5]=′h′;c[6]=′a′;c[7]=′p′;c[8]=′p′;c[9]=′y′; 上面定义了c为字符数组,包含10个元素.在赋值

随机推荐