精华内容
下载资源
问答
  • 静态成员变量

    2016-03-03 13:59:57
    1、静态成员变量 普通成员变量每个对象有各自的一份,而静态成员变量一共就一份,为所有对象共享。 sizeof 运算符不会计算静态成员变量静态成员变量本质上是全局变量,哪怕一个对象也不存在,类的静态成员变量也...

    1、静态成员变量

    • 普通成员变量每个对象有各自的一份,而静态成员变量一共就一份,为所有对象共享。
    • sizeof 运算符不会计算静态成员变量。
    • 静态成员变量本质上是全局变量,哪怕一个对象也不存在,类的静态成员变量也存在。
    • 在静态成员函数、非静态成员函数内部都可以访问静态成员。
    • 在类内部声明,在类体外面定义并初始化。
    class test
    {
        private:
            int id; 
        public:
            static int num;//声明静态成员变量 
            test(int i)
            {
                id=i;
                cout<<"constructor"<< id<<" called."<<endl;
            }
            ~test()
            {
                cout<<"destructor"<< id<<" called."<<endl;
            }
            static void print()
            {
                cout<<num<<endl;
            }
     } ;
     int test::num=0;//定义并初始化静态成员变量 

    2、静态成员函数

    • 普通成员函数必须具体作用于某个对象,二静态成员函数并不具体作用于某个对象
    • 静态成员(静态成员变量、静态成员函数)不需要通过对象就能访问。
    • 静态成员函数本质上是全局函数
    • 设置静态成员的机制的目的是将和某些类紧密相关的全局变量和函数写到类里面,看上去像一个整体,易于维护和理解。
    • 在静态函数中,不能访问非静态成员变量,也不能调用非静态成员函数。只能访问静态成员,调用静态函数。

    3、访问静态成员

    • 类名::成员名
    • 对象名.成员名
    • 指针->成员名
    • 引用.成员名
    展开全文
  • 而非静态成员变量是不属于类的,就像是你租了一套房,主人套房子不属于你,因此,静态成员变量的调用可以直接通过类加域运算符的形式 (CLASS::),而非静态成员变量的调用去只能由实例化的对象,可以理解为租约,有...

    写在前面的总结:

    静态成员变量是属于类的,就像是你买了一套房,属于固定资产;而非静态成员变量是不属于类的,就像是你租了一套房,主人套房子不属于你,因此,静态成员变量的调用可以直接通过类加域运算符的形式 (CLASS::),而非静态成员变量的调用去只能由实例化的对象,可以理解为租约,有了这个租约,这个房子才能被你用,但也是借用,并不代表房子就是你的了。

    (怎么想想还有点心酸呢?)

    发现个更好的例子: 

    静态成员函数是类的成员函数,该函数不属于该类申请的任何一个对象,而是所有该类成员共同共有的一个函数。 
    举个例子给你,你们班里面有10个人(10个比如高一一班的对象),体育老师分给你们一个篮球(静态成员函数),
    你们每个人都带了一个篮球(非静态成员函数),你们都很小气,自己的球只能自己拍,要是5对5打比赛,
    那就只能用那个静态的篮球了(每个人都可以拿来用,但是带来的影响是对全体的)。因此,我可以说那个篮球是
    高一一班的成员。所以也就是说:静态成员函数是类的成员函数(因为高一二班就不能拿来玩),但是这个篮球最
    后还是要还给老师的,任何私人不得占有。希望这样你能明白,其实在机器结构里面说白了静态的成员的内存是唯
    一的一份,就是当你在类外声明他时开辟的,但是非静态函数的空间分配是在你实例化对象时创建的。

    例如下面这段代码:

    #include <iostream>
    
    using namespace std;
    
    class Student                   //定义Student类
    {
        public:
        Student(int n,int a,float s):num(n),age(a),score(s){ }      //定义构造函数
        void total( );
        static float average( );      //声明静态成员函数
    
        private:
        int num;
        int age;
        float score;
        static float sum;            //静态数据成员
        static int count;            //静态数据成员
    };
    
    void Student∷total( )                      //定义非静态成员函数
    {
        sum+=score;                            //累加总分
        count++;                               //累计已统计的人数
    }
    
    float  Student∷average( )                  //定义静态成员函数
    { return(sum/count); }
    
    float Student∷sum=0;                     //对静态数据成员初始化
    int Student∷count=0;                     //对静态数据成员初始化
    
    int main( )
    {
        Student stud[3]={                      //定义对象数组并初始化
        Student(1001,18,70),    
        Student(1002,19,78),
        Student(1005,20,98)};
    
        int n;
        cout<<〃please input the number of students:〃;
        cin>>n;                               //输入需要求前面多少名学生的平均成绩
    
        for(int i=0;i<n;i++)                  //调用3次total函数
        {
            stud[i].total( );                 //total属于非静态成员函数,每一次的调用都要具体到某个学生
            cout<<〃the average score of 〃<<n<<〃 students is 〃<<Student∷average( )<<endl;
        }
        //调用静态成员函数
        return 0;
    }
    
    运行结果为
    please input the number of students:3↙
    the average score of 3 students is 82.3333

    非静态成员函数的调用要基于某一个实例化的对象;

    静态成员函数的调用可以直接用类名加域运算符“::”,也可以用实例化对象名和操作符"."来操作,如 Student a; a.sum;但是用实例化对象进行调用时,也不代表该静态函数或静态变量就属于该对象;

    可以理解为静态成员函数是属于类的,因此可以直接用类和域运算符来计算;而非静态成员函数是不属于类的,因此类就不能直接调用,而需要实例化对象之后才能调用;同时,在结构上,静态成员函数没有this指针,而非静态成员函数有this指针,因此静态成员函数不能调用非静态的;

    参考: https://blog.csdn.net/zhangjieting/article/details/5930004

     

    展开全文
  • 静态成员变量和非静态成员变量的对比 1、存储的数据 静态成员变量存储的是所有对象共享的数据 非静态成员变量存储的是每个对象特有的数据 2、存储位置 静态成员变量是随着类的加载在方法区的静态区...

    静态成员变量和非静态成员变量的对比

    1、存储的数据

    静态成员变量存储的是所有对象共享的数据

    非静态成员变量存储的是每个对象特有的数据

    2、存储位置

    静态成员变量是随着类的加载在方法区的静态区开辟内存了

    非静态成员变量是随着对象的创建再堆中开辟内存

    3、调用方式

    静态成员变量既可以通过对象访问也可以通过类名直接访问

    非景泰成员变量只能使用对象访问

    4、生命周期

    静态成员变量随着类的加载就在方法区中的静态区出现,整个程序执行完才消失

    非静态成员变量是随着对象的创建在堆中出现,随着对象的被垃圾回收而消失

    展开全文
  • 静态成员变量与非静态成员变量

    千次阅读 2017-06-08 09:03:23
    静态成员变量从属于一个类而非某个具体的对象,它的值被该类的所有对象所共享.对于public的静态成员变量而言,它既可以由类名直接通过 “.” 操作符引用,也可以由对象名通过“.”操作符来引用,并且两者效果相同. 静态...
    静态成员变量从属于一个类而非某个具体的对象,它的值被该类的所有对象所共享.对于public的静态成员变量而言,它既可以由类名直接通过 “.” 操作符引用,也可以由对象名通过“.”操作符来引用,并且两者效果相同. 静态成员按照它们在类中声明的顺序进行初始化,并且此过程先于Main函数执行。
    非静态成员变量则为独个对象所拥有,而不被各个对象所共享.因此不能用类名来直接引用.
    例如:   在内存上的关系如下图所示(并不准确,仅用于理解) ,其中两个对象中的sMember均引用顶端的类的sMember,而nsMember则为各自所独有。
    using System;


    class MyClass
    {
        public int nsMember;    //非静态成员变量
        public static int sMember;    //静态成员变量


        public MyClass(int i, int j)
         { //成员的初始化
             nsMember = i;
             sMember = j;
         }
    }


    class Test
    {
        static void Main()
         {
             MyClass mc1 = new MyClass(50, 100); //创建一个MyClass实例,并初始化.


             Console.WriteLine(MyClass.sMember); //ok, sMember是MyClass类的静态成员,可以由类名直接引用. 此行输出100        
             Console.WriteLine(MyClass.nsMember);//出错!nsMember是非静态成员,不能由类名直接引用        
             Console.WriteLine(mc1.nsMember);    //ok, mc是一个已成功创建的对象,它拥有自己的非静态成员nsMember                                                                 
            //此行输出50;        
             MyClass mc2 = new MyClass(10, 20);     //创建一个新的实例,并初始化.


             Console.WriteLine(MyClass.sMember);    //ok,由于在mc2初始化时已更改sMember为20,而sMember为所有MyClass类对象所共享,                                                                                                                                  
            //故此行输出20.
             Console.WriteLine(MyClass.nsMember);//同样出错!


             Console.WriteLine(mc2.nsMember);     //ok, 此行输出10;        


             Console.WriteLine(mc1.nsMember);    //此行输出50,因为mc1和mc2的非静态成员nsMember是互相独立的                                                                     


         }
    }
    。。。 。。。
    sMember
    。。。 。。。
    mc1
    nsMember(50)
    sMember
    mc2
    nsMember(10)
    sMember
    关于静态方法和非静态方法
    类似静态成员变量,静态方法为一个类所拥有.但静态方法中只能使用静态成员,而不能使用非静态成员.
    非静态方法中既能使用静态成员,也能使用非静态成员.
    例如,为上面的MyClass类添加一个静态方法StaticFun()和一个非静态方法UStaticFun()
    1 class MyClass
    2 {
    3     静态成员变量与非静态成员变量 静态成员变量与非静态成员变量
    4     static void StaticFun()
    5      {
    6          nsMember += nsMember;     //出错!因为nsMember是非静态成员
    7          sMember += sMember;    //ok,因为sMember是静态成员
    8      }
    9     
    10     void UStaticFun()
    11      {
    12          nsMember += nsMember;     //ok
    13          sMember += sMember;    //ok
    14      }
    15 }
    16


    关于静态构造函数
    静态构造函数的执行发生在类的静态成员初始化之后和类的第一个实例创建之前.一个类只能定义一个静态构造函数,并且不能带有参数.
    例如: 执行顺序如注释所标注.
    1 class InitOrder
    2 {
    3     static int sMember1 = 1; // 1
    4     static int sMember2 = 2; // 2    
    5     
    6      InitOrder()
    7      {
    8          Console.WriteLine("unstatic ctor initialized"); // 4
    9      }
    10
    11     static InitOrder()
    12      {
    13          Console.WriteLine("static ctor initialized"); // 3
    14      }
    15 }
    16
    17 class Test
    18 {
    19     static void Main()
    20      {
    21          InitOrder io = new InitOrder();
    22      }
    23 }
    24
    静态构造函数不能被显式调用,且各个类中静态构造函数的调用顺序是不确定的.
    例如: 有可能"Test2 Initialized"会在"Test1 Initialized"之前输出.
    1 class Test1
    2 {
    3     public static void Print()
    4      {
    5          Console.WriteLine("Print1 is called");
    6      }
    7     static Test1()
    8      {
    9          Console.WriteLine("Test1 Initialized");
    10      }
    11 }
    12
    13 class Test2
    14 {
    15     public static void Print()
    16      {
    17          Console.WriteLine("Print2 is called");
    18      }
    19     static Test2()
    20      {
    21          Console.WriteLine("Test2 Initialized");
    22      }
    23 }
    24
    25 class Test
    26 {
    27     static void Main()
    28      {
    29          Test1.Print();
    30          Test2.Print();
    31      }
    32 }
    33 有可能"Test2 Initialized"会在"Test1 Initialized"之前输出.
    展开全文
  • a)静态成员变量: 方法区的静态区域 b)非静态成员变量: 堆内存中的对象空间里面 2、从书写格式上看: a)静态成员变量: 在数据类型前面多了一个static修饰 b)非静态成员变量: 没有static修饰 3、从生命周期上...
  • 静态成员变量:也称类变量,一般表示类的共通属性,跟对象无关,初始化在对象初始化之前,被多个对象共用。 静态块:一般用来初始化静态成员变量和静态成员方法,初始化在对象实例初始化之前。 非静态成员方法:也...
  • 类中静态成员变量,所有类共享这一个成员变量; static声明 静态成员对象不属于某个对象; 需要在全局给静态成员变量开辟空间(类外); 静态成员变量属于类,不属于对象,所以访问时需要加类名,而不是...
  • 静态成员变量和静态成员函数: 静态成员变量在编译的时候就会分配内存 在成员变量前面加上static就会变成静态成员变量 静态成员变量在类内声明,在类外进行初始化 可以通过对象或者类名访问静态...
  • PHP静态成员变量和非静态成员变量 突然在网上找到了一遍对PHP静态变量和非静态变量讲解比较深入的一遍文章,特转来分享下。 转载地址:http://blog.chinaunix.net/uid-20722281-id-160034.html 数据成员可以分...
  • 从保存位置、书写格式、生命周期上、使用方法、修改后的影响范围上看静态成员变量和非静态成员变量的区别。
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    C++的静态成员变量和静态成员函数 静态成员变量和静态成员函数算是C++面向对象编程中的一个重点和难点,这里的静态具体指什么呢?与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是...
  • 如果我们在成员变量前边加上static关键字,这个变量就成为静态成员变量,我们又把这种变量叫做“类变量”,因为这样的变量在这个类的所有对象里只有一个,这个类的所有对象“共享”同一个类变量。
  • Python中,静态成员变量称为类变量,非静态成员变量称为实例变量。 基本概念 类变量: 类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。类变量在整个实例化的对象中是公用的。 实例变量: ...
  • Java中非静态成员变量静态成员变量的初始化时机。 非静态变量 我们在这里分析三种结构,着重分析这三种结构的初始化顺序: 成员变量初始化语句; 成员变量初始化块; 构造函数; 示例一: public class ...
  • 静态成员变量值是所有类的实例共享的,所以调用的时候只需要 类名.属性名 就可调用(也只能这样调用),而非静态成员变量的值是各个实例私有的,所以调用的时候必须是先有具体的类的实例,然后通过实例名来调用。也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,088
精华内容 11,635
关键字:

静态成员变量