精华内容
下载资源
问答
  • C++对象数组

    千次阅读 2019-09-24 08:24:49
    C++对象数组 一、对象数组 1.C++对象数组的定义:类名 数组名[元素个数] 例:Student stu[10]; 2.对象数组访问形式:数组名[下标].成员名; 例:stu[i].print(); 3.对象数组的初始化:对象数组的初始化通常也...

    C++对象数组

    一、对象数组

    1.C++对象数组的定义:类名 数组名[元素个数]

    例:Student stu[10];

    2.对象数组访问形式:数组名[下标].成员名;

    例:stu[i].print();

    3.对象数组的初始化:对象数组的初始化通常也是由构造函数来完成的

    例:

    关于对象数组的几点说明:

      (1)在建立对象数组的时候需要调用构造函数。如果对象数组有100个元素,就需要调用100次构造函数。

      (2)如果对象数组所属类有带参数的构造函数时,可用初始化列表按顺序调用构造函数,使用复制初始化来初始化每个数组元素。

    Student A[3]={Student(1,liu,1),Student(2,li,2),Student(3,he,3)};
    Student A[3]={Student(1),Student(2),Student(3)};
    

    (3)如果对象数组所属类有单个参数的构造函数时,定义数组时可以直接在初值列表中提供实参。

    例:只有一个参数的构造函数给对象数组赋值。

    #include<iostream>
    using namespace std;
    class exam{
    	public:
    		exam(int n){  //只有1个参数的构造函数 
    			x=n;
    		}
    		int get_x(){
    			return x;
    		}
    	private:
    		int x;
    };
    int main(){
    	exam ob1[4]={11,22,33,44};  //用只有1个参数的构造函数给对象数组赋值 
    	for(int i=0;i<4;i++)
    		cout<<ob1[i].get_x()<<" ";
    	return 0;
    }

    当各个元素的初始值相同时,可以在类中定义不带参数的构造函数或者带有默认值的构造函数;当各个元素的的初始值要求不同时,需要定义带参数(无默认值)的构造函数。

    例:用不到参数和带1个参数饿构造函数给对象数组进行赋值

    #include <iostream>
    using namespace std;
    class Student{
        public:
            Student(){
                score=100;
        }
             Student(int n){
                score=n;
        }
             int get_score(){
                return score;
            }
        private:
            int score;
    };
    int main(){
        Student stu[4]={60,70,80,90};
        Student stu1[4]={60,70};
        Student stu2[4];
        for(int i=0;i<4;i++)
            cout<<stu[i].get_score()<<" ";
            cout<<endl;
        for(int i=0;i<4;i++)
            cout<<stu1[i].get_score()<<" ";
            cout<<endl;
        for(int i=0;i<4;i++)
            cout<<stu2[i].get_score()<<" ";
            cout<<endl;
        return 0;
    }

    二、构造函数拥有多个参数

    如果构造函数有多个参数,在定义对象数组时只需在花括号中分别写出构造函数并指定实参即可实现初始化。

    例3:用带有两个参数的构造函数给对象进行赋值

    #include<iostream>
    #include <cmath>
    using namespace std;
    class Complex{
        public:
            Complex(double r=0.0,double i=0.0):real(r),imag(i){
             
            }
            ~Complex(){
                cout<<"Destructor caller"<<endl;
            }
            double absComplex(){
                double t;
                t=real*real+image*imag;
                return sqrt(t);
            }
        private:
            double real;
            double imag;
    };
    int main(){
            Complex com[3]={   //定义对象数组
                Complex(1.1,2.2),  //调用构造函数,为第一个对象数组元素提供实参1.1和2.2
                Complex(3.3,4.4),
                Complex(5.5,6.6)
            };
            cout<<"复数1绝对值为:"<<com[0].absComplex()<<endl;
            cout<<"复数2绝对值为:"<<com[1].absComplex()<<endl;
            cout<<"复数3绝对值为:"<<com[2].absComplex()<<endl;
            return 0;    
    }

    对象数组中的元素同样需要用构造函数初始化。具体哪些元素用哪些构造函数初始化,取决于定义数组时的写法。

    #include <iostream>
    using namespace std;
    class CSample{
        public:
            CSample(){
                cout<<"Constructor 1 Called"<<endl;
        }
            CSample(int n){
                cout<<"Constructor 2 Called"<<endl;
        }
    };
    int main(){
        CSample array1[2];
        cout<<"step1"<<endl;
        CSample array2[2]={4,5};
        cout<<"step2"<<endl;
        CSample array3[2]={3};
        cout<<"step3"<<endl;
        CSample* array4=new CSample[2];
        delete [] array4;
        return 0;
    }

     array1 数组中的两个元素没有指明如何初始化,要用无参构造函数初始化,因此输出两行 Constructor 1 Called。

    array2 数组进行了初始化,初始化列表 {4, 5} 可以看作用来初始化两个数组元素的参数,所以 array2[0] 以 4 为参数,调用构造函数 2 进行初始化;array2[1] 以 5 为参数,调用构造函数 2 进行初始化。这导致输出两行 Constructor 2 Called。

     array3 只指出了 array3[0] 的初始化方式,没有指出 array3[1] 的初始化方式,因此它们分别用构造函数 2 和构造函数 1 进行初始化。

    动态分配了一个 CSample 数组,其中有两个元素,没有指出和参数有关的信息,因此这两个元素都用无参构造函数初始化。

    在构造函数有多个参数时,数组的初始化列表中要显式包含对构造函数的调用。

    class Student{
    public:
        Student(int n){ }  //构造函数(1)
        Student(int n, int m){ }  //构造函数(2)
        Student(){ }  //构造函数(3)
    };
    int main(){
        //三个元素分别用构造函数(1)、(2)、(3) 初始化
        Student arrayl [3] = { 1, Student(1, 2) };
        //三个元素分别用构造函数(2)、(2)、(1)初始化
        Student array2[3] = { Student(2,3), Student(1,2), 1};
        //两个元素指向的对象分别用构造函数(1)、(2)初始化
        Student*  pArray[3] = { new Student(4) , new Student(1,2) };
        return 0;
    }

    pArray 数组是一个指针数组,其元素不是Student 类的对象,而是Student类的指针。Student*  pArray对 pArray[0] 和 pArray[1] 进行了初始化,把它们初始化为指向动态分配的Student对象的指针,而这两个动态分配出来的 Student对象又分别是用构造函数(1)和构造函数(2)初始化的。pArray[2] 没有初始化,其值是随机的,不知道指向哪里。Student*  pArray生成了两个Student对象,而不是三个,所以也只调用了两次 Student类的构造函数。

    从栈区和堆区两种存储方式上看它的使用

    #include <iostream>
    using namespace std;
    class Coordinate
    {
    public:
        Coordinate(){};//无参构造函数
    	~Coordinate(){};//析构函数
    public:
        int m_iX;
    	int m_iY;
    };
    int main()
    {
    	Coordinate coor[3];
    	coor[0].m_iX=1;
    	coor[0].m_iY=2;
    	coor[1].m_iX=3;
    	coor[1].m_iY=4;
        coor[2].m_iX=5;
    	coor[2].m_iY=6;//类似数组直接访问
    	Coordinate *p=new Coordinate[3];
    	p->m_iX=7;//默认访问首地址
        p[0].m_iY=8;//与上面一行指向的都是首地址
    	p++;//指针往后指一个
    	p->m_iX=9;
    	p->m_iY=10;
    	p++;//指针往后指一个
    	p->m_iX=11;
    	p->m_iY=12;
    	p--;
    	p--;
    	for(int i=0;i<3;i++)
    	{
    		cout<<coor[i].m_iX<<" ";
         	cout<<coor[i].m_iY<<" ";
    		cout<<"\n";
    	}
    	for(int j=0;j<3;j++)
    	{
    		cout<<p[j].m_iX<<" ";
            cout<<p[j].m_iY<<" ";
    		cout<<"\n";//没有进行过p++的才能用这种方式,因为上面进行了三次p++,p此时指向的是最后一个
    	}//为了规避这种情况我们利用指针回指打印数据
    	delete []p;
    	p=NULL;//注意如果用了p--指向第一个数据的话不能用delete,因为此时delete的不是我们申请的内存,
    如果是这种情况使用p++指向到申请的内存在释放
    	system("pause");
    	return 0;
    }

    三、指向对象的指针

    对象指针的用法:定义对象指针的语法和定义其它基本数据类型指针的语法相同。在使用对象指针之前,要把它指向一个已经创建的对象,然后才能访问该对象的成员。在使用对象名来访问对象成员时,要使用点运算符“.”。如果要通过指向对象的指针来访问对象的成员,那么必须使用箭头运算符“->”。

    展开全文
  • c++对象数组

    2020-08-12 09:07:53
    c++对象数组 首先定义一个简单的类: class Section{ public: Section(double top, double bottom){this->top = top; this->bottom = bottom;} Section(){} double top; double bottom; }; 将对象放入...

    c++对象数组

    首先定义一个简单的类:

    class Section{
    public:
        Section(double top, double bottom){this->top = top; this->bottom = bottom;}
        Section(){}
        double top;
        double bottom;
    };
    

    将对象放入数组类型中

    Section b[3];
        b[0] = Section(1000, 1007);
        b[1] = Section(1010, 1020);
        b[2] = Section(1030, 1040);
    
        for(int i=0; i<3; i++){
            cout << b[i].top << ","  << b[i].bottom << endl;
        }
    

    将对象放入vector类型中

    vector<Section *> data;
        data.push_back(new Section(1000, 1007));
        data.push_back(new Section(1010, 1020));
        data.push_back(new Section(1030, 1040));
    
        for(int i=0; i<3; i++){
            cout << data[i]->top << ","  << data[i]->bottom << endl;
        }
    
        for(int i=0; i<data.size(); i++){
            delete data[i];
        }
    

    在c++中使用完指针要进行delete释放。

    展开全文
  • C++ 对象数组

    2021-06-10 20:33:49
    对象数组 学过C语言的读者对数组的概念应该很熟悉了。数组的元素可以是int类型的变量,例如 int array[128]; 就是定义一个整型数组的每一个元素都是整型变量,数组的元素也可以是一个类对象,例如: class test...

    对象数组

           学过C语言的读者对数组的概念应该很熟悉了。数组的元素可以是int类型的变量,例如

    int array[128];

    就是定义一个整型数组的每一个元素都是整型变量,数组的元素也可以是一个类对象,例如:

    class test{…};

    test array[128];

    此时,定义一个test类,然后,定义一个test类对象数组,数组的每一个元素都是test类的对象。

           例如一个班有30个学生,每个学生的属性包括姓名,性别,年龄,成绩等。如果为每一个学生建立一个对象,需要分别取30个对象名。用程序处理很不方便。这时,可以定义一个“学生类”的对象数组,每一个数组元素表示一个“学生类”的对象,例如:

    student stud[30];   //假设已声明了student 类,定义stud[] 数组,有30 个元素

           在建立数组的时候,同样要调用构造函数。如果有30个元素,需要调用30个构造函数。有需要时,可以在定义数组的时候,提供实参以实现初始化数组的元素。如果构造函数只有一个参数,在定义数组的时候,可以在等号后面的花括号内提供实参,例如:

           程序运行结果如下:

           在上面的例子中,我们定义了 2 个对象的数组:

        student stud_array[2] =

        {

            {"wkf","www.mylinux.vip",13926572996},

            {"abc","china",13926572996}

        };

           注意:在VS2013开发环境中,不支持这种语法。在ubuntu系统中支持。那么,在VS2013

    中定义对象数组,可以显式调用构造函数,如下:

        student stud_array[2] =

        {

            student("wkf","www.mylinux.vip",13926572996),

            student("abc","china",13926572996)

        };

           给数组对象进行了初始化,初始化的数据是:

    {"wkf","www.mylinux.vip",13926572996}和{"abc","china",13926572996}

        其实,就相当于:

    student array_stud[0] = {"wkf","www.mylinux.vip",13926572996};

    student array_stud[1] = {"abc","china",13926572996};

        所以,调用对应的构造函数,创建数组对象。

    如果有如下的调用:

        student stud_array[2] =

        {

            student("wkf","www.mylinux.vip",13926572996),

            student("abc","china",13926572996),

            student("XYZ","123",13926572996)

        };

           是错误的!因为定义的 array_stud[2] 数组只能容纳 2 个元素。而赋值列表中,有3个元素,所以,创建的元素超过了数组的大小,会产生错误。

           假设有如下的数组定义:

        student stud_array[3] =

        {

            {"wkf","www.mylinux.vip",13926572996},

            {"abc","china",13926572996}

        };

           此时,定义stud_array[3]数组,数组的长度是3个元素。但是,只初始化了2个元素,那么,剩下的stud_array[2]元素也需要定义,就调用无参构造函数。

           此时,student类已经定义了构造函数,就不再提供默认的无参构造函数,所以,需要student类再定义无参构造函数。

           注意,在给数组对象赋值的时候,定义代码如下:

        student stud_array[2] =

        {

            {"wkf","www.mylinux.vip",13926572996},

            {"abc","china",13926572996}

        };

    这样的代码,在编译时提示警告,如下:

           虽然可以编译通过运行,但是,提示语法警告。而且,在windows下使用VS工具编译,编译异常。

           那么,为了解决这个编译异常,可以在初始化列表中,调用构造函数来定义对象。如下:

        student stud_array[2] =

        {

            student("wkf","www.mylinux.vip",13926572996),

            student("abc","china",13926572996)

        };

           此时,是合法的数组初始化。编译没有警告。

           可以看到,定义对象数组时,对数组进行初始化的方式,需要显示调用构造函数来进行初始化。注意:当前构造函数的调用,只是在数组对象初始化的时候使用,一般情况下,不会手动调用类的构造函数。

    5 总结

    本章讲解了对象指针的概念,其实,很简单,就是一个C++类型的指针,该指针指向一个C++类对象。

    但是,需要重点掌握的是“this指针”,掌握“C语言模拟C++的this对象思想”章节,就可以知道C语言也可以实现面向对象编程。所以,在Linux系统内核中,使用C语言就可以构造出庞大、复杂的软件系统。

    学习了C++面向对象编程,掌握面向对象编程的思路,就可以结合this指针的应用,使用C语言进行面向对象编程。作者介绍的知识点,都是基于十几年的Linux系统开发实践经验,贯穿于C/C++的程序设计。在介绍C++语言的时候,也会回顾C程序设计,使用C++的面向对象思想来应用到C语言开发中。

    读者要仔细分析,掌握好每一个知识点,然后,自己总结出对该知识点的理解。自己总结出来的知识,理解才深刻,才是自己掌握的知识。

    韦凯峰 Linux C/C++ 程序设计教程,Linux 系统编程,Openwrt 系统开发,微信:13926572996,QQ:1523520001,博客:www.mylinux.vip

     

    展开全文
  • c++ 对象数组

    2019-04-11 19:05:00
    注意:倘若使用类对象数组,则该类必须有默认构造函数。 下面给出几种定义类对象数组的方法: 1使用默认构造函数构造 stock alice[2];//用默认构造函数构造一个array 2使用构造函数来初始化数组元素 stock alice[1...

    前结提要:

    1. 构造函数与析构函数
    2. const成员函数
    3. this 指针
      注意:倘若使用类对象数组,则该类必须有默认构造函数。
      下面给出几种定义类对象数组的方法:
      1使用默认构造函数构造
    stock alice[2];//用默认构造函数构造一个array
    

    2使用构造函数来初始化数组元素

    stock alice[1]=
    {
    stock("aa",10,1);
    stock('bb",10,1);
    }//在这种情况下必须给每一个元素都调用构造函数。
    

    3如果一个类包含多个构造函数,我们同样可以使用多个构造函数来进行声明

    stock alice[10]={
    stock("aa",10,1);
    stock("bb",10,1);
    stock();
    }
    

    alice[0],alice[1]调用显式构造进行赋值,alice[2],调用stock进行赋值,剩余未在声明中定义的,将使用默认的构造函数进行声明。
    注意:cpp内部实现对象数组方式,先调用默认构造函数创造数组,然后创建临时对象用以存储{ }中内容 ,然后将临时对象中的内容赋值到对应的各个元素中。

    展开全文
  • 对象数组引例二段式初始始化 对象数组 引例 #include <iostream> using namespace std; class Stu { public: Stu(string n):_name(n){} //不带默认形参的构造器 void dis() { cout<<_name<&...
  • 【C++】4-1.8 c++对象数组对象指针和对象数组对象数组的声明方式三级目录 对象指针和对象数组 对象数组区别与对象指针, 对象指针是指向一个对象的地址,而对象数组即数组指针,指向含有对象的数组的地址; 对象指针...
  • c++对象数组初始化

    2020-04-17 16:28:32
    C++对象数组的初始化 只是对学习过程中遇到的一点小疑惑搜集了一点资料,才疏学浅,就当是笔记了。 在学习c++对象数组时,无意中发现书中写到的数组初始化,测试过程中发现若自己写上拷贝构造函数,则会报错,而如果...
  •  我们假设,学生是对象,对象的属性有ID和Score,那么如果班级里面有100个学生,那么每个对象都要用类进行实例化的话,那真是太恐怖了,此时,C++对象数组该上场了,一个数组直接搞定是不是很方便呢?...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,508
精华内容 4,203
关键字:

c++对象数组

c++ 订阅