精华内容
下载资源
问答
  • c++包含对象成员

    千次阅读 2019-04-26 10:03:44
    成员对象:当一个的成员是另一个的对象时,这个对象就叫成员对象。 我们知道,继承满足的关系是:is a关系,而成员对象满足的关系是has a关系,比如学生和分数,显然学生有分数,所以分数可以作为学生的...

    成员对象

    成员对象:当一个类的成员是另一个类的对象时,这个对象就叫成员对象。

    我们知道,继承满足的关系是:is a关系,而成员对象满足的关系是has a关系,比如学生类和分数类,显然学生有分数,所以分数类可以作为学生类的成员对象


    成员对象的构造与析构

    1、出现成员对象时,如果成员对象的构造函数是有参构造函数,则该类的初始化列表需要对成员对象进行初始化。class

    Member {
      private:
        int i;
      public:
        Member(int i)
        {
            this->i = i;
        } }; class Test {
      private:
        Member member;
      public:
        Test(): member(1)
        {
        } }; 
    

    2、一个含有成员对象的类实例化时要先调用成员对象的构造函数,然后再调用该类的构造函数,析构时先调用该类的析构函数,再调用成员对象的析构函数。

    3.如果你将成员对象分数设为私有,那么就不能通过student.fenshu.getfenshu()这种实例化fenshu的方式来访问getfenshu()函数(即成员对象的函数),因为成员对象分数为私有,就不能实例化来访问它,所以student.fenshu就是错的。但是既然成员对象分数为私有,我们就可以在student中建一个接口函数show_stu_fenshu来直接访问fenshu.getfenshu()。

    举例:

    void Student::show_stu_fenshu()
    {
        this->stu.show_name(); //通过this先直接访问类对象成员stu,再访问stu的成员函数show_name()
    }
    

    school.h:

    #ifndef SCHOOL_H
    #define SCHOOL_H
    #include <student.h>
    #include <string>
    #include <iostream>
    using namespace std;
    
    class School
    {
    private:
        string name;
        Student stu;
    
    
    public:
        School();
    
        School(string a);
    
        void show_stu_name();
    };
    
    #endif // SCHOOL_H
    

    school.cpp:

    #include "school.h"
    using namespace std;
    
    School::School()
    {
        this->name = "none";
        cout << "this is default constructor of school" << endl;
    }
    
    School::School(string a):stu("zouxu",666)
    {
        this->name = a;
        cout << "this is hancan constructor of school" << endl;
    }
    
    
    void School::show_stu_name()
    {
        this->stu.show_name();
    }
    

    student.h:

    #ifndef STUDENT_H
    #define STUDENT_H
    #include <string>
    #include <iostream>
    using namespace std;
    
    class Student
    {
    private:
        string name;
        int age;
    
    public:
        Student();
    
        Student(string a ,int b);
    
        void show_name() const;
    
        void show_age() const;
    
    
    };
    
    
    #endif
    

    student.cpp:

    #include "student.h"
    #include <iostream>
    
    using namespace std;
    
    Student::Student()
    {
        this->name = "none";
        this->age = 0;
        cout << "this is default constructor of student" << endl;
    }
    
    Student::Student(string a,int b)
    {
        this->name = a;
        this->age = b;
        cout << "this is hancan constructor of student" << endl;
    }
    
    void Student::show_name() const
    {
        cout << this->name << endl;
    
    }
    
    void Student::show_age() const
    {
        cout << this->age << endl;
    
    }
    

    main.cpp:

    #include <iostream>
    #include <student.h>
    #include <school.h>
    #include <string.h>
    using namespace std;
    
    int main()
    {
        School school("mianzhong");
        //school.stu.show_name();  it is wrong
        school.show_stu_name();
    
        return 0;
    }
    
    展开全文
  • 成员对象和封闭

    千次阅读 2015-07-29 10:55:52
    封闭包含成员对象类叫封闭(Enclosing)class CTyre{ private: int radius; int width; public: CTyre(int r,int w):radius(r),width(w){} }; class CEngine{ }; class CCar{ private:

    基本概念

    成员对象:一个类的成员变量是另一个类的对象
    封闭类:包含成员对象的类叫封闭类(Enclosing)

    class CTyre{
    private:
        int radius;
        int width;
    public:
        CTyre(int r,int w):radius(r),width(w){}
    };
    class CEngine{
    };
    class CCar{
    private:
        int price;
        CTyre tyre;
        CEngine engine;
    public:
        CCar(int p,int tr,int tw);
    };
    CCar::CCar(int p,int tr,int w):price(p),tyre(tr,w){
    };
    int main(){
        CCar car(20000,17,225);
        return 0;
    }

    如果CCar类不定义构造函数,则
    CCar car;// 编译出错
    因为编译器不知道car.tyre如何初始化,car.engine初始化没有问题,用默认构造函数
    生成封闭类对象的语句,要明确“对象中的成员对象”如何初始化

    封闭类构造函数的初始化列表

    定义封闭类构造函数时,添加初始化列表:
    类名::构造函数(参数表):成员变量1(参数表),成员变量2(参数表), …
    {
    ……
    }
    成员对象初始化列表中的参数:任意复杂的表达式;函数/变量/表达式中的函数,变量有定义

    调用顺序

    当封闭类对象生成时:
    1)先执行所有成员对象的构造函数
    2)再执行封闭类的构造函数

    成员对象的构造函数调用顺序:
    1)和成员对象在类中的说明顺序一致
    2)与在成员初始化列表中出现的顺序无关

    当封闭类的对象消亡时:
    1)先执行封闭类的析构函数
    2)再执行成员对象的析构函数

    析构函数顺序和构造函数的调用顺序相反

    class CTyre{
    public:
        CTyre(){cout<<"CTyre contructor"<<endl;}
        ~CTyre(){cout<<"CTyre destructor"<<endl;}
    };
    class CEngine{
    public:
        CEngine(){cout<<"CEngine contructor"<<endl;}
        ~CEngine(){cout<<"CEngine destructor"<<endl;}
    };
    class CCar{
    private:
        CEngine engine;
        CTyre tyre;
    public:
        CCar(){cout<<"CCar contructor"<<endl;}
        ~CCar(){cout<<"CCar destructor"<<endl;}
    };
    
    int main(){
        CCar car;
        return 0;
    }

    程序输出结果:
    CEngine constructor
    CTyre constructor
    CCar constructor
    CCar destructor
    CTyre destructor
    CEngine destructor

    展开全文
  • (2)当一个中含有对象成员时,在启动本的构造函数之前,先分配对象空间,按对象成员的声明顺序执行他们各自的构造函数,再继续执行本的构造函数; (3)对于非静态的局部对象,他们的析构函数的执行顺序与...

    首先,我们来看一段代码:

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
    	A()
    	{
    		cout << "A's constructor." << endl;
    	}
    	~A()
    	{
    		cout << "A's destructor." << endl;
    	}
    };
    
    class B
    {
    public:
    	B()
    	{
    		cout << "B's constructor." << endl;
    	}
    	~B()
    	{
    		cout << "B's destructor." << endl;
    	}
    };
    
    class C
    {
    private:
    	B bInC;
    public:
    	C()
    	{
    		cout << "C's constructor." << endl;
    	}
    	~C()
    	{
    		cout << "C's destructor." << endl;
    	}
    	A aInC;
    };
    
    class D:public C
    {
    public:
    	D()
    	{
    		cout << "D's constructor." << endl;
    	}
    	~D()
    	{
    		cout << "D's destructor." << endl;
    	}
    	A aInD;
    private:
    	B bInD;
    };
    
    int main(void) {
    	D d;
    	return 0;
    }

    那么,这段程序执行后,输出什么呢?

    B's constructor.
    A's constructor.
    C's constructor.
    A's constructor.
    B's constructor.
    D's constructor.
    D's destructor.
    B's destructor.
    A's destructor.
    C's destructor.
    A's destructor.
    B's destructor.

    分析如下:

    (1)存在继承关系时,先执行父类的构造函数,再执行子类的构造函数;

    (2)当一个类中含有对象成员时,在启动本类的构造函数之前,先分配对象空间,按对象成员的声明顺序执行他们各自的构造函数,再继续执行本类的构造函数;

    (3)对于非静态的局部对象,他们的析构函数的执行顺序与构造函数相反。

    在本程序中:

    (1)执行main(),需要创建一个对象d,所以,需要执行D的构造函数。而D继承自C,所以先要执行C的构造函数;

    (2)而在C中存在对象成员bInC和aInC,所以,在C的构造函数执行之前,先按声明顺序执行B和A的构造函数,然后执行C的构造函数;

    (3)轮到构造d了,但是D中有对象成员aInD和bInD,所以,在D的构造函数执行之前,先按声明顺序执行A和B的构造函数,最后,执行D的构造函数;

    (4)以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。

    最终的执行结果就不言而喻了。

    学无止境,共同学习。若本文所述存在错误或不妥之处,欢迎指正~

    展开全文
  • 最近研究WPF,遇到并解决了一些难题(至少是初学者的入门难题),包括: 1)控件如何绑定数据? ...4)控件如何绑定类对象成员变量? 5)每次加载页面时,都会重新初始化,如何保持数据不变?
  • C++中有一种类型成员,属于本身,而不属于对象,这种类型成员成为类成员,而属于对象成员成为对象成员或实例成员。可以使用关键字static来创建一个类成员。 static声明与定义 class C { public: //... ...

    类数据成员

    C++类中有一种类型成员,属于类本身,而不属于类的对象,这种类型成员成为类成员,而属于对象的成员成为对象成员实例成员。可以使用关键字static来创建一个类成员。

    static声明与定义

    class C
    {
    public:
        //...
    private:
        static unsigned n;
        //...
    };
    unsigned C::n=0; //在外部定义时不需要加static
    

    在类声明内部声明的static数据成员必须在任何程序块之外定义。通过外部定义将C::n初始化为0,但这不是必须的,因为在创建第一个对象时,所有的静态数据都会被初始化为零,除非提供一个不同的初值。并且在类体外定义的,不必使用static
    static数据成员不会影响该类及其对象的sizeof

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        int a;
        unsigned long b;
        //...
    private:
        //static unsigned n1; //does not impact sizeof(C)
        //static unsigned n2; //does not impact sizeof(C)
        //...
    };
    int main()
    {
        cout<<sizeof(C)<<endl;
        C c1;
        cout<<sizeof(c1)<<endl;
        return 0;
    }
    

    类成员函数

    除了static数据成员,类还可以有static成员函数。静态成员函数只能访问其他的static成员,包括数据成员和成员函数。

    class C
    {
    public:
        static unsigned getN()
        {
            setST(); //ERROR:not static!
            return n;
        }
    private:
    	unsigned n;
    }
    

    静态成员函数与非静态成员函数差别是:非static成员函数既可以访问static数据成员,也可以访问非static数据成员;而static成员函数只能访问static成员。

    类的static成员的访问

    有两种不同方式来访问类的static成员,既可以通过C的对象来访问,也可以直接通过类C来访问。

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        static void getN()
        {
            cout<<n<<endl;
        }
    private:
        static unsigned n;
    };
    unsigned C::n=10;
    int main()
    {
        C::getN(); //直接通过类C来访问
        C c1; 
        c1.getN(); //通过C的对象来访问
        return 0;
    }
    

    在类成员函数内定义static变量

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        void m();
    private:
        static unsigned n;
    };
    unsigned C::n=100;
    void C::m()
    {
        static int s=0;
        cout<<"s="<<++s<<endl;
        cout<<"n="<<n++<<endl;
        cout<<endl;
    }
    int main()
    {
        C c1,c2; 
        c1.m(); 
        c2.m();
        c1.m();
        return 0;
    }
    

    输出结果:

    s=1
    n=100
    
    s=2
    n=101
    
    s=3
    n=102
    

    本例在成员函数m中定义了一个static变量s,由于s定义在程序块内,他拥有程序块范围,因为只能在m内部访问。每调用m一次,s就会相应的增加一次,又因为m是C的成员函数,所以C的所有对象都共享这个静态局部变量,这样,对m的每一次调用访问的都是同一个s,同样,对于静态局部变量n来说,它也是一个静态局部变量,所以C的所有对象也都共享这个局部变量。

    展开全文
  • 在C++的成员函数中,允许直接访问该对象的私有成员变量。 b. 在成员函数中可以访问同类型实例的私有变量。 c. 拷贝构造函数里,可以直接访问另外一个同类对象(引用)的私有成员。 d. 成员...
  • 对象成员(整理)

    千次阅读 2020-08-03 12:39:53
    新的概念:对象成员 C++程序中可能会涉及到许多对象,这些对象间如何发生联系? C++为对象之间的联系提供了如下...这意味着一个A的“大对象包含着一个B的“小对象” 也就是说,B对象属于A对
  • C++中对象以及成员函数

    千次阅读 2017-11-17 16:57:23
    一个实体拥有自己的属性和行为,属性是私有的,行为是共有的,在C++中实体对应的就是对象,实体抽象数据类型就是,属性是成员变量,行为是成员函数。 面向对象思想的三大特征: 封装、继承、多态(静多态,动多态...
  • 本文实例讲述了Python面向对象程序设计变量与成员变量、方法与成员方法用法。分享给大家供大家参考,具体如下: 文章目录变量与成员变量1、若变量与成员同时存在并且同名2、若变量存在,成员变量不存在,3...
  • 很多人都知道C++是由结构体发展得来的,所以他们的成员变量(C语言的结构体只有成员变量)的内存分配机制是一样的。下面我们以来说明问题,如果的问题通了... 一个类对象的地址就是包含的这一片内存空间的
  • 一个对象作为另一个的数据成员。 &nbsp; &nbsp; &nbsp; &nbsp;一个中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个的一个对象。用子对象创建新。 &...
  • C++对象数组和成员对象

    千次阅读 2017-04-20 20:16:04
     对象数组是指数组元素为对象的数组,该数组中的每一个元素都是同一个对象。  定义格式:  [].... 例:date dates[5];  使用对象数组成员的格式:  []. 例:dates[0].year  
  • C#第3讲:对象的主要成员

    千次阅读 多人点赞 2018-08-13 15:27:59
    c#是一个面向对象的语言,就是对现实世界某个事物的抽象,比如“人”他在程序中就可以用一个来表示,人有年龄(Age),有姓名(Name),人还可以吃饭(Eat)和睡觉(Sleep),根据这几点我们就可以创建一个来...
  • 在java中实例对象访问类成员(静态变量),实际上是委托给该来访问类成员,因此即使某个实例为null,他也可以访问他所属类成员。package cn.com.postel.wbb.crazyJava; public class NullAccessStatic { ...
  • c++结构体中包含类对象成员的问题

    千次阅读 2012-03-07 14:55:00
    //使用 new 会调用成员的构造函数 //。。。 delete a; 或者(待验证) 2、void *v = malloc(sizeof(A)); A *a = new (v)A; //...... a->~A(); free(v);  ref:  ...
  • C++中的对象成员

    千次阅读 2018-07-27 11:04:56
    譬如定义一个A,B,其中A为B的函数成员,此时,A为B的对象成员 程序的结果分析如下: 第一步:A pa(0,0),调用A的构造函数,长生第一行结果: AAAAAAAAAA 第二步:pa.printA();调用A的成员函数...
  • 转自:http://www.cnblogs.com/yanqi0124/p/3828507.html私有成员变量的概念,在脑海中的现象是,以private关键字声明,是的实现部分,不对外公开,不能在对象外部访问对象的私有成员变量. 然而,在实现拷贝构造...
  • 会先创建Stu,对象成员,然后再创建banji 然而我们如果在Banji的构造函数里面初始化Stu,那就来不及了! 这时候,我们应该使用初始化列表! 因为初始化列表在构造函数的函数体执行顺序之前! 能够在初始...
  • 第五讲:成员对象成员的引用  掌握:类成员函数的性质、定义及存贮方式。对象成员三种引用方式,。  理解:函数、作用域运算符、inline成员函数的概念。  重点、难点: 类成员函数的性质、定义、存贮...
  • 关于类成员函数中访问同类对象的私有成员,主要包含以下几种场景: a. 在C++的成员函数中,允许直接访问该对象的私有成员变量。 b. 在成员函数中可以访问同类型实例的私有变量。 c. 拷
  • 新手小白学JAVA 面向对象 对象 封装

    万次阅读 多人点赞 2021-05-06 15:58:57
    面向对象概念 面向对象其实是一种编程思想,通过它可以把生活中复杂的事情变得简单化,从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. ...
  • 对组合当创建该对象时其中包含的各个对象成员也将被自动创建故该的构造函数应包含对其中对象成员的初始化通常采用成员初始化列表的方法来初始化对象成员成员初始化列表中既包含对象成员的初始化又包含对...
  • 对组合当创建该对象时其中包含的各个对象成员也将被自动创建故该的构造函数应包含对其中对象成员的初始化通常采用成员初始化列表的方法来初始化对象成员成员初始化列表中既包含对象成员的初始化又包含对...
  • 复合:把对象作为类成员

    千次阅读 2005-11-09 10:53:00
    复合:就是一个将其他对象作为自己的成员。...对象由内向外建立,由外向内删除(先删除对象,在删除类包含的其他对象)没有为成员对象提供初始化值的情况下,也没有为成员对象提供默认的构
  • this作用域是在内部,当在的非静态成员函数中访问的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说,即使你没有写上this指针,编译器在编译的时候也是加上this的,它...
  • 对于面向对象的语言来说,一个中能够使用的数据类型包括任何在本语言中合法的类型。 一个对象它属于引用类型数据实例,当然就可以出现在一个中作为这个成员使用了,可能这个对象不是这个的特有 特征,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 740,572
精华内容 296,228
关键字:

包含成员对象的类叫