精华内容
下载资源
问答
  • 1、在c++中,当把一个类的对象作为另一个新类的数据成员时,定义格式为: class X     {  类名1 成员名1;      类名2 成员名2;  其他成员;     } 2、如果一个类A的对象作为另一个类B的...

     

    1、在c++中,当把一个类的对象作为另一个新类的数据成员时,定义格式为:

    class  X

     

     

    {

       类名1  成员名1;

     

     

       类名2  成员名2;

       其他成员;

     

     

    }

    2、如果一个类A的对象作为另一个类B的数据成员,则在类B的对象创建过程中,调用其构造函数的过程中,数据成员(类A的对象)会自动调用类A的构造函数。

     

     

    但是应注意:

    (1)初始化列表的方式调用构造函数

          如果类A的构造函数为有参数时,则在程序中必须在类B的构造函数的括号后面加“”,和被调用的类A的构造函数,且调   用类A的构造函数时的实参值必须来自类B的形参表中的形参,

    例如对上面类X进行初始化时必须首先初始化其中的子对象,即必须首先调用这些子对象的构造函数,因此,类X的构造函数应定义为X::X(参数表0)成员1(参数表1),成员2(参数表2),成员n(参数表n){}

    其中参数表1 提供初始化成员1所需的参数,参数表2提供初始化成员2所需的参数,以此类推,并且这几个参数表中的参数都是由参数表0提供的,另外,初始化X的其他成员所需要的数据也是由参数表0提供的。

     

     

    (2)在构造新类的对象过程中,系统首先调用其子对象的构造函数去初始化子对象,然后才执行类X的自己的构造函数,初始化类中的非对象成员。对于同一类中的不同子对象,系统按照他们在类中的说明顺序调用相应的构造函数进行初始化,而不是按照初始化表的顺序进行初始化。

     

     

    展开全文
  • 一个类的对象作为另一个类的成员

    万次阅读 2011-12-07 20:06:49
    一个类的对象可以作为另一个类的数据成员,简称为对象作为成员,有时也称类之间的“复合”。要访问内部类,必须穿过外部对象,方法有两种:1是在外部类中顶一个一些公有函数,主要用于访问内部对象。2.通过 外部对象...

                  一个类的对象可以作为另一个类的数据成员,简称为对象作为成员,有时也称类之间的“复合”。要访问内部类,必须穿过外部对象,方法有两种:1是在外部类中顶一个一些公有函数,主要用于访问内部对象。2.通过 外部对象名.内部对象名.内部对象公有成员  的方式来直接访问内部对象的公有成员。

         下面举例说明:

    class		Person{
    public:
    	Date	dofb; //Date is a class
    	string	Name;
    	string	Sex;
    public:
    	Person(int d,int m,int y,string n,string s);
    	int &Year();//the first method to operate the inner class
    };
    Person::Person(int d,int m,int y, string n,string s):dofb(d,m,y),Name(n),Sex(s){
    	cout<<"initialize over"<<endl;
    }
    int	&	Person::Year(){
    	return dofb.year;
    } int _tmain(int argc, _TCHAR* argv[])
    {
    	Person	per(21,3,1999,"li","male");
    	per.Year()=2000;	cout<<per.Year()<<endl; //the first method to visit the class member
    	cout<<per.dofb.year<<endl;// the second method to visit the class member
    	return 0;
    }
    
    


    简单的实现了一下~

    展开全文
  • 怎么用一个对象调用另一个类对象的方法 比如一个类A ,一个类B,B里面有个方法show(),在main中A a=new A();B b=new B();在A中没有调用B方法情况下,我想通过a调用B中show()方法,该怎么实现。初学者,求大神给...
  • 实例化了两坐标类的对象 然后放到Line类里作为 private 成员变量了———————————————————————— 下面是我自己敲的代码 总共有5文件 首先是包含main函数的cpp文件#i

    在慕课网学习类的封装
    看着视频跟着老师敲代码感觉很简单
    关掉视频自己敲
    敲到一半发现敲不动;
    然后又反复的看了几遍视频
    最后知道了自己不会的原因
    这里写图片描述
    这是要求
    其实老师是
    实例化了两个坐标类的对象
    然后放到Line类里作为 private 成员变量了

    ————————————————————————
    下面是我自己敲的代码
    总共有5个文件
    首先是包含main函数的cpp文件

    #include "stdafx.h"
    #include<iostream>
    #include<cstdlib>
    #include"Line.h"
    using namespace std;
    
    
    int main()
    {
         Line *p = new Line;
         delete p;
    
        return 0;
    }

    其次是Line.h文件

    #pragma once
    #include"stdafx.h"
    #include"dian.h"
    
    class Line
    {
    public:
        Line();
        ~Line();
    
        void setA(int x, int y);
        void setB(int x, int y);
    
        void printInfo();
    
    
    private:
        dian A;      //类A的对象可以成为类B的数据成员
        dian B;
    };

    然后是line.cpp文件

    #include"stdafx.h"
    #include<iostream>
    #include"Line.h"
    using namespace std;
    
    Line::Line()
    {
        cout << "Line的构造函数被执行了" << endl;
    }
    Line::~Line()
    {
        cout << "Line的析构函数被执行了" << endl;
    }
    
    void Line::setA(int x, int y)
    {
        A.setX(x);
        A.setY(y);
    }
    void Line::setB(int x, int y)
    {
        B.setX(x);
        B.setY(y);
    
    }
    
    void Line::printInfo()
    {
        cout << "点A的坐标是:" << "(" <<A.getX() << "," << A.getY() << ")" << endl;
        cout << "点B的坐标是:" << "(" << B.getX() << "," << B.getY() << ")" << endl;
    }
    

    dian.h文件

    #pragma once
    #include"stdafx.h"
    
    class dian
    {
    public:
        dian();
        ~dian();
    
        void setX( int x);
        void setY( int y);
    
        int getX();
        int getY();
    
    
    private:
        int m_X;      //表示任意一个点的X坐标
        int m_Y;
    };
    
    

    dian.cpp文件

    #include"stdafx.h"
    #include<iostream>
    #include"dian.h"
    using namespace std;
    
    dian::dian() 
    {
        cout << "点的构造函数被执行了" << endl; 
    }
    dian::~dian()
    {
        cout << "点的析构函数被执行了" << endl;
    }
        void dian :: setX(int x)
        {
            m_X = x;
        }
        void dian::setY(int y)
        {
            m_Y = y;
        }
    
        int dian::getX()
        {
            return m_X;
        }
        int dian::getY()
        {
            return m_Y;
        }
    
    
    

    **

    实例化对象A时 ,如果对象A有对象成员B,那么先执行对象B的构造函数,在执行A的构造函数

    **

    展开全文
  • 一个类的对象作为另一个类的数据成员。    一个类中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个类的一个对象。用子对象创建新类。    在C++中,当把一个类的对象作为新类...
      一个类的对象作为另一个类的数据成员。
     
         一个类中的数据成员除了可以是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();
     
    }
    展开全文
  • C++在一个类中引用另一个类的对象

    千次阅读 2019-03-05 20:29:21
    #include&amp;lt;iostream&amp;gt;... int getx()//如何引用私有类的成员 { return x; } void setx(int xx) { x = xx; } int gety()//如何引用私有类的成员 { ...
  • 比如说,我在A中创建了一个对象数组。想在B中去使用这个A数组。那么有两种方式 1 继承 直接让B去继承这个A,那么在B中就可以对这个数组进行操作 如下图 这是Child,有个数组childs。长度是40; ...
  • 1、instanceof:用来测试左边对象是否是一个类: int a = 1; boolean flag= a instanceof Object; 返回结果为true,代表a是一个类,否则不是类。 2、getclass(): 比如:if(a.getClass()==String.getClass())...
  • c++在一个类中嵌套另一个类的对象

    万次阅读 2018-07-09 22:30:42
    class My2 { public: My2(); ~My2(); }; class My1 { public: My1(); ~My1();...从这里可以看出在一个类中嵌套另一个类对象的时候,先执行被嵌套的类的构造函数,在执行嵌套函数的构造函数。
  • 1.在一个类中定义另一个类的对象,则程序运行时该类的对象自动调用其构造函数初始化,然后其主类才调用构造函数初始化2.在一个类中定义另一个类的指针,需要在主类里面初始化指针,如 A* p=new A(),之后该指针可以...
  • #include /* run this program using the console pauser or add your own getch, system("pause") or input loop */ using namespace std; class Point{ int a,b; ... void Set(int m,int n){ ...
  • 我写一个类Class A,类A中有多不同构造函数: class A { public A() public A(parm1,parm2) public A(clsCustom s) //用于自定义类 } 我创建了两个对象,a1=new A(p1,p2),a2=new A(clsCustom s1) 我需要用a2自定义...
  • public class ModifierTest1 ...这程序中一共创建了两A类的对象,在类A的f()方法中创建的对象a,可以之间用a.i和a.s访问私有成员变量,而在main函数中创建的对象却不可如此使用,有点糊涂了,谁能帮忙解释下,谢了
  • 分享一个大牛人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能队伍中来!请点击http://www.captainbed.net - 方法1:类型.class,例如:String.class - 方法2:对象.getClass(),例如:"...
  • java判断对象是否是一个类的实例

    千次阅读 2019-07-05 14:34:01
    Java:如何判断一个对象是否是特定类的实例 一、InstanceOf运算符 InstanceOf运算符是用来在运行时指出对象是否是特定类的一个实例。InstanceOf通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的...
  • 用new来给一个类的对象分配空间,和使用类名称来定义一个类的对象,有什么区别?难道区别只是new的返回值是个指针,而对象定义得到的是变量名么?或者是在存储空间上不同?有什么不同呢?具体什么时候使用哪个方法呢...
  • C++类对象的赋值与复制(

    万次阅读 多人点赞 2018-08-20 17:17:07
    如同基本类型的赋值语句一样,同一个类的对象之间也是可以进行赋值操作的,即将一个对象的值赋给另一个对象。 对于类对象的赋值,只会对类中的数据成员进行赋值,而不对成员函数赋值。 例如:obj1 和 obj2...
  • 定义一个类只能创建一个对象

    千次阅读 2014-10-13 08:30:38
    有时我们程序中需要定义一个类,这个类只能创建一个youxiaosh
  • java中如何初始化一个类对象的数组

    千次阅读 2018-03-14 16:14:42
    初始化一个类对象的数组需要分两步 第一步 Animals [] an=new Animals[5]; 这只是个对象类型数组声明,里面一个类对象还是null 第二步 for(int i=0;i&lt;5;i++) an[i]=new Animals(); 对每个...
  • iphone上面判断一个对象是否是某个类的对象的方法   NSObject类的 一个函数叫做: - (BOOL)isKindOfClass:(Class)aClass;  例子代码如下:  BOOL bHeadSprite=[sprite isKindOfClass:...
  • 只是告诉编译器:“B有一个A类的对象”,并不在定义的时候创建a这个对象成员,也就不考虑它的构造函数。a这个对象成员的创建是在执行B的构造函数时进行的,B的构造函数后面必须以初始化表的形式为a对象成员提供参数...
  • 1.通过ClassLoader对象的loadClass()方法 比如以下方式: ClassLoader.getSystemClassLoader().loadClass("com.my.test.Hello") 去看一下loadClass源码: public Class<?> loadClass(String name) throws ...
  • C++面向对象程序设计中如何判断一个对象的类类型  在C++面向对象程序设计中,有时候需要判断某个对象的类类型,那么可以有下列两种方法:  方法1: 采用 typeid()函数进行判断:(缺点:当存在继承,并且子类...
  • 每个对象都可以调用类对象,如果它们是一个类出来,它们对象也是一样,所以判断对象是否属于同一个类,就判断它们对象是否相同。
  • 主要处理的问题:统计一个类中创建的对象的个数 1、在类中设置一个static的int变量,每次创建一个对象时,count加1。 staic int count=0; Person(){++count;} 2、 同时要让对象的id递增,只需把count加1的...
  • Java中如何获得一个对象所对应的类及Class类的简单理解 前言 在之前的学习中,所用的编程语言主要是Python,最近开始学习Java,熟悉Python的同学应该会知道在Python中有一个函数type(),通过这个函数可以非常...
  • 浅析new一个对象的过程

    万次阅读 2020-05-07 23:52:02
    在进行Java编程时,我们通常需要通过new创建一个对象的实例。 Object obj = new Object(); 做了三件事 (1)为对象创建了对象空间; (2)调用类的构造方法; (3)将生成对象的地址返回。 具体步骤 1,首先到常量池...
  • Java:如何判断一个对象是否是特定类的实例 一、InstanceOf运算符      InstanceOf运算符是用来在运行时指出对象是否是特定类的一个实例。InstanceOf通过返回一个布尔值来指出,这个对象...
  • class Gun: def __init__(self,model): # 枪类型 self.model = model # 子弹数量 self.bullet_number = None # 查询子弹数量 def queryBulletsNum(self): return self.bu...
  • 一、什么是对象,什么是类类比现实生活,任何一个具体的事物都可以称为对象,比如某台电脑,某本书,某个人……而类就是根据对象相似的特征和功能进行分类,对象是具体的,类是抽象的。二、类的基本格式public class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 469,060
精华内容 187,624
关键字:

一个类的对象