精华内容
下载资源
问答
  • 在建立类的对象时
    千次阅读
    2013-10-24 11:43:30
    C++中建立派生类对象时构造函数的调用顺序
    建立派生类对象时,派生类构造函数的调用顺序如下:
    1. 执行基类的构造函数。当派生类有多个基类时,处于同一层次的各个基类的构造函数的调用顺序取决于定义派生类时生命的顺序(从左至右),而与在派生类构造函数的成员初始化列表中给出的顺序无关。如果派生类的基类也是一个派生类,则每个派生类值需负责它的直接基类的构造,依次上溯。
    2. 执行成员对象的构造函数(如果有的话)。当派生类中有多个成员对象时,各个成员对象构造函数的调用顺序也取决于在派生类中定义的顺序(自上而下),而与在派生类构造函数的成员初始化列表中给出的顺序无关。
    3. 执行派生类的构造函数。
    派生类构造函数的定义中可以省略对基类构造函数的调用,其条件是基类中必须有默认的构造函数或者根本就没有定义构造函数。

    派生类析构函数的调用顺序:
    1. 执行派生类的析构函数,对派生类新增普通成员进行清理。
    2. 调用成员对象析构函数,对派生类新增的成员对象进行清理。
    3. 调用基类的析构函数,对基类进行清理。
    派生类析构函数的定义与基类无关,与没有继承关系的类中的析构函数的定义完全相同。它只负责新增成员的清理工作,系统会自己调用基类及成员对象的析构函数进行相应的清理工作。
     
    #include <iostream>
    #include <stdio.h>
    #include<math.h>
    #include <string.h>
    
    using namespace std;
    
    class BaseA
    {
    public :
        BaseA(int i)
        {
            a=i;
            cout<<"BaseA 's constructor called!"<<endl;
        }
        ~BaseA(){cout<<"BaseA 's destructor called!"<<endl;}
        int GetA(){return a;}
    private:
        int a;
    };
    class BaseB
    {
    public :
        BaseB(int i)
        {
            b=i;
            cout<<"BaseB 's constructor called!"<<endl;
        }
        ~BaseB(){cout<<"BaseB 's destructor called!"<<endl;}
        int GetB(){return b;}
    private:
        int b;
    };
    class Member
    {
    public :
        Member(int i)
        {
            m=i;
            cout<<"Member 's constructor called!"<<endl;
        }
        ~Member(){cout<<"Member 's destructor called!"<<endl;}
        int GetM(){return m;}
    private:
        int m;
    };
    class Derived:public BaseB,public BaseA
    {
    public:
        Derived(int i,int j,int k,int l);
        ~Derived(){cout<<"Derived 's destructor called!"<<endl;}
        void Print()
        {
            cout<<GetA()<<","<<GetB()<<","<<mem.GetM()<<","<<d<<endl;
        }
    private:
        Member mem;
        int d;
    };
    Derived::Derived(int i,int j,int k,int l):BaseB(j),BaseA(i),mem(k)
    {
        d=l;
        cout<<"Derived 's constructor called!"<<endl;
    }
    
    int main()
    {
        Derived obj(1,2,3,4);
        obj.Print();
    	return 0;
    }
    运行结果是:
    BaseB 's constructor called!
    BaseA 's constructor called!
    Member 's constructor called!
    Derived 's constructor called!
    1,2,3,4
    Derived 's destructor called!
    Member 's destructor called!
    BaseA 's destructor called!
    BaseB 's destructor called!

    更多相关内容
  • 创建派生类对象时,构造函数的执行顺序是: 调用构造函数先调用基类的构造函数,调用对象成员的构造函数,最后调用派生类本省的构造函数。 例: 这里插入代码片 #include <iostream > using ...

    在创建派生类对象时,构造函数的执行顺序是:
    在调用构造函数时先调用基类的构造函数,在调用对象成员的构造函数,最后在调用派生类本省的构造函数。
    例:

    #include <iostream >
    using namespace std;
    class B1
    {
    public:
     	B1() 
    	{ 
    		cout << "Construct B1"<<endl; 
    	} 
     	~B1() 
    	{ 
    		cout<< "Destruct B1" << endl; 
    	}
    };
    class B2
    {
    public:
    	B2() 
    	{ 
    		cout << "Construct B2" << endl; 
    	}
     	~B2() 
    	{ 
    		cout << "Destruct B2 " << endl; 
    	}
    };
    class D : public B2, public B1
    {
    public:
    	D() : B2( ), B1( ) 
    	{ 
    		cout << "Construct D" << endl; 
    	}
      ~D() 
    	{
    	 	cout << "Destruct D" <<endl; 
    	}
     private:
       B2  b2;
       B1  b1;
    };
    int main()
    {
     	D d;
    	return 0;  
    }
    
    

    在这里插入图片描述

    展开全文
  • 创建派生类对象,构造函数的执行顺序

    万次阅读 多人点赞 2019-04-24 22:04:10
    创建派生类对象,构造函数的执行顺序() 正确答案: A A 基类构造函数,派生类对象成员构造函数,派生类本身的构造函数 B 派生类本身的构造函数,基类构造函数,对象成员构造函数 C 基类构造函数,派生类...

    在创建派生类对象,构造函数的执行顺序()
    正确答案: A

    • A 基类构造函数,派生类对象成员构造函数,派生类本身的构造函数

    • B 派生类本身的构造函数,基类构造函数,对象成员构造函数

    • C 基类构造函数,派生类本身的构造函数,派生类对象成员构造函数

    • D 对象成员构造函数,基类构造函数,派生类本身的构造函数

    对象创建时代码的加载顺序为:静态代码 --> 非静态代码 --> 构造方法。

    若继承了父类,则加载顺序为:父类的静态的代码 --> 子类的静态的代码 --> 父类内部非静态代码 --> 父类的构造方法 --> 子类的非静态代码 --> 子类的构造方法。

    其中,静态代码包括(静态方法,静态变量,静态代码块等),非静态代码即(成员方法,成员变量,成员代码块等),同一种代码,写在上面的先加载

    
    public class ExtendsTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		C c = new D();
    	}
    
    }
    
    class C {
    	static {
    		System.out.println("C 基类静态域 ");
    	}
    	{
    		System.out.println("C 基类对象成员构造函数");
    	}
    
    	public C() {
    		System.out.println("C 基类本身的构造函数");
    	}
    }
    
    class D extends C {
    	static {
    		System.out.println("D 派生类静态域");
    	}
    	{
    		System.out.println("D 派生类对象成员构造函数");
    	}
    
    	public D() {
    		System.out.println("D 派生类本身的构造函数");
    	}
    }
    
    

    在这里插入图片描述

    展开全文
  • 一个对象作为另一个的数据成员。 &nbsp; &nbsp; &nbsp; &nbsp;一个中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个的一个对象。用子对象创建新。 &...
      一个类的对象作为另一个类的数据成员。
     
         一个类中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个类的一个对象。用子对象创建新类。
     
         在C++中,当把一个类的对象作为新类的数据员时,则新类的定义格式可表示为:
     
    class X
     
    { 类名1  成员名1;
     
      类名2  成员名2;
     
      ……
     
      类名n  成员名n;
     
      ……//其它成员
     
    };
     
    (3)如果一个类A的对象作为另一个类B的数据成员,则在类B的对象创建过程中,调用其构造函数的过程中,数据成员(类A的对象)会自动调用类A的构造函数。
     
    但应注意:如果类A的构造函数为有参函数时,则在程序中必须在类B的构造函数的括号后面加一“:”和被调用的类A的构造函数,且调用类A的构造函数时的实参值必须来自类B的形参表中的形参。这种方法称为初始化表的方式调用构造函数。如:以上面定义的类X为例,在对类X的对象进行初始化时,必须首先初始化其中的子对象,即必须首先调用这些子对象的构造函数。因此,类X的构造函数的定义格式应为:
     
    X::X(参数表0):成员1(参数表1),成员2(参数表2),…,成员n(参数表n)
     
    { ……}
     
    其中,参数表1提供初始化成员1所需的参数,参数表2提供初始化成员2所需的参数,依此类推。并且这几个参数表的中的参数均来自参数表0,另外,初始化X的非对象成员所需的参数,也由参数表0提供。
     
    在构造新类的对象过程中,系统首先调用其子对象的构造函数,初始化子对象;然后才执行类X自己的构造函数,初始化类中的非对象成员。对于同一类中的不同子对象,系统按照它们在类中的说明顺序调用相应的构造函数进行初始化,而不是按照初始化表的顺序。












    以下定义了三个Student、Teacher和Tourpair,其中Student类的对象和Teacher类的对象作为了Tourpair的数据成员,观察对象的构造过程和构造函数被执行的顺序。
     

    include <iostream.h>

     
    class Student
     
    { public: 


       Student()
     
        { cout<<”construct student.\n”;
     
           semeshours=100;
     
           gpa=3.5;   }   


    protected:
     
         int semeshours;
     
         float gpa;
     
    };
     
    class Teacher
     
    { public:
     
         Teacher()
     
       { cout<<”construct Teacher.\n”; 


        }
     
     };
     
    class Tourpair
     
    {public:
     
         Tourpair()
     
         {cout<<”construct tourpair.\n”;
     
          nomeeting=0;  }
     
      protected:
     
          Student student;
     
          Teacher teacher;
     
          int nomeeting;
     
     };
     
    void main()
     
    {Tourpair tp;
     
    cout<<”back in main.\n”; }
     
    其执行结果是:
     
       construct student.
     
       construct teacher.
     
       construct tourpair.
     
       back in main.
     
          由此可见:主函数main()运行开始时,遇到要创建Tourpair类的对象,于是调用其构造函数Tourpair(),该构造启动时,首先分配对象空间(包含一个Student对
     
    象、一个Teacher对象和一个int型数据),然后根据其在类中声明的对象成员的次序依次调用其构造函数。即先调用Student()构造函数,后调用Teacher()构造函数,最后才执行它自己的构造函数的函数体。
     
         由于上例中Tourpair类的数据成员student和teacher的构造函数都是无参函数,所以系统在构造student和teacher对象时会自动调用各自的构造函数Student()和Teacher(),而不需要用初始化表的方式去调用。
     
    【例3-7】试分析以下程序的执行结果:
     

    include <iostream.h>

     

    include <string.h>

     
    class Student
     
    { public:
     
       Student(char *pName=”No name”)
     
          { cout<<”构造新同学:”<<pName<<endl;
     
             strncpy(name,pName,sizeof(name)); char * strncpy(char *dest, char *src, size_t n); 将字符串src中最多n个字符复制到字符数组dest中(它并不像strcpy一样遇到NULL才停止复制,而是等凑够n个字符才开始复制),返回指向dest的指针。              C语言中判断数据类型长度符
     
             name[sizeof(name)-1]=’\0’;  


            }
     
     Student(Student &s)
     
          { cout<<”构造copy of “<<s.name<<endl;
     
             strcpy(name, ” copy of “);  extern char *strcpy(char *dest,char *src);    把src所指由NULL结束的字符串复制到dest所指的数组中
     
             strcat(name,s.name);    extern char *strcat(char *dest,char *src);          把src所指字符串添加到dest结尾处(覆盖dest结尾处的’\0’)并添加’\0’。
     
             }
     
    ~Student()
     
     { cout<<”析构 “<<name<<endl; }
     
        protected:
     
        char name[40];  };
     
    class Tutor
     
    { public: 


           Tutor(Student &s):student(s)//此为初始化表,调用
     
                                                         //Student的拷贝构造函数
     
           { cout<<”构造指导教师 \n”;  }
     
       protected:
     
            Student student;
     
     };
     
    void main()
     
    {  Student st1;   //此处调用Student的构造函数Student(char  


               *pName=”No name”)
     
       Student st2(“zhang”); //同上
     
       Tutor tutor(st2); //此处调用Tutor的构造函数Tutor(Student &s)
     
       //在构造tutor对象的过程中,用初始化表调用
     
       //Student类的拷贝构造函数Student(Student &s)
     
    }
     
    执行结果如下:
     
    构造新同学:No name
     
    构造新同学:zhang
     
    构造copy of zhang
     
    构造指导教师
     
    析构  copy of zhang
     
    析构 zhang
     
    析构 No name
     
    3.2.7 利用初始化表对常量数据成员或引用成员提供初值
     
         如前所述,构造函数可对对象的数据成员进行初始化,但若数据成员为常量成员或引用成员时,就有所不同,如:
     
    class Sillyclass
     
    { public :
     
    Sillyclass()   // 此构造函数对成员ten和refi的初始化错误。
     
        { ten=10;
     
           refi=i; }
     
    protected:
     
        const int ten;   //常量数据成员ten
     
        int &refi;         //引用refi
     
    };
     
    说明:
     
    1. 造成以上错误的原因是在Sillyclass类的构造函数进入之后(开始执行其函数体时),对象结构已经建立,数据成员ten和refi已存在,而其数据成员ten为const,而refi为引用,所以在构造函数体内不能再对其指派新的值。
     
    2. 解决以上问题的方法是利用初始化表:在构造函数的括号后面加一“:”和初始化表,初始化表的格式是:
     
    数据成员名(值),如果有多个时,需要用逗号隔开。
     
    【例3-8】 类employee中包括私有数据成员x, 和2个公有函数成员example、show。程序中使用初始化表是x(215)。
     

    include <windows.h>

     

    include <iostream.h>

     
    // 定义类 employee
     
    class  employee
     
    {private:
     
         const int x;
     
      public:
     
         employee ();
     
         void show(); 


     };
     
    // employee的类外定义
     
    employee :: employee () : x (215)   // 初始化表
     
    {                   }
     
    // show()的定义。
     
    void employee :: show()
     
    {  cout << “\n    x的值是:”<< x << endl; }
     
    // 主函数
     
    void main()
     
    {   //生成对象并为x赋予初始值
     
       employee obj;
     
         //调用show显示x的值
     
       obj.show();
     
    }

    展开全文
  • Connection对象也称为连接对象,用来创建一个与指定数据源的连接,包括Microsoft SQL server、Oracle以及能够为其指明一个OLEDB提供程序或一个ODBC驱动器的任何数据源。不同的.NET数据提供程序都有自已的连接。...
  • 可以建立对象的情况下调用成员吗? 非静态成员不能,非静态成员是随着对象存在而产生的,没有对象也就不会存在非静态成员,静态的可以,类名::成员名方式访问。 静态的成员变量和函数存在全局段,整个程序...
  • 利用构造函数对类对象进行初始化

    千次阅读 2017-05-01 20:25:22
    9.1利用构造函数对类对象进行初始化 9.1.1对象的初始化 程序中常常需要对变量赋初值,即对其初始化。 那么,怎样使他们得到初值呢?有人试图声明类对数据成员初始化。如 class Time { hour=0; minute=0...
  • C++创建类对象的两种方法(Qt)

    千次阅读 2020-06-09 10:35:18
    1.直接创建类对象 类名+对象名; 对象名.方法(); 注意:如果需要一个类中使用另一个类的函数;类的头文件中 加上 "class 待引用类名 "。 2.如果需要类之间传递一些指针,函数之类的。 头文件: cpp文件: ...
  • C++对象的使用之对象指针

    万次阅读 多人点赞 2019-07-04 21:38:07
    对象的使用之对象指针 对象指针的一般概念 对象指针:指向的成员的指针。C++中,可以说明指向的数据成员和成员函数的指针。 对象指针遵循一般变量指针的各种...在建立对像,编译系统会为每一个对像分配...
  • 文章目录C++对象的指针的区别指向地址的指针指针本身的大小指向数组的指针指针数组指向指针数组的指针多维指针数组函数参数中使用指针数组指针传址实现数组求和函数指针模仿C++ 类别函数指针数组对象指针...
  • 浅论创建子类对象时是否创建了父类对象

    千次阅读 多人点赞 2018-09-08 11:51:57
    我们都知道创建子类对象时,调用子类构造方法前,必须调用父类的构造方法。 那么调用构造方法就代表着创建对象了吗? 假设1: 如果创建子类对象没有创建父类对象,那么我们子类继承过来的属性和通过super调用的...
  • C++对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    //有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象数组的初始化:对象数组的初始化通常也是由构造函数来完成的。 Eg: #include”student.h” int main ...
  • 【C++】C++对象、构造函数和析构函数

    千次阅读 多人点赞 2018-06-03 20:32:37
    它即可包含描述事物的数据,又可包含处理这些数据的函数,类在程序运行是被用作样板来建立对象的。所以要建立对象,首先必须定义。 定义 定义一个的一般格式为: class 类名{ private: 成员表1; public:...
  • java中创建类对象的各种方法

    千次阅读 2018-01-18 00:15:50
    最近听朋友提起面试题的时候,加上整理复习汇总java基础知识,刚好写下来记录创建java对象的方法,又称为java的实例化,有很多种,列举如下:一、使用Spring管理创建学过Spring框架的同学都知道,我们可以利用...
  • C++中,类对象的建立方式有两种,一种是静态建立类对象,如A a;另一种是动态建立类对象,如A* p = new A; 这两种方式是有区别的:  静态建立类对象:是指全局对象,静态对象,以及分配栈区域内的对象,...
  • 对象的抽象就是的具体化就是对象,也可以说的实例化就是对象实际上就是一种数据类型。具有属性用数据结构来描述的属性。具有操作,它是对象的行为的抽象,用操作名和实现该操作的方法来描述。 二...
  • 这种情况搞不懂,创建对象成功了,是只要把抽象方法给具现化了就能创建吗? ``` abstract class Driver { public abstract void drive(); } public class Test { public static void main(String[] args) ...
  • 采用面向对象方法开发软件,通常需要建立三种形式的模型,它们分别是: 描述系统数据结构的 ( 1 ) ,该模型主要用 ( 2 ) 来展现。 描述系统控制结构的 ( 3 ) ,该模型通常用 ( 4 ) 来表示。 描述系统功能的 ...
  • Rational Rose建立对象

    万次阅读 2019-04-18 11:23:41
    确定对象图中有哪些,并浏览器窗口中,建立每个。 步骤: (1)Logic View中添加Person、Company。如图1-20所示。 图1-20 新建Person和Company 2.2建立对象图 步骤: (1)右击LogicalView, ...
  • 搜索引擎中,在建立了正排表后需要对正排表按照wordId进行排序,且该排序要保持稳定的特性。因此想到了 python 的列表中存储一个,通过指定的某个属性来进行排序。具体代码如下: 1.首先定义,按照需求...
  • c++采用new建立对象数组

    万次阅读 热门讨论 2018-07-17 20:24:40
    推荐用vector。 参考此文:... object *p = new object[3]; p[0] = ...上述情况是否需要定义构造函数?答案是不需要(有默认构造函数就足够了)。如果对象有用户自定义的构造函数...
  • 从什么是类开始说起… 我们都知道类也是由成员变量`构造器和方法等构成的 所以其本质也是一个一个的对象 需要通过对象来描述和创建 ...Class类对象无法直接创建 因为它的构造方法是私有的 是由JVM随...
  • C++构造函数初始化类对象

    万次阅读 多人点赞 2019-04-12 15:53:51
    在类外构造函数,需要在类内进行声明。 【4】构造函数的名字必须与类名相同。 【5】构造函数通常用于对内的数据进行初始化。 二.构造函数的分类 无参的构造函数 有参的构造函数 参数初始化表的构造函数【重点】...
  • C++中,类的对象建立分为两种,一种是静态建立,如A a;另一种是动态建立,如A* ptr=new A;这两种方式是有区别的。...动态建立类对象,是使用new运算符将对象建立堆空间中。这个过程分为两步,第一步是执...
  • 建立动态模型 开发交互式系统,动态模型非常...从脚本提取所有外部事件,确定每事件发送和接收对象。 针对系统中的典型功能,画出顺序图 用一张状态图描绘的行为,集中考虑具有交互行为。 画出系统中重点
  • Python学习笔记(九):对象

    万次阅读 热门讨论 2021-02-10 01:16:44
    类和对象类的定义类的实例化类对象的使用二.self用法三.类方法实例方法类方法静态方法静态方法和类方法的区别四.类命名空间 一.类和对象 类(class)和对象(object,也被称为实例,instance),可以把类理解成某种...
  • Pb语言中的对象

    千次阅读 2017-03-26 13:24:24
    对象是相关但不相同的概念。对象是一个的实例,而可以有零个或多个实例。对象(object)是相关函数和...用户PowerBuilder中创建的所有窗口都属于Window。对象的实际物理表示,是用户创建和取消的内容。
  • 建立对象模型即使用UML画类图

    万次阅读 多人点赞 2017-06-04 12:37:01
    UML类图画法及其之间的几种关系 最近复习软件工程的考试,大...看见建立对象模型的题目首先想到就是使用UML画类图,有一定的步骤 文章目录如下: 类图画法 之间的几种关系:泛化(Generalization)、实现(Reali
  • 实验八 建立对象模型阅读有关“自行车租赁管理系统”的说明,建立该系统的对象模型。要求:使用Microsoft Office Visio或其它工具绘制类图。【说明】系统管理员利用系统进行自行车清单维护和客户清单维护。自行车...
  • java.lang.Class和反射机制创建对象

    万次阅读 2015-11-24 00:12:02
     Java程序运行,Java运行系统一直对所有的对象进行所谓的运行类型标识。这项信息纪录了每个对象所属的。虚拟机通常使用运行类型信息选准正确方法去执行,用来保存这些类型信息的是Class。Class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,130,212
精华内容 452,084
关键字:

在建立类的对象时