精华内容
下载资源
问答
  • 类数据成员 python的类数据成员是不需要用self修饰的。例如 class my_class(object): value_list=[1,2] class1=my_class() print(my_class.value_list) print(class1.value_list) print(id(my_class.value_list...

    类数据成员

    python的类数据成员是不需要用self修饰的。例如

    class my_class(object):
        value_list=[1,2]
        
    class1=my_class()
     
    print(my_class.value_list)
    print(class1.value_list)
    print(id(my_class.value_list))
    print(id(class1.value_list))

    通过上面的测试可以看出,定义的类my_class()中的数据成员为类成员可以通过类名和对象名调用,其中两种访问方式访问同一块内存区域的数据。
    注意:对于类成员我们要通过类名来访问,通过对象访问只是为了测试

    class my_class(object):
        value_list=[1,2]
        
    class1=my_class()
    class1.value_list=['i']
     
    print(my_class.value_list)
    print(class1.value_list)
    print(id(my_class.value_list))
    print(id(class1.value_list))

    经过对象class1通过赋值语句重新定义value_list变量后,对象class1中访问的value_list与类数据成员则保存在不同的内存区域中。这也是给对象动态定义数据成员的效果。

    对象数据成员

    通过初始化函数,经过self修饰的数据成员是与对象绑定的。每个对象都会分配自己的内存区域。

    class my_class(object):
        value_list=[1,2]
        def __init__(self):
            self.value=[]
        
    class1=my_class()
    class2=my_class()
    class1.value=['i']
    class2.value=[1,2]
     
    print(class1.value)
    print(class2.value)
    print(id(class1.value))
    print(id(class2.value))

    value数据成员是属于每个对象的,在类的初始化过程或者后续引用中修改,不会产生相互的干扰。
    类的数据成员可以在对象初始化后动态添加,不是必须在类模板中声明。
    猜想:对象定义与类数据成员同名的变量时,会给对象定义一个self修饰的对象数据成员
    声明:由于个人知识局限,所写的内容会存在错误,欢迎大家指出其中的问题,谢谢

    展开全文
  • C++——类数据成员和类成员函数

    千次阅读 2014-01-05 20:22:24
    C++——类数据成员和类成员函数 C++除了有属于对象的成员——对象成员(或实例成员),还有属于类本身的一种成员,称之为类成员。 使用关键字static就可以创建一个类成员。   一、 类数据成员 static数据成员在类...

    C++——类数据成员和类成员函数

    C++除了有属于对象的成员——对象成员(或实例成员),还有属于类本身的一种成员,称之为类成员。

    使用关键字static就可以创建一个类成员。

     

    一、       类数据成员

    static数据成员在类声明的内部声明,在任何程序块之外定义(注意:不能在构造函数中初始化)。

    
    class Task
    {
    public:
         //……
    
    private:
    	static int n;
    };
    int Task::n = 0; //定义(初始化)时不受private和protected访问限制.
    
    

    
    

    初始化为0不是必须,在任何程序块之外定义的变量都自动初始化为0

     

    注:不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下,这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。

    static数据成员不会影响该类及其对象的sizeof.

    二、       类成员函数

    static成员函数只能访问其他的static成员(类数据成员和类成员函数)。

      

       类成员函数可以为inline也可以为非inline

     

        对于static成员的访问,可以通过对象访问,也能通过类来访问。

      

    
    class A
    {
    public:
    	static int x;  //此处只为说明
    	static void Getx();
    };
    

    
    

     

     

    int main()
    {
    	A a;
    	a.Getx();  //通过对象访问
    	A::Getx(); //通过类访问
    	int m = a.x;
    	int n = A::x;
    	return 0;
    }
    


    三、       在成员函数中定义static变量

    如果成员函数中定义了static变量,则该类的所有对象调用该成员函数时将共享这个静态变量

      

    本例在成员函数m中定义了一个static变量s,由于s定义在程序块内,它拥有程序块范围,因此它只能在m内部访问。每调用m一次,s就会相应地增加一次。又因为m是C的成员函数,所以,C的所有对象都共享这个静态局部变量。这样,对m的每一次调用访问的都是同一个s。相反,对于非静态局部变量x来说,每个C对象都拥有一个x。所以,在main中第一次调用c1.m()将s从0增加到1,调用c2.m()将s从1增加到2,第二次调用c2.m()将s从2增加到3。

     

    
    
    
    
    展开全文
  • 类数据成员 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++语言,每个可以有类成员变量,也可以有对象的成员变量,类成员变量需要用static修饰;在python中,也有两种变量 python中类成员变量是不用self修饰的,也就是说对象成员变量需要用self.来修饰,具体可以...

    相比于C++语言,每个类可以有类成员变量,也可以有对象的成员变量,类成员变量需要用static修饰;在python中,也有两种变量

    python中类成员变量是不用self修饰的,也就是说对象成员变量需要用self.来修饰,具体可以看代码。

    class person:
        population = 0
    
        def __init__(self,name):
            self.name=name
            self.population+=1
            print self.population
            print person.population
    
    
    peter = person('peter')
    print peter.population
    print person.population
    
    line2: population = 0,这个是类的变量。无论在哪里调用,都需要用person.population来引用

    line6: self.population +=1,这个地方调用的就是对象的变量。对象的变量会在类的变量的基础上执行加一,这是在对象变量没有被赋值的前提下。

    这段代码的执行结果是

    1

    0

    1

    0

    还会有一个全局的变量来干扰

    class person:
        population = 0
    
        def __init__(self,name):
            self.name=name
            self.population+=1
            print self.population
            print person.population
            print population
    
    population = 2
    peter = person('peter')
    print peter.population
    print person.population
    print population
    

    代码的运行结果是

    1

    0

    2

    1

    0

    2


    展开全文
  • C++11中类数据成员初始化方法详解

    千次阅读 2016-12-31 21:28:38
    分配内存,调用构造函数时,隐式/显示的初始化各数据成员  2.进入构造函数后在构造函数中执行一般计算  1.里面的任何成员变量在定义时是不能初始化的。  2.一般的数据成员可以在构造函数中初始化。  3....
  • c++中 类数据成员的定义、声明总结

    千次阅读 2015-07-12 10:14:05
    1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员 2.进入构造函数后在构造函数中执行一般计算  1.里面的任何成员变量在定义时是不能初始化的。  2.一般的数据成员可以在构造函数中初始化。  3....
  • C++类数据成员的初始化

    千次阅读 2009-08-29 09:30:00
    分配内存,调用构造函数时,隐式/显示的初始化各数据成员2.进入构造函数后在构造函数中执行一般计算 1.里面的任何成员变量在定义时是不能初始化的。 2.一般的数据成员可以在构造函数中初始化。 3.const数据...
  • C++回顾之类数据成员的初始化

    千次阅读 2014-02-06 14:46:54
    构造函数初始化列表,中的普通对象成员初始化,const成员及引用成员的初始化方法。
  • class A { public: A(){} ~A(){} private: const int a[3]; }; const int a[3]怎么初始化?求教高手
  • 往往被初学者忽视的是,C++中的数据初始化是有jia
  • C++中成员变量有以下几种特殊的类型: 1、常成员变量 2、静态成员变量 3、静态常成员变量(基本数据类型) 4、静态常成员变量(自定义数据类型) 二、常成员变量 C++中使用const关键字修饰的成员变量...
  •  (C++11提供了内初始化,因此内常量可在声明时进行内初始化,因此该内常量的作用域属于级,即该的所有对象均具有同一个值。)#include &lt;iostream&gt; using namespace std; class A ...
  • 2、static成员:初始化在外,且不加static修饰 3、const static成员只有唯一一份拷贝,且数值不能改变。因此,可以在中声明处初始化,也可以像static在外初始化 示例:   #include using st
  • C++中的常数据成员和静态数据成员的区别

    千次阅读 多人点赞 2013-09-20 01:19:26
    刚开始学习C++的和对象的部分,对中的常数据成员和静态数据成员的概念和用法经常混淆,所以今天整理一下,顺便说一下,今天是我的生日,祝我生日快乐,呵呵。 常数据成员数据成员是指在中定义的不能修改其...
  • 静态数据成员和普通数据成员区别较大,体现在下面几点...(2)因为的静态数据成员的存在不依赖与于任何对象的存在,的静态数据成员应该在代码中被显示的初始化,一定要在外进行。 (3)外部访问的静态成员
  • C++ 数据成员分布详解

    千次阅读 2018-12-22 23:39:13
    我们都知道中包含着数据成员,但是数据成员在内存中是怎样分布的呢?继承之后数据又是怎样布局的呢?下面对这些问题进行整理。的空间分布是编译器编译的结果,不同的编译器有可能会不一样,但是原理是一样的。 ...
  • C++中为什么类中自身类的对象不能做自己的数据成员,但是做静态数据成员、引用类数据成员等可以? student { private: student a;//错误! student *b;//正确! static student c;//正确! } 类定义中...
  • C++成员和数据成员初始化总结

    万次阅读 2013-05-24 22:15:38
    1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员 2.进入构造函数后在构造函数中执行一般计算  1.里面的任何成员变量在定义时是不能初始化的。  2.一般的数据成员可以在构造函数中初始化。  3....
  • C++静态数据成员静态成员函数 我们如何才能在范围内共享数据呢? 这个问题便是本章的重点: 声明为static的成员或者成员函数便能在的范围内共同享,我们把这样的成员称做静态成员和静态成员函数。 下面...
  • 彻底搞懂Python数据成员和成员方法

    千次阅读 多人点赞 2020-03-30 22:49:22
    一、数据成员(属性) 数据成员可以大致分为两类:属于对象的数据成员和属于类的数据成员。...属于类的数据成员是该类所有对象共享的,不属于任何一个对象,在定义类时这类数据成员一般不在任何一个成员方法的定义中...
  • 的静态成员函数和静态数据成员

    千次阅读 2015-10-10 21:31:27
    一、基本知识当将的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象...
  • 静态数据成员和静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,...在中声明静态数据成员很简单,是以static关键字表明即可,
  • 静态数据成员定义

    千次阅读 2017-09-11 09:13:52
    我们知道C++的静态成员变量是需要初始化的,但为什么要初始化呢。其实这句话“静态成员变量是需要初始化的”是有一定问题的,应该说“静态成员变量需要定义”才是准确的,...静态成员变量在中仅仅是声明,没有
  • C++的常数据成员和常成员函数

    千次阅读 2019-03-11 11:01:07
    一、常数据成员 1、定义 用const修饰的数据成员 const int hour;//定义const为常数据成员 2、初始化 不能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员是不能被赋值的。 构造函数只能用...
  • 定义一个Student,要求使用静态数据成员或静态成员函数计算5个学生的《计算机导论》课程的总成绩和平均成绩。请同学们自行设计该。 【提示】 静态数据成员:static int total; 表示所有同学成绩总分 静态成员...
  • C++static类成员,static类成员函数

    万次阅读 多人点赞 2017-03-20 14:33:14
    在C++primer里面说过,static类成员不像普通的类数据成员,static类数据成员独立于一切类对象处在。static类数据成员是与类关联的,但不与该类定义的对象有任何关系。这句话什么意思?就是static不会想普通类数据...
  • 一个的对象作为另一个数据成员。 &nbsp; &nbsp; &nbsp; &nbsp;一个中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个的一个对象。用子对象创建新。 &...
  • 1、在c++中,当把一个的对象作为另一...2、如果一个A的对象作为另一个B的数据成员,则在B的对象创建过程中,调用其构造函数的过程中,数据成员A的对象)会自动调用A的构造函数。     但是应注...
  • 的常数据成员必须进行初始化,而且只能通过构造函数的成员初始化列表的方式来进行。列表中对成员的初始化顺序,与它们在列表中的顺序无关,而与它们在中的声明顺序有关。包含常数据成员不能使用默认构造函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 907,833
精华内容 363,133
关键字:

类数据成员