数组与指针

#pragma  once
#include  < iostream >
using   namespace  std;

void  PrintArray( double   * p,  int  num)
{
     for ( int  i  =   0 ; i  <  num;  ++ i)
    {
        cout  <<   "   "   <<  p[i]  <<   "   " ;
    }
    cout  <<  endl  <<   " The array is end! "   <<  endl;
}
void  PrintArray( double  arr[ 3 ]) 
{
     for ( int  i  =   0 ; i  <   3 ;  ++ i)
    {
        cout  <<   "   "   <<   * (arr + i) /* arr[i] */   <<   "   " ;
    }
    cout  <<  endl  <<   " The array is end! "   <<  endl;
}
void  ChangeArray( double  arr[ 3 ])  //  数组传参为传指针，所以函数内可以修改
{
     for ( int  i  =   0 ; i  <   3 ;  ++ i)
    {
        arr[i]  =   10 ;
    }
}
void  PrintArray( double  arr[ 3 ][ 3 ])
{
     for ( int  i  =   0 ; i  <   3 ;  ++ i)
         for ( int  j  =   0 ; j  <   3 ;  ++ j)
            cout  <<   "   "   <<  arr[i][j]  <<   "   " ;
    cout  <<  endl  <<   " The array is end! "   <<  endl;
}

int  GetLength(){ return   3 ;}

void  TestArray()
{
     //  数组的定义和初始化
     short  months[ 12 ]  =  { 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 };
     double  arr[ 3 ]; 
    arr[ 0 ]  =   1.0 ;
    arr[ 1 ]  =   2.0 ;
    arr[ 2 ]  =   3.0 ;
     double  arr2[]  =  { 1.0 , 2.0 , 3.0 };
     // double arr3[3] = arr;  //  error
    PrintArray(arr, 3 );
    PrintArray( & arr[ 0 ], 3 );
    PrintArray(arr2);

     double  matrix2 [ 2 ][ 2 ]  =  { 1.0 , 0.0 , 0.0 , 1.0 };
     double  matrix3 [ 3 ][ 3 ]  =  {{ 1.0 , 0.0 , 0.0 },
                            { 0.0 , 1.0 , 0.0 },
                            { 0.0 , 0.0 , 1.0 }};
    PrintArray(matrix3[ 0 ], 3 * 3 );
    PrintArray( & matrix3[ 0 ][ 0 ], 3 * 3 );
     // PrintArray(matrix3,3*3);
    PrintArray(matrix3);

     //  指针来模拟数组
     double   * p3  =   new   double [GetLength()];
    p3[ 0 ]  =   10.0 ;
    p3[ 1 ]  =   20.0 ;
    p3[ 2 ]  =   30.0 ;
    PrintArray(p3, 3 );
    PrintArray(p3);
    delete []p3;

     //  数组+指针实现二维变长数组
     double   * p4[ 2 ];
    p4[ 0 ]  =   new   double [ 2 ];
    p4[ 1 ]  =   new   double [ 4 ];
    p4[ 0 ][ 0 ]  =   10 ;
    p4[ 0 ][ 1 ]  =   20 ;
    p4[ 1 ][ 0 ]  =   30 ;
    p4[ 1 ][ 1 ]  =   40 ;
    p4[ 1 ][ 2 ]  =   50 ;
    p4[ 1 ][ 3 ]  =   60 ;
    PrintArray(p4[ 0 ], 2 );
    PrintArray(p4[ 1 ], 4 );
    delete [] p4[ 0 ];
    delete [] p4[ 1 ];

    PrintArray(arr);  //  数组传参为传指针，所以函数内可以修改
    ChangeArray(arr);
    PrintArray(arr);
}

 

代码分析总结：

1）数组的定义必须使用常量指定长度，例如：double arr[3]，但是使用指针时可以是运行时指定，例如double *p3 = new double[getLength()]。
2）数组定义时即分配空间且在栈上，不需要程序员来对内存管理，但是如果对指针使用了new[]，则必须由程序员在使用完毕后delete[]。
3) 一维数组数组名即第一个元素的地址，例如：double arr[3]中，arr == &arr[0]为true。
4）二维数组中第一行的地址即为第一个元素的地址，例如：double matrix3 [3][3]，matrix[0] == &matrix[0][0]为true。
5）可以使用指针数组来模拟变长二维数组，例如：double *p4[2]; p4[0] = new double[2]; p4[1] = new double[4];
6）二维数组内存中同一维数组仍为连续的区域，所以可以将二维数组和一维相互转化。
7）一维数组名即为第一个元素的地址，所以可以同指针隐式转化，但二维数组名不是第一个元素地址，所以不能转化。
8) 当函数传入数组，实际传首元素的指针，所以可以在函数内修改数组元素。