精华内容
下载资源
问答
  • 对象成员对象成员指针 对象成员,作为一个对象来说,他成为另外一个类的数据成员 对象成员指针,对象的指针作为另外一个类的数据成员   对象成员指针也可以用初始化列表实现 对象成员指针指向其某一...
    • 对象指针
    • 对象成员和对象成员指针
      对象成员,作为一个对象来说,他成为另外一个类的数据成员
      对象成员指针,对象的指针作为另外一个类的数据成员
              class Line public: Line(); N Line(); private: Coordinate *m_pCoorA; Coordinate m_pCoorB;
      对象成员指针也可以用初始化列表实现
    对象成员指针指向其某一对象
    Line. m m pCoorA = new Coordinate(l, 3); pCoorB = new Coordinate(5, 6);
    注意!在类中使用了对象成员指针后,在析构函数中要删除指针!

    展开全文
  • Python类对象成员与类实例对象成员

    千次阅读 2018-06-05 13:49:34
    #Person类对象成员Count公有。 _income=0; #Person类对象成员income保护,其派生类可以引用。 __Tel="13088888888" #Person类对象成员Tel,是私有,在类定义中可以引用。 def __init__(self,name,...
    class Person(object):
        Count=0;         #Person类对象成员Count公有。
        _income=0;      #Person类对象成员income保护,其派生类可以引用。
        __Tel="13088888888"  #Person类对象成员Tel,是私有,在类定义中可以引用。
        def __init__(self,name,number,stuid,age):
            self.name=name     #类实例对象成员name公有
            self.number=number #类实例对象成员number公有
            self._stuid=stuid  #类实例对象成员stuid为保护
            self.__age=age     #类实例对象成员age为私有,在类定义中可以引用。
        def Work():
           print(Person.__Tel)
           Person.__Tel="13562334563"
           print(" I am working!")
           print(Person.__Tel)
        def Study(a,Time=2): 
            #不用self,但使用了a,python默认第一个参数是引用实例对象本身。
            print(a.name,"学习了%s小时"%Time)
        def Details(self):
            print("姓名:%s 身份证号:%s 学号:%s 年龄:%s"%(self.name,self.number,self._stuid,self.__age))
    print(Person.Count)
    Person.Count+=1
    print(Person.Count)
    Person._income+=1000
    print(Person._income)
    Person.Work()
    #--------------------实例对象成员的使用方法-----------
    a=Person("liu",232,22,20)
    a.Details()
    #a.Work()   #不允许实例对象调用类对象方法。因为没有self或者其他参数。

    a.Study(3)

    大家,加油!

    展开全文
  • 访问对象中的成员可以有3种方法:①通过对象名和对象成员引用运算符(.)访问对象中的成员; 访问对象中数据成员的一般形式为: 对象名.成员名class Data { public : int data; void fun(int a,int b,int d);/...

    访问对象中的成员可以有3种方法:

    ①通过对象名和对象成员引用运算符(.)访问对象中的成员;
    访问对象中数据成员的一般形式为:
    对象名.成员名

    class Data {
    public :
        int data;
        void fun(int a,int b,int d);//函数实现在外部
    private :
        void add(int m)
        {
            data +=m;
        }
        int x,y;
    }
        void caller1()
    {
        Data A, B; //定义对象
        A.fun(1,2); //正确,类外部可以访问类的public成员函数
        A.data=100; //正确,类外部可以访问类的public数据成员
        A.add(5); //错误,类外部不能访问类任何private的成员
        A.x=A.y=1; //错误,类外部不能访问类任何private的成员
        B.data=101; //正确,A.data和B.data是两个对象的数据成员,为不同的存储空间
        B.fun(4,5); //正确,A.fun和B.fun函数调用相同的代码,但作用不同的数据成员
    }
    

    调用对象中成员函数的一般形式为:
    对象名.成员函数(实参列表)
    ②通过指向对象的指针和指针成员引用运算符(->)访问对象中的
    成员;
    访问对象中数据成员的一般形式为:
    对象指针—>成员名
    调用对象中成员函数的一般形式为:
    对象指针—>成员函数(实参列表)

    void caller(){
    Data A,*p1,*p2;//定义对象指针变量
        p1=&A;//p1指向对象A
        p1->data=100;
        p1->fun(1,2)
        p2=new Data;//动态分配Data对象
        p2->data=100;
        p2->fun(1,3);
        delete p2;//销毁对象
    }
    
    

    ③通过对象的引用变量和对象成员引用运算符(.)访问对象中的成
    员;
    访问对象中数据成员的一般形式为:
    对象引用变量名.成员名
    调用对象中成员函数的一般形式为:
    对象引用变量名.成员函数(实参列表)

    void caller(){
    Data A,&a=A;//定义对象引用变量
    a.data=100;
    a.fun(1,3);
    }

    对象的赋值

    如果一个类定义了两个或多个对象,则这些同类的对象之间可以互相赋值。这里所指的对象的“值”是指对象中所有数据成员的值。
    对象赋值的一般形式为:
    对象名1=对象名2
    对象的赋值只对其中的非静态数据成员赋值,而不对成员函数赋值。
    如果对象的数据成员中包括动态分配资源的指针,按上述赋值的原理,赋值时只复制了指针值而没有复制指针所指向的内容。

    对象指针或引用作为函数的参数或者返回值

    (1)当形参是对象时,实参要求是相同类的对象名,C++不能对
    类对象进行任何隐式类型转换。此时形参是实参对象的副本。
    采用这样的值传递方式会增加函数调用在空间、时间上的开销,特
    别是当数据成员的长度很大时,开销会急剧增加。
    实际编程中,传递对象时需要考虑类的规模带来的调用开销,如果
    开销很大时建议不用对象作为函数参数。
    (2)当形参是对象指针时,实参要求是同类对象的指针,C++不
    能对对象指针进行任何隐式类型转换。函数调用时,无论类多大规模,传递的参数是一个地址值,其开销非常小。采用地址传递方式,在函数中若按间接引用方式修改了形参对象本质上就是修改实参对象。因此,使用对象指针作为函数参数可以向主调函数传回变化后的对象。
    (3)当形参是对象引用时,实参要求是同类的对象,其功能与对
    象指针相似。 此时函数形参对象实际上是实参对象的别名,为同一个对象。在函数中若修改了形参对象本质上就是修改实参对象。因此,使用对象
    引用作为函数参数可以向主调函数传回变化后的对象。

        #include <iostream>
        using namespace std;
        void func1(Data a,Data *p,Data &r)
        {
        a.data=100; p->data=200;    r.data=300;
        }
        int main()
        {
        Data A, B, C;
        A.fun(1,2,3); B.fun(4,5,6); C.fun(7,8,9);
        func1(A,&B,C);//将对象A、B的地址、对象C的引用传递到函数func1
        return 0;
        }
    

    如果不希望在函数中修改实参对象的值,函数形参可以作const限
    定,例如:

    void func2(Data a,const Data *p,const Data &r)
    {
    a.data=100;
    p->data=200; //错误,左值是const对象
    r.data=300; //错误,左值是const对象
    }
    不必对对象形参作const限定,如上述代码中的形参a,因为即使在
    函数中修改了a,也不会影响实参对象。
    函数返回值可以是对象、对象指针或对象引用。函数返回对象时,将其内存单元的所有内容复制到一个临时对象中。因此函数返回对象时会增加调用开销。函数返回对象指针或引用,本质上返回的是对象的地址而不是它的存储内容,因此不要返回局部对象的指针或引用,因为它在函数返回后是无效的。

    Data func1()
    {   Data a; a.fun(1,2,3);
        return a; //可以返回局部对象,它被复制返回
    }
    Data* func2(Data *p1,Data *p2)
    {   if (p1->data > p2->data) 
        return p1;
        return p2;
    }
    Data& func3(Data &r1,Data &r2)
    {   if (r1.data > r2.data) return r1;
        return r2;
    }
    void caller()
    {
    Data A, B, C;
    A.fun(1,2,3);
    B.fun(4,5,6);
    C=func1();
    func2(&A,&B)->data=100; //等价于 (&B)->data=100;
    func3(A,B).data=100; //等价于 B.data=100;
    }
    
    
    
    
    
    Data* func()
    {
    Data a;
    Data *p=&a;
    return p;   //返回局部对象a的指针p
    }
    void caller()
    {
    Data *p1;
    p1=func();
    p1->data=100; //a已不存在,引用错误
    }

    这里返回了局部对象的指针,有时候你会得到一个正确的值,但是c++规定这是不被允许的。我试了一下

    #include<iostream>
    using namespace std;
    class Point {
        public :
        int a;
    };
    Point* fun()
    {
        Point a;
        Point *p=&a;
        return p;
    }
    int main(){
        Point  *p1,*p2;
    
        p1=fun();
        p2=fun();
        p1->a=100;
        p2->a=200;
        cout<<p1->a<<endl;
        cout<<p2->a<<endl;
        return 0;
    }

    运行结果如下图
    这里写图片描述
    但是如果这里只写一个fun()函数就是对的,就是删掉p2=fun()就好。

    展开全文
  • 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;
    }
    
    展开全文
  • 类的对象成员(整理)

    千次阅读 2020-08-03 12:39:53
    新的概念:类的对象成员 C++程序中可能会涉及到许多类和对象,这些类和对象间如何发生联系? C++为类和对象之间的联系提供了如下方式: 一个类对象可能是另一个类的成员(对象成员) 一个类的成员函数是另一个类的...
  • C++对象成员与构造函数

    千次阅读 2018-03-19 20:47:35
    当一个类中出现对象成员时,该类的构造函数就要为对象成员初始化,对象成员的初始化必须在构造函数的初始化表中完成。注意:初始化对象成员时必须用对象成员名,而不是它的类型名。例如:class Date{ int year, ...
  • c++ 指向对象成员的指针

    千次阅读 2018-05-13 14:17:27
    对象中的成员也是占有内存的,所以,存放对象成员的起始地址的指针变量就是指向对象成员的指针变量。1.指向对象数据成员的指针int *p1; //定义指向整形数据的变量p1 = &amp;t1.hour; //把hour的地址赋给p1cout&...
  • 不是由static修饰的是实例变量,也就是对象成员变量, 对象.变量名 调用 public class Variable { //定义类变量 private static String name ;; //定义对象变量 private int age; public static void main...
  • 指向对象成员变量的指针

    万次阅读 2016-04-16 20:46:01
    指向对象成员变量的指针
  • 略识>之对象指针与对象成员指针

    千次阅读 2016-07-21 15:05:09
    对象指针声明方法: 堆中: Coordinate *p = new Coordinate();... //让对象指针指向对象a对象成员是指一个对象是另一个对象的数据成员;而对象成员指针是指对象指针成了另一个对象的数据成员。 比如:class
  • 第五讲:类的成员、对象成员的引用  掌握:类成员函数的性质、定义及存贮方式。对象成员三种引用方式,。  理解:类函数、作用域运算符、inline成员函数的概念。  重点、难点: 类成员函数的性质、定义、存贮...
  • C++类中的对象成员

    千次阅读 2018-07-27 11:04:56
    譬如定义一个类A,类B,其中类A为类B的函数成员,此时,类A为类B的对象成员 程序的结果分析如下: 第一步:A pa(0,0),调用类A的构造函数,长生第一行结果: AAAAAAAAAA 第二步:pa.printA();调用类A的成员函数...
  • C++学习之对象成员指针篇

    千次阅读 2016-01-14 18:32:13
    所谓对象成员指针就是让一个类的对象的指针作为另外一个类的成员变量,对象成员就是让一个类的对象成为另一个类的成员变量。下面以代码举例说明: 公用坐标类: class Coordinate { public: Coordinate(int x,...
  • C++之指向对象成员函数的指针

    千次阅读 2018-08-11 11:55:41
    定义指向对象成员函数的指针变量的方法和定义指向普通函数指针变量方法有所不同; 1.普通指针函数变量的定义方法:数据类型名(*指针变量名)(参数列表);  例:void (*p)(void);  p = fun;  (*p)(); // ...
  • 获取数组长度, 对象成员个数, 字符串数. 2.学习/操作 TBD 3.问题/补充 TBD 4.参考 https://www.cnblogs.com/sunnywindycloudy/p/7382226.html //js获取数组长度,对象成员个数、字符串数 ...
  • c++对象成员的引用

    千次阅读 2018-05-30 13:41:46
    访问类对象中的成员可以有3种方法:通过对象名和成员运算符访问对象中的成员;通过指向对象的指针访问对象中的成员;通过对象的引用变量访问对象中的成员。1.通过对象名和成员运算符.访问对象中的成员例如在程序中...
  • -> 运算:对象指针名->成员 不是等价于 (*对象指针名).成员 吗? #include using namespace std; class point { public: point(int x=0,int y=0):x(x),y(y){} int getx() const { return x; } int gety()...
  • 构造时:基类构造函数→对象成员构造函数→派生类本身的构造函数 析构时:派生类本身的析构函数→对象成员析构函数→基类析构函数 写个小程序验证一下: #include <iostream> using namespace std; class ...
  • B: static成员函数在对象成员函数中无法调用 C: 虚成员函数不可能是static成员函数 D: static成员函数不能访问static成员变量 答案:c 解释,(1)类的static成员变量属于该抽象类,需要在类定义时初始...
  • C++中的常对象和常对象成员

    千次阅读 多人点赞 2016-08-08 19:36:53
    对象中的数据成员为常变量且必须要有初始值,如 Time const t1(12,34,36); //定义t1为常对象 这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,...
  • java面试题37 关于对象成员占用内存的说法哪个正确?( ) A 同一个类的对象共用同一段内存 B 同一个类的对象使用不同的内存段,但静态成员共享相同的内存空间 C 对象的方法不占用内存 D 以上都不对 蒙蔽树...
  • (2)当一个类中含有对象成员时,在启动本类的构造函数之前,先分配对象空间,按对象成员的声明顺序执行他们各自的构造函数,再继续执行本类的构造函数; (3)对于非静态的局部对象,他们的析构函数的执行顺序与...
  • 这个功能其实并不常用,然而在多线程和回调函数中要调用默认对话框类的对象成员或方法还是可能要用到的,所以做下记录。  首先声明一个全局变量用以存储默认对话框类对象指针: LPVOID pParam;//对话框对象指针 在...
  • // 例4.8 含有对象成员的派生类构造函数和析构函数的执行顺序。 #include&lt;iostream&gt; using namespace std; class Base{ //声明基类Base public: Base(int i){ //基类的构造函数 x = i; cout&...
  • 关于类中对象成员的构造函数和类自身构造函数的执行顺序的问题,我们通过一段简单的程序来验证,测试代码如下: #include <stdio.h> class A { public: A() { printf("AAAAA\n"); }; ~A(){}; ...
  • **1,常对象** 在定义对象时加关键字...//等价说明:(1)如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数(出了由系统自动调用的隐式的构造函数和析构函数)。常
  • var obj = {title:'姓名',field:'username'}...使用obj.title、obj.field读取obj的title和field成员 浏览器的开发者工具中报错Uncaught TypeError:cannot read property of 'field' undefined 应该如何读取这两个成员

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,653
精华内容 53,461
关键字:

对象成员