精华内容
下载资源
问答
  • 程序最终都将在内存执行,变量只有在内存占有一席之地时才能被访问。  静态成员(变量和方法)属于... 在一个静态成员去访问其非静态成员之所以会出错是因为在的非静态成员不存在的时候静态成员就
    程序最终都将在内存中执行,变量只有在内存中占有一席之地时才能被访问。 
    
     类的静态成员(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问;
    非静态成员(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。 
      在一个类的静态成员中去访问其非静态成员之所以会出错是因为在类的非静态成员不存在的时候类的静态成员就已经存在了,访问一个内存中不存在的东西当然会出错:
    class CA{
    private:
        int a;     //非静态成员,创建类的实例时分配内存,类的不同实例对应不同的内存区域  
        static int b;     //静态成员,类加载时分配内存,类的所有实例共享   
    public:
        void fa(void)
    {
            a = 1;
            b = 1;
     }       static void fb(void){
            //a = 1;        //Non-static member can't be accessed by static function
            b = 1;
        }
    };

    int CA::b = 1;   
    int main(void)
    {
        
        CA ca;
        ca.fa();
        CA::fb();
     return 0;
    }
       类的静态函数和普通函数的最大区别就是 :
        (1)类的静态函数依赖类存在
         (2)普通类的成员函数 依赖对象存在 普通类的成员函数有个this指针指向当前对象
    而静态函数没有此指针
    因为它们在内存中放置的位置不同。 类的静态函数放置在静态区。而类的普通函数在函数内而存在。 类的静态函数可以通过函数名::静态函数 直接引用。而类的普通函数不可以 类的静态函数不能直接调用类的成员变量,但是能调用类的静态的成员变量。 类的普通函数可以直接调用类的成员函数,也可以调用类的静态成员变量,它是依赖对象存在的。

    程序最终都将在内存中执行,变量只有在内存中占有一席之地时才能被访问。

    类的静态成员(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问;非静态成员(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。

    在一个类的静态成员中去访问其非静态成员之所以会出错是因为在类的非静态成员不存在的时候类的静态成员就已经存在了,访问一个内存中不存在的东西当然会出错。

    C++会区分两种类型的成员函数:静态成员函数和非静态成员函数。这两者之间的一个重大区别是,静态成员函数不接受隐含的this自变量。所以,它就无法访问自己类的非静态成员。

     

    静态数据成员

        在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个对象的成员。

        使用静态数据成员可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。

    静态数据成员的使用方法和注意事项如下:

    1、静态数据成员在定义或说明时前面加关键字static。

    2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下:
         <数据类型><类名>::<静态数据成员名>=<值>

    这表明:
    (1) 初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆。

    (2) 初始化时不加该成员的访问权限控制符private,public等。

    (3) 初始化时使用作用域运算符来标明它所属类,因此,静态数据成员是类的成员,而不是对象的成员。

    3、静态数据成员是静态存储的,它是静态生存期,必须对它进行初始化。

    4、引用静态数据成员时,采用如下格式:

    <类名>::<静态成员名>

     

    静态成员函数

        静态成员函数和静态数据成员一样,它们都属于类的静态成员,它们都不是对象成员。因此,对静态成员的引用不需要用对象名。

    在静态成员函数的实现中不能直接引用类中说明的非静态成员,可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时,可通过对象来引用。
    下面通过例子来说明这一点。

    #include <iostream>

    using namespace std;

     

    class M

    {

    public:

         M(int a) { A=a; B+=a;}

         static void f1(M m);

    private:

         int A;

         static int B;

    };

     

    void M::f1(M m)

    {

         cout<<"A="<<m.A<<endl; //静态成员函数中通过对象来引用非静态成员

         cout<<"B="<<B<<endl;

    }

     

    int M::B=0; //静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>

    void main()

    {

         M P(5),Q(10);

         M::f1(P); //静态成员函数调用时不用对象名

         M::f1(Q);

    }



    读者可以自行分析其结果。从中可看出,调用静态成员函数使用如下格式:

    <类名>::<静态成员函数名>(<参数表>);

     

    运行结果:

    A=5

    B=15

    A=10

    B=15


    展开全文
  • C++ (静态成员和静态函数)

    万次阅读 2018-07-21 15:01:46
    静态成员函数 class A { public: static int x; public: static void Func(){} } int A::x=10; 静态成员变量 a. 关键字static用于说明一个的成员变量时,该成员为静态成员。静态成员提供了一个同类对象...

    文章概述

    1. 静态成员变量
    2. 静态成员函数
    class A
    {
      public:
      static int x;
      public:
      static void Func(){}
    }
    int A::x=10;

    静态成员变量

    a. 关键字static用于说明一个类的成员变量时,该成员为静态成员。静态成员提供了一个同类对象的共享机制;
    b. 把一个类的成员说明为static时,该类无论创建多少个对象,这些对象都共享这个static成员;
    c. 静态成员变量属于类,不属于对象;
    d. 定义静态成员变量的时候,是在类的外部。
    e. 访问静态成员变量的两种方法:

    • 对象使用.(成员运算符)
    A a;
    //对象成员运算符调用静态成员变量
    a.x=8;
    • 类和作用域符(::)
    //类和作用域符调用静态成员变量
    A::a;

    静态成员函数

    a. 静态成员函数时属于类的,不是对象的;
    b. 静态成员函数的调用方式和静态成员变量的方法类似。
    c. 静态成员函数不能够调用普通的成员函数和普通的成员变量,因为静态成员函数属于类,不知道普通的成员属性属于哪个对象,只能调用静态的类的资源。

    展开全文
  • C++提供static这个关键词对静态成员进行声明,静态成员函数的实例化无关,对于同一来说,静态成员函数是共享的。而普通成员函数需要实例化才能调用,对于每一个实例来说,普通成员函数是自己独有的。 #...

    C++提供static这个关键词对静态成员进行声明,静态成员函数和类的实例化无关,对于同一类来说,静态成员函数是共享的。而普通成员函数需要实例化才能调用,对于每一个实例来说,普通成员函数是自己独有的。

    #include<iostream>
    class Person
    {
    public:
        void ordinaryfunc();//声明一个普通成员函数
        void static staticfunc();//声明一个静态成员函数
    };
    void Person::ordinaryfunc()
    {
        std::cout<<"from ordinary"<<std::endl;
    }
    void Person::staticfunc()//注意定义静态函数不需要再带static
    {    
        std::cout<<"from staticfunc"<<std::endl;
    }
    void main()
    {
        Person::ordinaryfunc();//未实例化直接调用普通成员函数
        std::cin.get();
    }

    1.调用成员函数

    在未实例化就调用普通成员函数可以看到在VS2013报了一个error:非静态成员函数的非法调用,所以普通成员函数要调用需要实例化。

    Person::staticfunc();//未实例化直接调用静态成员函数

    成功调用静态成员函数

    2.通过函数指针调用成员函数

    公有成员函数可以通过函数指针进行调用,调用成员函数也是需要实例化的。

    函数指针调用普通成员函数:

    void(Person::*pord)() = &Person::ordinaryfunc;
    Person P1;
    (P1.*pord)();//通过函数指针调用成员函数

    (1)首先是函数指针的定义把函数名挖掉替换成函数指针的变量名:void(*函数指针变量名)();

    (2)但类的普通成员函数指针需要带上类名,并且在后面需要取类的地址:&Person::ordinaryfunc;

    (3)在调用时也需要实例化,相当于每一个实例对应了自己的函数指针。

    每个实例调用自己的函数指针:

    Person P1,P2;
    (P1.*pord)();//通过函数指针调用成员函数
    (P2.*pord)();

    函数指针调用静态成员函数:

    (1)调用静态函数指针是不需要实例化的

    (2)只需要指定是哪一个类的静态函数

    void(*psta)() = Person::staticfunc;
    psta();

    3.总结

    (1)类的静态函数和类无关

    (2)类的静态函数可以在未实例化前调用

    (3)定义函数指针指向普通成员函数时,需要取类的地址,而调用时每一个实例有自己的函数指针

    (4)用函数指针调用静态成员函数时,仅需要指定类名

    展开全文
  • C# 静态静态函数

    千次阅读 2016-07-30 15:53:47
    C# 翻译msdn文档 静态静态函数

    学习静态类和静态函数。
    这篇博客的内容来自MSDN,当然内容是我自己看MSDN翻译出来的。

    正文

    静态类和非静态类其实基本相同。两者有一处不同:静态类不能被实例化。换句话来说,你不能够用new去为一个静态类实例出一个对象来。因为静态类中根本没有实例成员。你只能通过使用类名来访问静态类变量。举一个例子:如果你的静态类名叫UtilityClass,而这个类中有个方法叫做MethodA,你只能像下面这样去调用。

    UtilityClass.MethodA();
    可以把静态类当作一个很方便的容器,存储一组函数,这些函数只是由输入参数来操作,而不需要读写类内的实例feild。例如,在。Net类库中System.Math静态类包含的方法只执行数学计算,而不需要存储和检索Math类实例特有的数据,就是说,你需要通过指定类名和方法名来使用类成员,就像下面的例子展示的那样。

    和所有类类型一样,当加载引用静态类的程序时,静态类的类型信息通过公共语言运行时得以加载。程序并不能精确的指定出,这个类何时加载。但是,CLR保证在静态类首次引用前,加载这个类,初始化类的字段并且调用它的构造函数。

    以下包含了静态类的主要特性
    只包含静态成员
    不能被实例化
    sealed封闭的
    不能包含实例构造函数

    因此,创建一个 静态类和创建一个只包含静态成员和私有构造函数的类基本是一样的。私有构造函数方式类实例化。使用静态类的好处是,编译器可以检查确保没有偶然的添加实例成员。编译器会确保不能创建出对象。

    静态类是封闭的,因此不能继承。除了Objecet类,它不能继承自其他类。静态类不能包含实例构造函数。但,可以包含静态构造函数。如果非静态类需要初始化重要的静态成员,非静态类也应该定义静态构造函数。

    静态成员
    非静态类可以包含静态函数,字段,属性和方法。

    非静态类可以包含静态方法,字段,属性,事件。即使当类的实例没有创建出来,静态成员也是可以调用的。静态成员是通过类名访问的,而不是对象名。无论创建了多少对象,静态成员只存在一份。静态方法和属性不能访问非静态字段、事件XX,而且他们不能访问任何对象的实例,(除非它在方法参数中显示传递 )。比起去声明一个完全的静态类,声明一个包含静态成员的非静态类更为典型。

    去共同维护一个计算实例化类的静态字段,或者存储一个必须共享给所有对象的值。
    静态方法可以 重载 ,但 不可以重写,因为它们属于类,不属于任何实例。
    虽然字段不能声明为static const,从静态的行为来说,一个const字段本质是静态的。它属于静态类型,而不是实例类型。因此,const字段可以同样通过使用ClassName.MemberName来访问。

    C#不支持静态局部变量(声明在方法范围的变量),

    在静态成员第一次被访问之前,静态构造器之前,如果调用其中一个静态成员会实例化。
    去访问一个静态类成员,要使用类名而不是一个变量名
    、如果一个类包含静态字段,你可以写一个静态构造器,当类加载时,构造函数可以初始化他们。

    一个静态成员的调用产生了MSIL中的一个调用指令,而一个实例方法的调用产生了一个callvir指令,
    然而,大多数时候这两者之间的不同不是那么重要。

    展开全文
  • 类静态成员函数的定义

    千次阅读 2017-11-16 11:37:15
    类静态成员函数的定义
  • 一般地,线程要读写的私有成员变量,只有两种方法:将全局函数声明为友元friend,或者使用静态的成员函数static。那非静态的成员函数呢?一般地方都说的是,不行,做不了。。。为什么不行?都是代码区的代码,...
  • 图片简略,图片的说明解释了图片大意 [定义的外部]...如图,为什么定义了一个静态内部,在主函数访问此内部类中静态函数时只能通过建立对象调用而不是类名调用,谁能帮忙解答疑惑?
  • C++ 类静态成员函数

    万次阅读 2020-12-06 18:25:14
    。。。
  • 折磨了我好久的问题,还是自己c,c++功力不够,其实把自己的指针作为参数传入到静态函数中 就可以使用了。–,…….
  • 的静态成员变量,以及静态函数。 静态成员变量: 1.静态成员共享机制 2.静态成员局部属于,它不是对象的成员,位于静态区。 3.静态成员变量需要在外部进行初始化。 静态函数: 1.静态成员函数都在代码区,...
  • 静态函数的作用

    千次阅读 2019-01-27 19:13:43
    用关键字“static”修饰的函数称为静态函数,和静态变量的存储方式都是静态存储,但又有所区别。现在主要讲静态函数: 1、用static修饰的函数,系统会给程序分配一块一直存在并能被使用的内存,避免了函数在调用时...
  • 其实我们从直观上可以很好的理解静态成员函数不能调用非静态成员变量这句话因为无论是静态成员函数还是静态成员变量,它们都是在的范畴之的,及在的整个生存周期里始终只能存在一份。然而非静态成员变量和非...
  • Python:普通成员函数、成员函数、静态函数 Python 中的也是一个普通对象,如果需要直接使用这个,例如将作为参数传递到其他函数中,又希望在实例化这个之前就能提供某些功能,那么最简单的办法就是使用 ...
  • QT 类静态函数作为回调函数

    万次阅读 2020-05-26 08:41:05
    (二) 今天使用静态函数作为回调函数,具体方式如下, (1) 在头文件定义 class CardDataDispose : public QObject { Q_OBJECT public: static void callback(int device, int msg, i...
  • 静态函数只能访问的静态成员变量 静态函数只能访问的静态成员变量 静态函数只能访问的静态成员变量 静态函数只能访问的静态成员变量 转载于:...
  • 的所有成员函数都可以访问本的私有成员,但是静态成员函数没有this指针,因此通过 该的对象作为函数参数,可以显示访问该的私有成员。 测试程序如下: #include &lt;stdio.h&gt;   class Demo ...
  • 静态类 关键字static修饰的称之为静态类静态类不能实例化。 static关键字可以防止程序员写代码实例化静态类,也可以防止在静态类的内部...不能包含实例构造函数(但可以包含静态构造函数)。 静态成员 ...
  • 静态变量与静态函数

    千次阅读 2018-08-16 10:42:50
    1、栈区(stack):有编译器自动分配释放,存放函数的参数值、局部变量的值等,操作凡是类似于数据结构的栈; 2、堆区(heap):一般有程序员分配和释放(动态存储分配),分配方式类似于链表; 3、全局区...
  • 今天在群里看了一个奇怪的代码。这样的代码是可以直接运行的 查看了编译以后的代码如下: ...接着就索性研究一下虚函数,成员函数静态成员函数。 把修改成如下。 执行代码如下:
  • --------------------------------------------...注:静态函数与非静态函数在定义上并没有任何区别 只是在声明的时候 静态函数前面有关键字static  而非静态函数是没有这个关键字的。
  • c/c++静态变量和静态函数

    千次阅读 2018-11-11 15:32:26
    而内存主要分为两静态存储区和动态存储区; 静态存储区分为:只读数据(READONLY DATA)区、以读写数据(RW DATA)区、未初始化区(BSS)。它们都是在程序编译连接阶段确定的,在程序执行的阶段不会改变。 ...
  • c++ 调用静态方法

    千次阅读 2018-12-07 16:22:37
    头文件myClass.h class myClass{ ...//cpp不需要再写static void myclass::myFunc(){ //... } 调用myClass的方法 void main(){ //需要用::,而不是-&gt;或者. myClass::myFunc(); } ...
  • 类中静态成员函数访问非静态成员变量 1.思路: 静态成员函数属于(通过访问,调用函数时没有提供this指针), 非静态成员函数属于实例(通过对象访问)(默认都提供了this指针), 非静态成员也属于实例(通过...
  • 比如内绑定自身成员函数作为回调函数,这种情况在开启多线程时很常见,如果不想将回调定义为全局那只能定义为类静态了,为了避免过度破坏封装类中应当尽量不要让类静态成原函数调用成员。这种情况下可以用一种...
  • 1.h #include #include #include class CGlobalUnits { public: //构造函数 CGlobalUnits(); //析构函数 ~CGlobalUnits(); //辅助函数 ... //静态函数 public: static CGlobalUnits* GetInstan
  • 静态函数调用

    千次阅读 2020-01-09 15:48:09
    静态函数 #include <iostream.h> class Point { public: void output()//非静态成员函数 { } static void init()//静态成员函数 { } }; 调用1:非静态成员函数和非静态成员属于对象的方法和数据,也...
  • C#静态函数

    千次阅读 2019-07-09 22:48:51
    //一.新建Person ...面对对象静态函数和非静态函数的区别 { //新建个Person public class Person { private static string _name; //静态字段 public static string Name //属性,对字体的限定...
  • C++中静态成员函数

    千次阅读 多人点赞 2019-03-28 09:33:46
    静态成员函数类中的特殊的成员函数 静态成员函数没有隐藏的this指针:当调用一个对象的非静态成员函数时,系统会将该对象的起始地址赋值给成员函数的this指针.但是,静态成员函数不属于某个对象,为该的所有...
  • c++调用静态函数的方法

    千次阅读 2020-08-09 13:09:25
    今天在写c++程序时,发新现在的gcc和vc++对于静态函数的调用方式有所改变,在旧标准的c++,调用的静态方法只能用类名::函数名的方式,在新的标准的对像也可以像调用的方法一样调用静太函数。示例如下: ...
  • 内联函数和普通函数最大的区别在于内部的实现方面,当普通函数在被调用时,系统首先跳跃到该函数的入口地址,执行函数体,执行完成后,再返回到函数调用的地方,函数始终只有一个拷贝; 而内联函数则不需要进行一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,094,734
精华内容 437,893
关键字:

类中的静态函数