精华内容
下载资源
问答
  • hello,大家好,鸡啄米上一讲讲了数组的声明和使用,今天给大家讲下数组的存储与初始化、对象数组和数组作为函数参数的知识。  一.数组的存储  数组在内存中是一组连续的内存单元,也就是说数组元素是连续...

    转自:http://www.jizhuomi.com/software/74.html

           一.数组的存储

           数组在内存中是一组连续的内存单元,也就是说数组元素是连续存储的。数组名是数组所占内存的首地址。

           一维数组是按照下标的顺序存储的,而对多维数组就复杂些,以一定的约定顺序将多维数组存储在连续的内存单元中很重要。因为要对数组赋初值、函数间的数组数据传递等都需要先知道数组元素和存储位置的对应关系。

           一维数组的元素是按照下标从小到大的顺序存在内存中的,例如,int a[3]在内存中的存储顺序是:a[0] a[1] a[2]。

           对于二维数组元素,第一个下标叫做行标,第二个下标叫做列标。例如,数组int a[2][3]相当于一个两行三列的矩阵:

           a[0][0] a[0][1] a[0][2]
           a[1][0] a[1][1] a[1][2]

           上面的a[0][0],行标为0,列标也为0,表示矩阵第一行第一个元素,a[1][2],行标为1,列标为2,表示矩阵第二行第三个元素。二维数组在内存中是按行存储的,也就是先存第一行,再存第二行...。每行中的元素按照列标从小到大的顺序存储。这种存储方式叫做行优先存储。上面例子中的二维数组a在内存中的存储顺序是:a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]。

           对于多维数组,其存储方式与二维数组类似。可以把多维数组的下标看作一个计数器。多维数组右边的下标为低位,左边的为高位,每一位都在各自的上界与下界之间变化。当某一位超过上界则向左进一位,该位及右边各位就恢复为下界。最右边一维的下标变化最快,最左边的变化最慢。鸡啄米再提醒大家注意,下界都是0,某一维的上界是声明时该维的下标表达式值减1。例如,数组int a[2][2][2]在内存中的存储顺序是:a[0][0][0] a[0][0][1] a[0][1][0] a[0][1][1] a[1][0][0] a[1][0][1] a[1][1][0] a[1][1][1]。

           实际上我们在软件开发时三维及三维以上的数组很少用到,用的最多的是一维数组。

           二.数组的初始化

           在我们声明数组时对部分或全部元素赋值就是数组的初始化。这里鸡啄米分开给大家讲简单数组类型的数组和对象数组,简单数组类型数组的初始化就是给数组元素赋初值,而对象数组的每个元素都是某个类的对象,它的初始化就是调用对象的构造函数。对象数组下面单独讲。

           我们可以在声明数组时就给出每个元素的初值,例如:int a[2] = { 2,3 };这条语句声明了一个有2个元素的int类型的数组,a[0]的初值是2,a[1]的初值是3。

           如果我们在声明数组时每个元素都给出初始值的话,就可以不说明元素个数,例如:int a[] = { 2,3 };和上面的那个数组声明语句等价。

           我们也可以只对数组的前面一部分元素赋初值,例如,int a[3] = { 1,2 };这时数组元素的个数就必须给出,经过这样声明后,a[0]为1,a[1]为2,a[3]默认为0,也就是后面没有赋初值的元素默认为0。

           多维数组的初始化也满足上面讲到的规则。另外,如果我们对数组初始化时给出了全部元素的初值,则第一位的元素个数可以不用显式说明,例如:int a[2][2] = { 1,2,1,2 };等价于int a[][2] = { 1,2,1,2 };。多维数组还可以按照第一维的下标分组,用括号把每一组括起来。二维数组的话可以用大括号将每组括起来,例如:int a[2][2] = { {1,2},{1,2}};与上面的语句等价,通过将每组元素括起来我们更能直观的分开每行数据。

     三.对象数组

           当数组的元素是某个类的对象时此数组就是对象数组。声明一维对象数组的形式为:类名 数组名[下标表达式];。跟前面说过的基本数据类型的数组一样,使用对象数组也只能引用单个的数组元素,而每个数组元素都是对象,利用这个对象又可以引用它的公有成员,引用形式为:数组名[下标].成员名。

           对象数组在初始化时每个对象元素都会调用其构造函数。如果初始化时数组元素显式给出初始值就会调用带形参的构造函数,如果没有显式指定初始值则调用默认构造函数。例如,A b[2] = { A(2,3) };会先调用带形参的构造函数初始化b[0],再调用默认构造函数初始化b[1]。

           四.数组作为函数参数

           函数的参数可以是数组元素也可以是数组名。数组元素作为函数参数时跟同类型的变量作函数参数效果一样。

           数组名作为函数参数时,实参和形参都须是数组名,并且数组类型要一样。此时传递的是数组的首地址,也就是说形参数组的首地址跟实参是一样的,后面的元素根据其在内存中的顺序进行对应,对应的元素的内存地址相同,所以实参数组的元素个数应该等于或多于形参数组的元素个数。如果在函数内对数组元素值改变,则主调函数中实参数组的相应元素也会改变。

           鸡啄米给大家一个数组作为函数参数的例子:主函数中初始化一个矩阵并将每个元素都输出,然后调用子函数,分别计算每一行的元素之和,将和直接存放在每行的第一个元素中,返回主函数之后输出各行元素的和。

            #include <iostream>
            using namespace std;
            void RowSum(int A[][4], int nrow)
            { 
                    int sum;
                    for (int i = 0; i < nrow; i++)
                    {
                              sum = 0;
                              for(int j = 0; j < 4; j++)
                                         sum += A[i][j];
                              cout << "Sum of row " << i << " is " << sum << endl;
                              A[i][0]=sum;
                    }
            } 
            int main()
            { 
                   int Table[3][4] = {{1,2,3,4},{2,3,4,5},{3,4,5,6}};

                   for (int i = 0; i < 3; i++)
                   { 
                              for (int j = 0; j < 4; j++)
                                        cout << Table[i][j] << "   ";
                              cout << endl;
                   }
                   RowSum(Table,3);
                   for (int i = 0; i < 3; i++)
                              cout << Table[i][0] << endl;
                   return 0;
           }

           此程序的运行结果是:

           1   2   3   4
           2   3   4   5
           3   4   5   6
           Sum of row 0 is 10
           Sum of row 1 is 14
           Sum of row 2 is 18
           10
           14
           18


    展开全文
  • 数组的定义与使用 数组是具有一定顺序关系的若干相同类型变量的集合体,组成数组的变量称为该数组的元素。 数组的定义: 类型说明符 数组名 【常量表达式 】【常量表达式】……; 数组名的构成方法与一般变量名...

    数组的定义与使用

    数组是具有一定顺序关系的若干相同类型变量的集合体,组成数组的变量称为该数组的元素。

    • 数组的定义: 类型说明符 数组名 【常量表达式 】【常量表达式】……;

      数组名的构成方法与一般变量名相同。

    • 数组元素的使用

      数组必须先定义,后使用;

      可以逐个引用数组元素。

    //举例说明数组的定义和元素使用
    int a[10];   //表示a为整型数组,有十个元素,为a[0]…a[9]
    int a[5][3];  //表示a为二维整型数组,可以存放5行3列的整型数据表格,元素15个
    a[0] = a[5]+a[7]-a[2*3];
    b[1][2] = a[2][3]/2;
    
    //例 循环语句
    #include<iostream>
    using namespace std;
    int main(){
        int a[10],b[10];
        for(int i = 0;i < 10;i++){
            a[i] = i*2-1;
            b[10-i-1] = a[i];
        }
        for(int i = 0;i < 10;i++){
            cout << "a[" << i << "] = " << a[i] << " ";
            cout << "b[" << i << "] = " << b[i] << endl;
        }
        return 0;
    }
    

    数组的存储

    1. 一维数组的存储

    • 数组元素在内存中顺次存放,它们的地址是连续的
    • 元素间物理地址上的相邻,对应着逻辑次序上的相邻。
    • 数组名字是数组首元素的内存地址
    • 数组名是一个常量,不能被赋值。

    2. 一维数组的初始化

    • 列出全部元素的初始值。例如,static int a【10】= {0,1,2,3,4,5,6,7,8,9};
    • 可以只给一部分元素指定初值。例如,static int a【10】= {0,1,2,3,4};
    • 列出全部元素初值时,可以不指定数组长度。例如,static int a【】= {0,1,2,3,4,5,6,7,8,9};

    3. 二维数组的存储

    • 按行存储。例如,float a【3】【4】; 存储顺序为00 01 02 03 10 11 12 13 20 21 22 23.

    4. 二维数组的初始化

    • 将所有初值写在一个{}内,按顺序初始化。

      例如,static int a【3】【4】= {0,1,2,3,4,5,6,7,8,9,10,11};

    • 分行列出二维数组元素的初值。

      例如,static int a【3】【4】= {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};

    • 可以只对部分元素初始化。

      例如,static int a【3】【4】= {{0}, {4,5}, {8,9,1}};

    • 列出全部初值时,第一维下标个数可以省略。

      例如,static int a【】【4】= {0,1,2,3,4,5,6,7,8,9,10,11};

      或static int a【】【4】= {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};

    • 如果不作任何初始化,局部作用域的非静态数组中会存在垃圾数据,static数组中的数据默认初始化为0

    • 如果只对部分元素初始化,剩下的未显式初始化的元素,将自动被初始化为0.

    //例1 求斐波那契数列的前20个数。
    #include<iostream>
    using namespace std;
    
    int main(){
        int f[20] = {1,1};  //初始化第0、1个数
        for(int i=0;i<20;i++)  //求第2—19个数
        f[i]=f[i-1]+f[i-2];
        for(int i=0;i<20;i++){
            if(i%5==0) cout<<endl;  //输出,每行5个数
            cout.width = 12;  //设置输出宽度为12
            cout << f[i];
        }
        return 0;
    }
    
    //例2 循环从键盘读入若干组选择题答案,计算并输出每组答案的正确率,直到输入ctrl+z为止。
    //每组连续输入5个答案,每个答案可以是abcd。
    #include<iostream>
    using namespace std;
    
    int main(){
        const char key[] = {'a','c','b','a','d'};
        const int NUM_QUES = 5char c;
        int ques = 0,numCorrect = 0;
        cout << "Enter the " << NUM_QUES <<"question tests:" << endl;
        while(cin.get(c)){
            if(c!='\n'){
                if(c==key[ques]){
                    numCorrect++;
                    cout<<' ';
                }
                else
                    cout<<"*";
                ques++;
            }
            else{
                cout<<"Score "<<static_cast<float>(numCorrect)/NUM_QUES*100<<"%";
                ques = 0;
                numCorrect = 0;
                cout << endl;
            }
        }
        return 0;
    }
    
    运行结果:
    Enter the 5 question tests:
    acbba
       ** Score 60%
    acbad
          Score 100%
    

    5. 数组作为函数参数

    数组元素做实参,与单个变量一样;

    数组名做参数,形参实参都应当是数组名,类型要一样,传送的是数组首地址。对形参数组的改变会直接影响到实参数组。

    //例 使用数组名作为函数参数
    //主函数中初始化一个二维数组,表示一个矩阵,并将每个元素都输出。然后调用子函数,分别计算每一行的元素之和,将和直接存放到每行的第一个元素中,返回主函数之后输出各行元素的和。
    
    #include<iostream>
    using namespace std;
    
    void rowSum(int a[][4],int nRow){  //计算二维数组a每行元素的值的和
        for(int i=0;i<nRow;i++){
            for(int j=1;j<4;j++)
                a[i][0]+=a[i][j];
        }
    }
    
    int main(){
        int table[3][4] = {{1,2,3,4},{2,3,4,5},{3,4,5,6}};
        for(int i=0;i<3;i++){  //输出数组元素
            for(int j=0;j<4;j++)
                cout << table[i][j] <<"  ";
            cout<<endl;
        }
        rowSum(table,3);  //调用子函数,计算各行的和
        for(int i=0;i<3;i++)
            cout << "Sum of row " << i << " is" << table[i][0] << endl;
        return 0;
    }
    
    运行结果:
    1  2  3  4
    2  3  4  5
    3  4  5  6
    Sum of row 0 is 10
    Sum of row 1 is 14
    Sum of row 2 is 18
    

    6. 对象数组

    对象数组的定义和访问
    • 定义对象数组: 类名 数组名【元素个数】;
    • 访问对象数组元素: 通过下标访问:数组名【下标】.成员名
    对象数组初始化
    • 数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该对象。
    • 通过初始化列表赋值。例 Point a[2] = {Point(1,2),Point(3,4)};
    • 如果没有为数组元素指定显式初值,数组元素使使用默认值初始化(调用默认构造函数)。
    数组元素的构造和析构
    • 构造数组时,元素所属的类未声明构造函数,则采用默认构造函数。
    • 各元素对象的初值要求为相同的值时,可以声明具有默认形参值的构造函数。
    • 各元素对象的初值要求为不同的值时,需要声明带形参的构造函数。
    • 当数组中每一个对象被删除时,系统都要调用一次析构函数。
    //例 对象数组应用举例
    //Point.h
    #ifndef_POINT_H
    #define_POINT_H
    class Point{
        public:
          Point();
          Point(int x,int y);
          ~Point();
          void move(int newX,int newY);
          int getX() const{return x;}
          int getY() const{return y;}
          static void showCount();  //静态函数成员
        private:
          int x,y;
    };
    #endif//_POINT_H
    
    //Point.cpp
    #include<iostream>
    #include"Point.h"
    using namespace std;
    
    Point::Point():x(0),y(0){
        cout << "Default Constructor called." << endl;
    }
    Point::Point(int x.int y):x(x),y(y){
        cout << "Constructor called." << endl;
    }
    Point::~Point(){
        cout << "Destructor called." << endl;
    }
    void Point::move(int newX,int newY){
        cout << "Moving the point to (" << newX << "," << newY << ")" << endl;
        x = newX;
        y = newY;
    }
    
    //6_3.cpp
    #include<iostream>
    #include"Point.h"
    using namespace std;
    
    int main(){
        cout << "Entering main…" << endl;
        Point a[2];
        for(int i=0;i<2;i++)
            a[i].move(i+10,i+20);
        cout << "Exiting main…" << endl;
        return 0;
    }
    
    运行结果:
    Entering main…
    Default Constructor called.
    Default Constructor called.
    Moving the point to (1020)
    Moving the point to (1121)
    Entering main…
    Destructor called.
    Destructor called.
                                 
    //基于范围的for循环举例
                         int main(){
                             int array[3] = {1,2,3};
                             int *p;
                             for(p=array;p<array+sizeof(array)/sizeof(int);++p){
                                 *p += 2;
                                 std::cout << *p << std::endl;
                             }
                             return 0;
                         }
               
                         int main(){
                             int array[3] = {1,2,3};
                             for(int &e:array){
                                 e += 2;
                                 std::cout << e << std::endl;
                             }
                             return 0;
                         }
    
    展开全文
  • hello,大家好,鸡啄米上一讲讲了数组的声明和使用,今天给大家讲下数组的存储与初始化、对象数组和数组作为函数参数的知识。  一.数组的存储  数组在内存中是一组连续的内存单元,也就是说数组元素是连续...

    hello,大家好,鸡啄米上一讲讲了数组的声明和使用,今天给大家讲下数组的存储与初始化、对象数组和数组作为函数参数的知识。

           一.数组的存储

           数组在内存中是一组连续的内存单元,也就是说数组元素是连续存储的。数组名是数组所占内存的首地址。

           一维数组是按照下标的顺序存储的,而对多维数组就复杂些,以一定的约定顺序将多维数组存储在连续的内存单元中很重要。因为要对数组赋初值、函数间的数组数据传递等都需要先知道数组元素和存储位置的对应关系。

           一维数组的元素是按照下标从小到大的顺序存在内存中的,例如,int a[3]在内存中的存储顺序是:a[0] a[1] a[2]。

           对于二维数组元素,第一个下标叫做行标,第二个下标叫做列标。例如,数组int a[2][3]相当于一个两行三列的矩阵:

           a[0][0] a[0][1] a[0][2]
           a[1][0] a[1][1] a[1][2]

           上面的a[0][0],行标为0,列标也为0,表示矩阵第一行第一个元素,a[1][2],行标为1,列标为2,表示矩阵第二行第三个元素。二维数组在内存中是按行存储的,也就是先存第一行,再存第二行...。每行中的元素按照列标从小到大的顺序存储。这种存储方式叫做行优先存储。上面例子中的二维数组a在内存中的存储顺序是:a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]。

           对于多维数组,其存储方式与二维数组类似。可以把多维数组的下标看作一个计数器。多维数组右边的下标为低位,左边的为高位,每一位都在各自的上界与下界之间变化。当某一位超过上界则向左进一位,该位及右边各位就恢复为下界。最右边一维的下标变化最快,最左边的变化最慢。鸡啄米再提醒大家注意,下界都是0,某一维的上界是声明时该维的下标表达式值减1。例如,数组int a[2][2][2]在内存中的存储顺序是:a[0][0][0] a[0][0][1] a[0][1][0] a[0][1][1] a[1][0][0] a[1][0][1] a[1][1][0] a[1][1][1]。

           实际上我们在软件开发时三维及三维以上的数组很少用到,用的最多的是一维数组。

           二.数组的初始化

           在我们声明数组时对部分或全部元素赋值就是数组的初始化。这里鸡啄米分开给大家讲简单数组类型的数组和对象数组,简单数组类型数组的初始化就是给数组元素赋初值,而对象数组的每个元素都是某个类的对象,它的初始化就是调用对象的构造函数。对象数组下面单独讲。

           我们可以在声明数组时就给出每个元素的初值,例如:int a[2] = { 2,3 };这条语句声明了一个有2个元素的int类型的数组,a[0]的初值是2,a[1]的初值是3。

           如果我们在声明数组时每个元素都给出初始值的话,就可以不说明元素个数,例如:int a[] = { 2,3 };和上面的那个数组声明语句等价。

           我们也可以只对数组的前面一部分元素赋初值,例如,int a[3] = { 1,2 };这时数组元素的个数就必须给出,经过这样声明后,a[0]为1,a[1]为2,a[3]默认为0,也就是后面没有赋初值的元素默认为0。

           多维数组的初始化也满足上面讲到的规则。另外,如果我们对数组初始化时给出了全部元素的初值,则第一位的元素个数可以不用显式说明,例如:int a[2][2] = { 1,2,1,2 };等价于int a[][2] = { 1,2,1,2 };。多维数组还可以按照第一维的下标分组,用括号把每一组括起来。二维数组的话可以用大括号将每组括起来,例如:int a[2][2] = { {1,2},{1,2}};与上面的语句等价,通过将每组元素括起来我们更能直观的分开每行数据。

           三.对象数组

           当数组的元素是某个类的对象时此数组就是对象数组。声明一维对象数组的形式为:类名 数组名[下标表达式];。跟前面说过的基本数据类型的数组一样,使用对象数组也只能引用单个的数组元素,而每个数组元素都是对象,利用这个对象又可以引用它的公有成员,引用形式为:数组名[下标].成员名。

           对象数组在初始化时每个对象元素都会调用其构造函数。如果初始化时数组元素显式给出初始值就会调用带形参的构造函数,如果没有显式指定初始值则调用默认构造函数。例如,A b[2] = { A(2,3) };会先调用带形参的构造函数初始化b[0],再调用默认构造函数初始化b[1]。

           四.数组作为函数参数

           函数的参数可以是数组元素也可以是数组名。数组元素作为函数参数时跟同类型的变量作函数参数效果一样。

           数组名作为函数参数时,实参和形参都须是数组名,并且数组类型要一样。此时传递的是数组的首地址,也就是说形参数组的首地址跟实参是一样的,后面的元素根据其在内存中的顺序进行对应,对应的元素的内存地址相同,所以实参数组的元素个数应该等于或多于形参数组的元素个数。如果在函数内对数组元素值改变,则主调函数中实参数组的相应元素也会改变。

           鸡啄米给大家一个数组作为函数参数的例子:主函数中初始化一个矩阵并将每个元素都输出,然后调用子函数,分别计算每一行的元素之和,将和直接存放在每行的第一个元素中,返回主函数之后输出各行元素的和。

            #include <iostream>
            using namespace std;
            void RowSum(int A[][4], int nrow)
            { 
                    int sum;
                    for (int i = 0; i < nrow; i++)
                    {
                              sum = 0;
                              for(int j = 0; j < 4; j++)
                                         sum += A[i][j];
                              cout << "Sum of row " << i << " is " << sum << endl;
                              A[i][0]=sum;
                    }
            } 
            int main()
            { 
                   int Table[3][4] = {{1,2,3,4},{2,3,4,5},{3,4,5,6}};

                   for (int i = 0; i < 3; i++)
                   { 
                              for (int j = 0; j < 4; j++)
                                        cout << Table[i][j] << "   ";
                              cout << endl;
                   }
                   RowSum(Table,3);
                   for (int i = 0; i < 3; i++)
                              cout << Table[i][0] << endl;
                   return 0;
           }

           此程序的运行结果是:

           1   2   3   4
           2   3   4   5
           3   4   5   6
           Sum of row 0 is 10
           Sum of row 1 is 14
           Sum of row 2 is 18
           10
           14
           18

           鸡啄米对数组的存储与初始化、对象数组和数组作为函数参数的内容就讲到这里,如果有什么问题可以在鸡啄米博客上留言讨论。谢谢大家的支持。

    展开全文
  • 一、数组的存储 数组在内存中连续存储,数组名则为数组所占内存的首地址。 多维数组的存储,这里以二维数组 int a[2][3]为例 左边为高位,右边为低位 a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]...
    一、数组的存储
    	数组在内存中连续存储,数组名则为数组所占内存的首地址。
    多维数组的存储,这里以二维数组 int a[2][3]为例
    	左边为高位,右边为低位
    	a[0][0] a[0][1]  a[0][2]
    	a[1][0] a[1][1]  a[1][2]   //这种存储方式为行优先存储
     
    二、数组的初始化
    声明数组时对部分或全部元素赋值就是数组的初始化。
    如简单数组类型的数组和对象数组,前者就是给相应数组元素赋值,后者则为调用对象的构造函数。
    声明时为元素赋值,如:
    
    int a[2]={1,2};
    int a[]={1,2};  //都给出初始值时可以不说明元素个数
    int a[3]={1,2}  //这种情况必须给出元素个数,a[2]没赋值的情况下默认为0
    多维数组类似
    int [2][2]={1,2,1,2}
    int [][2]={1,2,1,2}  //与上面等价
    int [2][2]={{1,2},{1,2}}  //等价,这样显示更为直观

    三、对象数组
    当数组元素是某个类的对象时此数组就是对象数组。
    初始化时需要调用每个对象的构造函数。
    如:
    A b[2]={A(2,3)};
    //b[0]显示指定初始值,则调用带形参的构造函数
    //b[1]示显示指定,调用默认构造函数
    四、数组作为函数参数
    数组元素作为函数参数时,实参和形参都须是数组名且类型要一样。此时传递的是数组的首地址,后面元素根据内存地址进行对应。
    如果在函数内对数组元素值进行改变,则主调函数中实参数组的相应元素值也会改变。
    主调函数中的实参数组也相应改变,那传数组是传值还是传引用?
    实际是如果形参是数组,实际作用相当于“传引用了”。
    因为形参如果是数组的形式,则并非传数组的值,而是传指针的值(首地址)。所传的并非数组的内容,而是指向数组首元素的指针。
    如void fun(int& a[]);  //这样会报错,arrays of references are illegal
    展开全文
  • 数组作为函数参数

    2017-05-08 09:59:25
    一维数组和多维数组都可以作为函数参数int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; int b[]={1,2,3,4,5};printf("%d\n",sizeof(*(&a)));//48(容易产生的误区的:二维数组名其实是个行指针,那么*(&a)取到的是这一行...
  • 数组作为函数实参的时候可以有两种情况,一种是使用数组的元素作为实参,另一种是使用数组名作为实参。 数组元素作实参 这种情况和相同类型的其他单个变量是一样的。 数组名作实参 此时,形实结...
  • C++中数组作为函数参数如何不用同时传入大小 在C/C++中如果将数组作为参数传入函数通常需要同时传入数组的大小, 在使用时总是带着一个尾巴, 总是显得有些赘余. 这是由于C/C++的原生数组实质上只是一个指针而已, 不...
  • 6.2 数组作为函数参数 数组元素作实参,与单个变量一样。数组名作参数,形、实参数都应是数组名(实质上是地址),类型要一样,传送的是数组首地址。对形参数组的改变会直接影响到实参数组。 //6-2 使用数组名...
  • 1、传递一个数组作为函数参数的时候,必须传入一个数组或者一个指针,而不能传入引用。根据上面的知识,编写程序实现冒泡排序。基本的算法是,每次循环依次把末排元素的最小元素排在前面,传入参数为数.
  • 函数可以以任意深度的数组或者对象的值作为排序基数对数组或的元素进行排序。 代码如下: /** * 排序数组或者对象 * by Jinko * date -- * @param object 数组对象 * @param subkey 需要排序的子键, 该...
  • 一、对象作为函数参数 对象也可以作为函数参数传递给函数,其转递方法与传递其他类型的数据一样,可采用值传递和地址传递两种方法。 值传递时是把对象的拷贝而不是本身传递给函数,函数中对参数对象的任何修改...
  • 如果形参是数组,那么实参是数组对象. 例如: void fun(int a[],int count); 参数一:表示的是int 型数组 参数二:表示传入的数组的个数 调用函数: int a[3] = {1,0,1}; fun(a,3) 这个时候 a 就是数组对象 重点: 数组...
  • C++对象数组作为类成员的问题

    千次阅读 2013-11-23 18:37:49
    //对象数组作为类的成员 } 那样的话对象数组的初始化会变得很麻烦, 因为数组名不能作为左值,所以不可以指针传递的方式赋值。 而且不能通过参数列表(构造函数后面加一个冒号)的方式初始化, 所以只能让类...
  • C++ 数组作为参数

    2019-04-25 16:05:38
    之前写过,当类对象作为参数,传入函数的时候,在函数内部,进行对类的操作,有的会生效,有的不会,当将类的指针对象传入的时候,就不会不生效。 今天同样遇到,将数组指针指针当作参数,传入函数的时候也失效了。...
  • 但马上又发现将二维数组传给函数时必须指定第二维的维数,因为函数传递的是一个指向一个一维数组的指针,这个一维数组中存储有着若干元素的数组,所以函数必须要知道这个指针所指向对象的信息,在这里表现为这个被...
  • 目录数组的存储与初始化一维数组的存储一维数组的初始化二维数组的存储二维数组的初始化数组作为函数参数对象数组对象数组的定义和访问对象数组的初始化数组元素所属类的构造函数基于范围的for循环指针的初始化和...
  • 对象作为函数参数

    2020-12-15 09:31:01
    传参时不会像数组那样以首地址作为函数参数传递,而是先将对象中的所有数据进行备份(复制),将复制的数据作为形参传递到调用函数中去、 类对象中的数据成员的传参顺序为:最先定义的数据成员最后压栈,最后定义...
  • 作为函数参数的多维数组

    千次阅读 2011-08-13 22:40:57
    C语言的数组值得注意的地方有两点: ...然而,C语言中的数组的元素可以是任何类型的对象,当然也可以是另外一个数组。这样,要“仿真”出一个多维数组就不是一件难事。 2、对于一个数组,我们只能够做两件事:确定该
  • 1. Array.of() 将参数中所有值作为元素形成数组数组中的参数可以是不同类型的,当参数为空时,返回空数组。 2. Array.from() 将类数组对象或可迭代对象转化为数组。 3. find() 查找数组中符合条件的元素,若有...
  • C++实验6 对象数组

    2020-04-10 07:57:16
    (1)学习如何使用数组名作为函数参数,通过传数组的方式,在被调用 函数中访问主调函数中的多个对象的方法。 (2)学习如何在类中内嵌对象数组成员变量。 (3)学习对象数组的初始化。 2 实验内容 2.1 根据题目...
  • R语言数组array函数

    2017-08-06 11:53:00
    数组是一个可以在两个以上的维度存储数据的...它需要向量作为输入,并使用 dim 参数的值,以创建一个数组。 示例 例子下面将创建的每两个3×3矩阵的数组,具有3行3列。 # Create two vectors of different length...
  • Array.of() :将参数中所有值作为元素形成数组参数值可为不同类型: 参数为空时返回空数组: 2.Array.from():将类数组对象或可迭代对象转化为数组。 3.参数: 返回值为转换后的数组。 arrayLike:想要转换的类...
  • 应用场景:在前端用ajax向服务器提交json对象数组,在controller的以对象数组作为函数参数,提交的json数组直接转为服务器端的对象数组。 如: 要将json对象数组[{Id:1,Name:"AA"},{Id:2,Name:"BB"}] 用ajax提交...
  • 建立一个对象数组,内放五个学生的数据(学号,成绩),设立一个函数max,用指向对象的指针作为参数,在max函数中找出5个学生中成绩最高者,并输出学号。 #include<iostream> using namespace std; class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,628
精华内容 651
关键字:

对象数组作为函数参数