精华内容
下载资源
问答
  • 2019-10-22 15:25:48

    1.静态数据成员

    (1)静态数据成员不仅可以通过对象访问,还可以直接使用类名进行访问。

    class Student
    
    {
        public:
    
            string name;
    
            static int age;
    
    };
    
    
    int main()
    
    {
        Student stu1;
    
        cout<<Student::age<<stu1.age;//两种方式都可以
    }

    (2)静态数据成员是被所有的类对象共享的,也就是说无论创建了多少了对象静态数据成员就只有一份,只要有一个对象修改了静态数据成员,其他对象的该成员也会改变。简单的说,就是所有对象都使用这一个数据成员,并不是每个对象单独一个。

    class Student
    
    {
        public:
    
            string name;
    
            static int age;
    };
    
    
    int main()
    
    {
        Student stu1,stu2;
    
        stu1.age=20;
    
        cout<<stu1.age<<stu2.age;//输出的结果相同
    }

    (3)静态数据成员其类型可以是当前类的类型,而非静态成员是不可以的,除非是指针。

    class Student
    
    {
        public:
    
            string name;
    
            static int age;
    
            Student stu1;        //错误
    
            static Student stu2;  //正确
    
            Student *stu3;        //正确
    }

    2、静态成员函数

    (1)静态成员函数只能访问类的静态数据成员,不能访问非静态的数据成员。

    (2)静态成员函数不能用const关键字修饰。这是由于const实际上适用于修饰this指针的,而静态成员函数时没有this指针的,所以不能用const。

    (3)静态成员函数实现和声明,只能有一处标明static。

    三、this指针

    class Student
    
    {
        public:
    
            string name;
    
            static int age;
    
            int getAge()
    
            {
                return age;
            }
    };
    
    
    int main()
    {
        Student stu1,stu2;
    
        stu1.age=20;
    
        stu2.age=30;
    
        cout<<stu1.getAge()<<stu2.getAge();
    }

    之所以不同对象调用同一个函数,输出结果相同时因为getAge()中有隐藏的this指针,该函数其真实形式是

    int getAge(Student *this)
    
    {
        return this->age;
    }

     

     

    更多相关内容
  • 大家都知道C++中类的成员函数默认都提供了this指针,在非静态成员函数中当你调用函数的时候,编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面,类还具备了静态成员和静态函数,即 ...
  • 静态成员函数只能访问静态数据成员、静态成员函数和类以外的函数和数据,不能访问非静态数据成员,但静态成员函数或静态数据成员可由任意访问许可的函数访问。原因是:当前对象的地址(this)是被隐含地传递到被调用...
  • C++中静态成员变量与静态成员函数

    千次阅读 2022-04-22 13:46:51
    C++中静态成员变量与静态成员函数

    Hello,我是你们的好朋友一一,一一这次呢想跟大家分享的知识点是静态成员变量和静态成员函数

    So what is the 静态成员???

    1.静态成员:

    在类定义中,它的成员(包括成员变量和成员函数),这些成员可以用关键字static声明为静态的,称为静态成员。

    1.1 静态成员变量:

            在一个类中,若将一个成员变量声明为static,这种成员称为静态成员变量。静态成员变量,属于某个类,所有对象共享。

         静态变量,是在编译阶段就分配空间,对象还没有创建时,就已经分配空间。

    一一敲黑板啦!!!

    1. 静态成员变量必须在类中声明,在类外定义
    2. 静态数据成员不属于某个对象,在为对象分配空间中不包括静态成员所占空间。
    3. 静态数据成员可以通过类名或者对象名来引用。

                     话不多说,直接上代码吧!! !

    //静态成员变量:在一个类中,在一个成员变量前面加static,在类中声明,类外定义
    
    class Person
    {
    public:
    	static int m;//类内声明
    
    };
    
    int Person::m = 10; //类外初始化
    
    void test()
    {
    	Person p1;
    	p1.m = 20;
    	cout << p1.m << endl; //通过对象访问
    	cout << Person::m << endl; //通过类名访问
    }
    int main()
    {
    	test();
    	return 0;
    }
    

    1.2 静态成员函数

            在类定义中,前面有static说明的成员函数称为静态成员函数。静态成员函数使用方式和静态变量一样,同样在对象没有创建前,即可通过类名调用。静态成员函数主要为了访问静态变量,但是,不能访问普通成员变量

            静态成员函数的意义,不在于信息共享,数据沟通,而在于管理静态数据成员,完成对静态数据成员的封装。

    一一又来划重点啦!!!

    1. 静态成员函数只能访问静态变量,不能访问普通成员变量
    2. 静态成员函数的使用和静态成员变量一样
    3. 静态成员函数也有访问权限
    4. 普通成员函数可访问静态成员变量、也可以访问非经常成员变量

    
    //静态成员函数
    class Person
    {
    public:
    	static void fun()
    	{
    		cout << "调用fun" << endl;
    	}
    };
    
    void test()
    {
    	Person p1;
    	p1.fun();  //通过对象调用
    	Person::fun();//通过类调用
    }
    int main()
    {
    	test();
    	return 0;
    }
    //静态函数只能访问静态变量,不能访问非静态变量。
    
    class Person
    {
    public:
    	static int m;
    	int n;
    	static void fun()
    	{
    		cout << "调用fun" << endl;
    		m = 10;  //静态函数只能访问静态变量
    		//n = 10;   报错,静态函数不能访问非静态变量
    	}
    };

    今天一一也是元气满满的一天呀!大家继续冲鸭!!! 

    欢迎大家批评指正! 

    end

    展开全文
  • 为啥静态函数只能调用静态成员

    千次阅读 2020-06-25 23:04:54
    在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个对象的成员。 使用静态数据成员可以节省...

    首先得知道为什么要使用静态数据成员:


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

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

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

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

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

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

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

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

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

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

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

     

    为什么不能在静态成员函数中使用非静态变量:

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

    因为静态是针对类的,而成员变量为对象所有。

    静态成员函数不属于任何一个类对象,没有this指针,而非静态成员必须随类对象的产生而产生,所以静态成员函数”看不见”非静态成员,自然也就不能访问了

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

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

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

     

    静态成员函数

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

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

    #include <iostream>
    using namespace  std;
    class M{
    public:
        M(int a){
         this->A=a;
         this->B=this->B+a;
        }
        static void f1(M m);
    private:
        int A;
        static int B;
    };
    int M::B=0;//静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>,z初始化在外部实现
    void M::f1(M m){
    cout<<"A="<<m.A<<endl;静态成员函数中通过对象来引用非静态成员
    cout<<"B="<<B<<endl;
    }
    int main()
    {
        M P(5);
        M Q(10);
        M::f1(P);静态成员函数调用时不用对象名
        return 0;
    }
    

    从中可看出,调用静态成员函数使用如下格式:

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

    运行结果:

    A=5

    B=15

     

    展开全文
  • 所以全局变量和静态成员变量的功能差不多,只是创建的方式不同,类的静态成员创建在类中,全局变量创建在程序开头. 二.为什么要用类的静态成员而不用全局变量 全局变量在c中得心应手,而在c++中却力不从心.全局变量...

    一.什么是类的静态成员
    静态成员变量和全局变量都存储在全局/静态区,它们都是在程序编译时创建,直到编译结束才被收回.所以全局变量和静态成员变量的功能差不多,只是创建的方式不同,类的静态成员创建在类中,全局变量创建在程序开头.

    二.为什么要用类的静态成员而不用全局变量
    全局变量在c中得心应手,而在c++中却力不从心.全局变量定义在程序开头,一旦全局变量多了,就会降低程序的可读性,并且这样定义变量会使程序变得很不安全.而
    三.怎样创建类的静态成员
    首先在human.h头文件的类中声明静态数据成员,但是不能初始化.

    static int humanCount;
    

    然后在human.cpp源文件中初始化静态成员,初始化时不需要写static

    int Human::humanCount = 0;
    

    四.什么是静态成员函数
    静态成员函数和静态数据成员一样,属于类的,不是属于某个具体对象的.
    五.为什么用静态成员函数
    静态数据成员存在bug,此bug就是静态数据成员函数可以被任何函数修改,并且必须要创建具体的对象才能调用该函数.首先安全性很低,其次必须要创建一个不必用的对象才能用函数,浪费资源.
    类的静态数据成员和静态成员函数就像故宫一样,人人都能去,并且不属于某个个人.调用静态成员函数时只需要用类名调用即可,节省资源.但是类名不能直接调用静态数据成员.
    首先在human.h头文件的类中声明静态成员函数.

    static int getHumanCount();
    

    然后在human.cpp源文件中定义静态成员函数,定义时不需要写static

    int Human::getHumanCount() {
    	return humanCount;
    }
    

    然后在main.cpp源文件中调用静态成员函数

    void showMsg() {
    	cout << Human::getHumanCount() << endl;
    }
    

    五.总结
    1)静态数据成员:
    所有的成员函数,都可以访问静态数据成员.
    类和对象不能直接访问普通的静态数据成员(Human::humanCount非法)
    2)静态成员函数
    类和对象都可以访问静态成员函数(Human::getHumanCount())
    静态成员函数无法访问类的非静态数据成员(如:静态成员函数访问age时,他就蒙了,不知道到底要访问哪个age,因此这是非法的),静态成员函数只能访问属于类的,不能访问具体对象所有的属性,因为静态成员函数不知道是哪一个的.
    静态成员函数只能访问类的静态成员函数.

    在这里插入图片描述

    展开全文
  • 类的静态函数只能访问类的静态成员变量 类的静态函数只能访问类的静态成员变量 类的静态函数只能访问类的静态成员变量 类的静态函数只能访问类的静态成员变量 转载于:...
  • 类的静态成员函数

    千次阅读 2020-06-16 11:24:36
    1)静态函数成员不可以直接访问类中非静态数据成员以及非静态成员函数只能通过对象名(由参数传入)来访问; 2)静态成员函数在类外定义时,无需加static修饰,否则出错; 3)在类外,可以通过对象名以及类名来...
  • 静态函数只有当程序结束的时候才从内存消失。而非静态则是动态加载到内存,不需要的时候就从内存消失。 据个例子,调用类中的静态函数,你不需要创建对象就可以调用。而对于非静态函数,你必须要先创建对象,才...
  • C++静态成员函数访问非静态成员的四种方法

    千次阅读 多人点赞 2021-07-01 17:00:48
    大家都知道C++中类的成员函数默认都提供了this指针,在非静态成员函数中当你调用函数的时候,编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面,类还具备了静态成员和静态函数,即 class...
  • 只能使用一个全局变量,然后在构造函数中对这个全局变量进行修改(加1) 缺点:使用全局变量不方便,破坏程序的封装性。 解决方案: 使用类的静态成员。 头文件:Human.h class Human { public: ...... int ...
  • C++静态成员函数和静态数据成员

    千次阅读 2014-08-05 22:47:10
    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。静态...
  • c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用对象名来调用。 测试代码: #include <iostream> using namespace std; class Point{ public: Po...
  • 文章目录类中静态成员变量与静态成员函数的特点静态成员变量示例代码typeid运算符静态成员函数示例代码this指针访问权限 类中静态成员变量与静态成员函数的特点 在类中以static 修饰的变量以及函数称为静态成员变量...
  • C++ 静态成员函数

    千次阅读 2020-02-28 13:25:31
    1、普通成员函数可以访问所有成员(包括成员变量和成员函数),而静态成员函数只能访问静态成员。 编译器在编译一个普通成员函数时,会隐式地增加一个形参 this指针,并把当前对象的地址赋值给这个this指针,所以...
  • This指针,静态成员函数和非静态成员函数

    千次阅读 多人点赞 2019-02-27 14:12:12
    C++中,静态成员函数不能被声明为virtual函数。  例如,下面的程序会编译失败。 #include&lt;iostream&gt; class Test { public: // 编译错误:static成员函数不能声明为virtual virtual static ...
  • 类的静态成员与静态成员函数

    千次阅读 2020-08-14 22:49:54
    声明静态成员 使用类的静态成员 定义静态成员 静态成员的类内初始化 静态成员能用于某些场景,而普通函数不能
  • 静态成员函数不能访问非静态成员,但可以访问静态成员,也就是说,如果我们的这个类是个单例,我们完全可以在创建的时候把this指针赋值给那个静态成员,然后在静态成员函数内部就可以放心大胆的使用了。 class A { ...
  • 1、static成员函数不能访问非static成员函数/成员,只能static成员间相互访问: //.h class A { public: static func1() // 编译出错 { menber1 = 1; } static func3() { cout<<"abc"<<endl; } ...
  • 静态成员函数详解

    2020-02-02 18:10:48
    普通成员函数可以访问所有成员(包括成员变量和成员函数),静态成员函数只能访问静态成员。 编译器在编译一个普通成员函数时,会隐式地增加一个形参 this,并把当前对象的地址赋值给 this,所以普通成员函数只能在...
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    C++的静态成员变量和静态成员函数 静态成员变量和静态成员函数算是C++面向对象编程中的一个重点和难点,这里的静态具体指什么呢?与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是...
  • 1、静态数据成员 1、在类内数据成员前加上 static ... 4、静态数据成员不能再类中定义和初始化,只能在类中声明,在类外进行定义和初始化,默认初始化为0 5、静态数据成员的初始化为 <类型名> <类名>...
  • 静态成员函数访问构造函数

    千次阅读 2017-04-08 00:16:27
    非静态的成员函数是属于类的,不属于某个对象,所以不含有this指针,所以只能调用静态成员函数静态成员函数,但是今天在实现单例模式(一个类只能拥有一个对象时发现静态成员函数可以访问构造函数,难道构造函数是...
  • C++提供static这个关键词对静态成员进行声明,静态成员函数和类的实例化无关,对于同一类来说,静态成员函数是所有类的对象共享的。而普通成员函数需要实例化才能调用,对于每一个实例来说,普通成员函数是自己独有...
  • 首先要明白:静态成员函数是可以调用非静态数据成员的,具体怎么调用,看下面。 class A { public: static void fun ( A a ) { cout << b <<endl;(错误) cout <&l...
  • 和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分。如果要在类外调用公用的静态成员函数,要用类名和域运算符“∷”。如 Box∷volume( ); 实际上也允许通过对象名调用静态成员函数,如 a....
  • 类的所有成员函数都可以访问本类的私有成员,但是静态成员函数没有this指针,因此通过 该类的对象作为函数参数,可以显示访问该类的私有成员。 测试程序如下: #include &lt;stdio.h&gt;   class Demo ...
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 189,383
精华内容 75,753
关键字:

静态成员函数只能访问