精华内容
下载资源
问答
  • 静态成员函数
    千次阅读
    2020-12-22 09:32:06

    先放上几个小例子
    1、static 修饰成员变量
    静态变量,是在编译阶段就分配空间,对象还没有创建时,就已经分配空间。
    静态成员变量必须在类中声明,在类外定义。
    静态数据成员不属于某个对象,在为对象分配空间中不包括静态成员所占空间。

    class Data
    {
    public:
        int num;//普通成员变量
        static int data;//静态成员变量(类内声明)
    };
    //定义的时候 不需要加static
    int Data::data=100;//类外定义+初始化
    
    void test01()
    {
        //data是静态成员变量 是属于类 可以通过类名称::直接访问
        cout<<Data::data<<endl;//100
        //赋值
        Data::data = 200;
        cout<<Data::data<<endl;//200
    
        //data静态变量 是所有对象 共享的 可以通过对象名访问
        Data ob1;
        ob1.data = 300;
        cout<<Data::data<<endl;//300
    
        Data ob2;
        cout<<ob2.data<<endl;//300
    
        //普通成员变量 属于对象的 只能通过对象名访问
        ob1.num = 100;
        cout<<"ob2.num = "<<ob2.num<<endl;//随机值
        //cout<<Data::num<<endl;//普通成员变量不能通过类名称访问
    }
    

    2、static修饰静态成员函数

    class Data
    {
    private:
        int num;//普通成员变量
        static int data;//静态成员变量(类内声明)
    public:
        //普通成员函数 依赖于 对象的 必须对象调用
        int getData(void)
        {
            return data;
        }
    };
    
    //定义的时候 不需要加static
    int Data::data=100;//类外定义+初始化
    
    void test01()
    {
        //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
        //cout<< Data::getData()<<endl;//err getData() 必须对象调用
    
        Data ob;
        cout<<ob.getData()<<endl;
        //存在问题:data静态的 在创建对象之前 就已经存在
        //如果类没有实例化对象 难道 就不能使用data了吗? 
        //解决上述问题 就要用到静态成员函数
    }
    

    静态成员函数:

    class Data
    {
    private:
        int num;//普通成员变量
        static int data;//静态成员变量(类内声明)
    public:
        //普通成员函数 依赖于 对象的 必须对象调用
        int getData(void)
        {
            return data;
        }
    
        //静态成员函数  属于类 而不属于对象
        static int getDataStatic(void)
        {
            return data;
        }
    };
    
    //定义的时候 不需要加static
    int Data::data=100;//类外定义+初始化
    
    void test01()
    {
        //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
        //cout<< Data::getData()<<endl;//err getData() 必须对象调用
    
        Data ob;
        cout<<ob.getData()<<endl;
        //存在问题:data静态的 在创建对象之前 就已经存在
        //如果类没有实例化对象 难道 就不能使用data了吗?
        //解决上述问题 就要用到静态成员函数
    
        //1、静态成员函数 属于类 就可以通过类名称直接访问
        cout<<Data::getDataStatic()<<endl;
    
        //2、也可以通过对象名访问(对象共享静态成员函数)
        cout<<ob.getDataStatic()<<endl;
    }
    

    注意:
    1、静态成员函数的目的 操作静态成员数据。
    2、静态成员函数 不能访问 非静态成员数据。(静态成员函数内部没有this指针)
    3、普通成员函数 可以操作 静态成员数据 非静态成员数据。
    4、静态成员变量 和 静态成员函数 都有权限之分。


    静态成员函数与非静态成员函数的区别


    成员函数:无论静态函数还是非静态函数,
    都是属于类的(这一点与数据成员的静态非静态不同),
    对象并不拥有函数的拷贝.

    两者的区别在于:
    非静态的函数由类对象(加.或指针加->;)调用,
    这时将向函数传递this指针.而静态函数由类名(:😃(或对象名.)调用,
    但静态函数不传递this指针,不识别对象个体,
    所以通常用来对类的静态数据成员操作.

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

    更多相关内容
  • 主要介绍了C++ 中静态成员函数与非静态成员函数的区别的相关资料,需要的朋友可以参考下
  • C++中静态成员函数与静态成员变量(static ) 这篇介绍了静态成员函数与静态成员变量,是我的读书笔记,我希望它够简短但又比较全面,起到复习的作用。如果有一些C++知识记不清楚了,它可以帮你很快回忆起来。 复习...
  • 静态成员函数不能访问非静态成员,这是因为静态函数属于类而不是属于整个对象,静态函数中的 member可能都没有分配内存。静态成员函数没有隐含的this自变量。所以,它就无法访问自己类的非静态成员
  • 下面小编就为大家带来一篇C++静态成员函数不能调用非静态成员变量(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 大家都知道C++中类的成员函数默认都提供了this指针,在非静态成员函数中当你调用函数的时候,编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面,类还具备了静态成员和静态函数,即 ...
  • 主要介绍了C++中静态成员函数访问非静态成员的实例的相关资料,需要的朋友可以参考下
  • 下面小编就为大家带来一篇C++静态成员变量和静态成员函数的使用方法总结。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 静态成员变量和静态成员函数 class ClassA { int a; int b; static int c; //静态成员变量 static void xxx_fun() //静态成员函数 { ... } } 普通成员变量每个对象都有各自的一份,静态成员变量所有对象...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...

    转载自:https://blog.csdn.net/computer_liuyun/article/details/29235111

    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就对静态数据成员和静态成员函数坐下小结哈!

    一、静态数据成员

    1.静态数据成员怎么去定义?

    在类中声明静态数据成员很简单,是以static关键字表明即可,如下所示

    class Test{
    private:
    	//静态数据成员
    	static int a;
    };
    

    a就是静态数据成员了,在类中只能声明可是不能定义哈!

    要对静态数据成员定义和初始化必须在类的外面也就是在全局作用域中定义,如果定义不给出初值,则默认初值为0

    class Test{
    public:
    	int GetA() const{return a;}
    private:
    	//静态数据成员
    	static int a;
    };
    //int Test::a;如果这样定义不赋予初值则初值为零
    int Test::a = 1;
    #include <iostream>
    int main()
    {
    	Test T;
    	std::cout << T.GetA() << std::endl;
    }
    

    定义时一定要在全局作用域中定义,一定不要在类中定义!

    静态数据成员甚至在类没有任何对象的时候都可以访问,静态成员可以独立访问,无需依赖任何对象的建立

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

     

    2.静态数据成员被类的所有对象共享,包括该类的派生类对象,基类对象和派生类对象共享基类的静态数据成员

    答:静态数据成员不属于任何对象,类的静态数据成员的存在不依赖于任何类对象的存在,静态数据成员是由类的所有对象共享的。例子如下:

    class Base{
    public:
    	//静态数据成员
    	static int a;
    };
    class Derived : public Base{
     
    };
    //int Test::a;如果这样定义不赋予初值则初值为零
    int Base::a;
    #include <iostream>
    int main()
    {
    	Base B;
    	Derived D;
    	B.a++;
    	std::cout << B.a << std::endl;
    	D.a++;
    	std::cout << D.a << std::endl;
    	
    }
    

    打印结果如下:

    由打印结果看出来,派生类对象和基类对象都是共享基类的静态数据成员,而基类的所有对象也是共享该静态数据成员,且该静态数据成员应该在全局作用域中定义,可以赋予初值也可以不赋予初值,如果不赋予初值,静态数据成员有其默认值。

     

    3.静态数据成员可以作为成员函数的默认形参,而普通数据成员则不可以

    答:不多说,直接看例子马上就明白了哈!

    class Test{
    public:
    	//静态数据成员
    	static int a;
    	int b;
    	void fun_1(int i = a);//正确
    	void fun_2(int i = b);//报错
    };
    

    4.静态数据成员的类型可以是所属类的类型,而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用

    答:这个也不多说,直接看例子就可以懂什么意思哈!

    class Test{
    public:
    	//静态数据成员
    	static Test a;//正确
    	Test b;//报错
    	Test *pTest;//正确
    	Test &m_Test;//正确
    	static Test *pStaticObject;//正确
    };
    

    5.静态数据成员在const函数中可以修改,而普通的数据成员是万万不能修改的哈!

    答:看个例子

    class Test{
    public:
    	Test():b(0){}
    	//静态数据成员
    	static int a;//正确
    	int b;
    	void test() const
    	{
    		a++;
    		b++;//const指的不能修改当前调用该函数对象的数据成员
    	}
    };
    int Test::a;
    

    const修饰的时当前this指针所指向的对象是const,但是静态数据成员不属于任何类的对象,它被类的所有对象修改,所以this指针不修饰静态的数据成员,所以可以更改。

     

    二、静态成员函数

    静态成员函数的声明也很简单,就是在类的成员函数前加上static关键字即可,和静态成员一样,静态成员函数也是属于类的,它并不属于任何对象,当调用静态成员函数时应该使用类名和域运算符“∷”,当然也可以使用对象调用操作,但是这样的操作并不意味着静态成员函数属于这个对象,它只是被这个对象共享而已,这样也就决定了静态成员函数中是不能访问本类中的非静态数据成员的,它是不能访问非静态数据成员的,在c++中静态成员函数主要用来访问静态数据成员而不访问非静态数据成员

    1.静态成员函数不能调用非静态成员函数,但是反过来是可以的

    2.静态成员函数没有this指针,也就是说静态成员函数不能使用修饰符(也就是函数后面的const关键字)

    3.静态成员函数的地址可用普通函数指针储存,而普通成员函数地址需要用 类成员函数指针来储存。

    总结:其实声明为静态,不论是静态数据成员还是静态成员函数,它们都是不依赖于对象而存在的,类在定义后并不分配存储空间,而是在定义类的对象的时候才分配存储空间,相反静态的数据成员和静态的成员函数是已经在内存中开辟了内存空间了,所以静态数据成员可以独立的访问在任何类对象没有建立起来都可以访问,并且静态成员函数不可以调用非静态成员函数,因为非静态成员函数只有在类对象建立以后才可以调用,相反则是可以的。我觉得当对某个判断产生怀疑的时候应该去测试,只有验证了才知道是不是对的哈!

    为了能更好阐释静态数据成员和静态成员函数,然后在网上搜了博客,感觉有些例子不错(因找不到最初的出处,所以无法注明请原作者谅解),所以就拿来给大家参考一下哈!

    关于玩篮球的例子很能明显解释静态数据成员和静态成员函数到底是怎么回事

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

    为了使大家更好的理解这两个概念,还是老样子用代码来说明上面文字说明的这一切哈!

    关于学生类的例子

    //定义Student类
    #include <iostream>
    class 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;           
    };
    //在全局作用域对静态数据成员初始化,如果不赋予初值,则使用其默认值零
    float Student::sum;                     
    int Student::count;
    //定义非静态成员函数
    void Student::total()                    
    {
    	//累加总分
    	sum+=score;
    	//累计已统计的人数
    	count++;                               
    }
    //定义静态成员函数
    float  Student::average()                  
    {
    	return(sum/count);
    }
    int main()
    {
    	Student stud[3]={    
    	//定义对象数组并初始化
    	Student(1001,18,70),
    	Student(1002,19,78),
    	Student(1005,20,98)
    };
    int n;
    std::cout<<"please input the number of students: ";
     //输入需要求前面多少名学生的平均成绩
    std::cin>>n;                              
    //调用3次total函数
    for(int i=0;i<n;i++)
    {
    	stud[i].total();
    }
    //调用静态成员函数
    std::cout<<"the average score of "<<n<<" students is "<<Student::average( )<<std::endl;
    return 0;
    }
    

    打印输出如下:

     

    对上面的代码做以下说明:

    首先,在主函数中定义了对象数组,存放每个学生的编号、年龄和成绩,其中sum和count是要累计所有学生的总成绩和总的学生人数,我们定义成了静态数据成员,在学生类的成员函数中,我们定义了普通的total成员函数,用来计算所有学生的总成绩和总的学生人数,另外,定义了静态成员函数average,学生类的设计大概如此

    在全局作用域对类中静态数据成员进行了定义,但未赋予初值,这意味着我们采用其默认值。

    在类的普通成员函数toal中可以引用静态数据成员sum和count,可见类的所有成员函数都可以引用类的静态数据成员。

    在类的静态成员函数average中,只能引用类的静态数据成员,不能引用非静态数据成员。

    在主函数中我们调用类的非静态成员函数时只能通过类对象来调用,如stu[i].total,但是对于静态成员函数可以直接通过类名+作用域符号来调用,如

    Student::average。

     

    展开全文
  • 声明为 static 的类成员或者成员函数便能在类的范围内共同享,我们把这样的成员称 做静态成员和静态成员函数
  • C++静态成员函数 与数据成员类似,成员函数也可以定义为静态的,在类中声明函数的前面加static就成了静态成员函数。如 static int volume( ); 和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一...
  • 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

    展开全文
  • 静态成员 静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员 静态成员分为: 1.静态成员变量 所有对象共享同一份数据 在编译阶段分配内存 ...2.静态成员函数 所有对象共享一个函数

    静态成员

    静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员
    静态成员分为:

    1.静态成员变量

     所有对象共享同一份数据
     在编译阶段分配内存
     类内声明,类外初始化
    

    示例:

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
       static int m; // 所有对象共享同一份数据
    };
    int Person::m = 0;// 类内声明,类外初始化
    

    2.静态成员函数

    所有对象共享一个函数
    静态成员函数只能访问静态成员变量
    
    #include<iostream>
    using namespace std;
    class Person
    {
    public:
       static void func()
       {
       	cout << "static void func调用" << endl;
       	m_a = 100;//静态成员函数可以访问静态成员变量
       	//m_b=100,静态成员函数不可以访问非静态成员变量
       	//原因无法区分到底哪个是对象的m_b;
       }
       static int m_a;//静态成员变量
       int m_b;
    };
    int Person::m_a = 0;
    int main()
    {
       //1.通过对象访问
       Person p;
       p.func();
       //2.通过类名访问
       Person::func();
    
       system("pause");
       return 0;
    }
    

    静态成员函数可以访问静态成员变量
    静态成员函数不可以访问非静态成员变量
    私有权限的静态成员函数,也是访问不到的

    成员变量和成员函数分开存储

    在C++中,类内的成员变量和成员函数分开存储
    只有非静态成员变量才属于类的对象上

    空对象:

    #include<iostream>
    using namespace std;
    class Person
    {
    
    };
    void test01()
    {
    	Person p;
    	//空对象占用内存空间为:1
    	//C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
    	//每个空对象也应该有独一无二的内存地址
    	cout << sizeof(p) << endl;
    }
    int main()
    {
    	test01();
    	return 0;
    }
    

    输出结果:1

    #include<iostream>
    using namespace std;
    class Person
    {
    	int m_a;//非静态成员变量 属于类的对象上
    };
    void test02()
    {
    	Person p;
    	cout << sizeof(p) << endl;
    }
    int main()
    {
    	test02();
    }
    

    输出结果:4

    #include<iostream>
    using namespace std;
    class Person
    {
    	int m_a;//非静态成员变量 属于类的对象上
    	static int m_b; //静态成员变量 不属于类的对象上
    };
    void test02()
    {
    	Person p;
    	cout << sizeof(p) << endl;
    }
    int main()
    {
    	test02();
    }
    

    输出结果:4
    与第二个对比可知:
    静态成员变量 不属于类的对象上

    #include<iostream>
    using namespace std;
    class Person
    {
    	int m_a;//非静态成员变量 属于类的对象上
    	static int m_b; //静态成员变量 不属于类的对象上
    	void func() {}//非静态成员函数 不属于类的对象上
    	static void func2() {} //静态成员函数也不会属于 类的对象上
    };
     int Person::m_b = 0;
    void test02()
    {
    	Person p;
    	cout << sizeof(p) << endl;
    }
    int main()
    {
    	test02();
    }
    

    输出结果:4

    结论:只有非静态成员变量才属于类的对象上

    this 指针

    每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一块代码
    那么问题是:这块代码是如何区分是哪个对象调用自己的呢?

    C++通过提供的特殊的对象指针,this指针,解决上述问题,this 指针指向被调用的成员函数所属的对象,
    通俗的说,谁调用它,this就指向谁
    this 指针是所有成员函数的隐含参数吗,不需要定义,可直接使用

    this 指针的用途

    1.当形参和成员变量同名时,可用this指针来区分
    2.在类的非静态成员函数中返回对象本身,可用 return  *this 
    

    1.当形参和成员变量同名时,可用this指针来区分

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	void func(int age)
    	{
    		this->age = age;  //
    	}
    	int age;
    };
    int main()
    {
    	Person p;
    	p.func(18);
    	cout << p.age << endl;
    	system("pause");
    	return 0;
    }
    

    2.在类的非静态成员函数中返回对象本身,可用 return *this

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	Person& func(Person&p)
    	{
    		this->age += p.age;
    		return *this;
    	}
    	int age;
    };
    int main()
    {
    	Person p;
    	p.age = 10;
    	//链式编程思想
    	p.func(p).func(p).func(p);
    	cout << p.age << endl;
    	system("pause");
    	return 0;
    }
    

    空指针访问成员函数

    C++中空指针是可以调用成员函数,但是也要注意有没有用到this指针
    如果用到this指针,需要加以判断保证代码的健壮性

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	void ShowPersonclass()
    	{
    		cout << "调用ShowPerclass()函数" << endl;
    	}
    };
    int main()
    {
    	Person* p = NULL;
    	p->ShowPersonclass();
    	system("pause");
    	return 0;
    }
    

    通过空指针p是可以访问到成员函数(不带this指针的成员函数)
    如下代码就是一个错误代码

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	void ShowPersonname()
    	{
    		cout << m_name << endl;  //此处出现了this指针
    	}
    	int m_name;
    };
    int main()
    {
    	Person* p = NULL;
    	p->ShowPersonname();
    	system("pause");
    	return 0;
    }
    

    解析:
    此处出现了this指针,

    cout << m_name << endl;
    

    相当于

    cout <<this -> m_name << endl;
    

    而this指针是一个空指针,所以会报错
    为了增加代码的健壮性,我们因该做出如下改动

    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	void ShowPersonname()
    	{
    		if (this == NULL)  //在此判断this是否是空指针
    			return;
    		cout << m_name << endl;
    	}
    	int m_name;
    };
    int main()
    {
    	Person* p = NULL;
    	p->ShowPersonname();
    	system("pause");
    	return 0;
    }
    
    展开全文
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    C++的静态成员变量和静态成员函数 静态成员变量和静态成员函数算是C++面向对象编程中的一个重点和难点,这里的静态具体指什么呢?与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是...
  • 静态成员函数访问非静态数据成员【C++】

    千次阅读 多人点赞 2021-05-11 10:33:56
    静态成员函数访问非静态数据成员静态数据成员静态成员函数 静态数据成员 定义格式: static 类型名 静态数据成员名 ; 详解:由于静态数据成员属于本类的所有对象共享,不属于特定类对象,因此在未产生类对象时作用...
  • C++静态成员函数访问非静态成员的四种方法

    千次阅读 多人点赞 2021-07-01 17:00:48
    大家都知道C++中类的成员函数默认都提供了this指针,在非静态成员函数中当你调用函数的时候,编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面,类还具备了静态成员和静态函数,即 class...
  • C++中子类是否可以继承父类的静态成员和静态成员函数? 静态成员变量 #include <iostream> using namespace std; class Base { public: Base(int a) { val = a; cout << "Base construct fun" <&...
  • 静态成员不可在类体内进行赋值,因为它是被所有该类的对象所共享的。你在一个对象里给它赋值,其他对象里的该成员也会发生变化。为了避免混乱,所以不可在类体内进行赋值
  • c++——静态成员函数

    千次阅读 2020-10-22 10:43:01
    静态成员的定义: 静态成员是在类中定义的一个成员变量,和普通成员函数不同的地方是在声明...静态成员函数和静态成员变量类似,只是在普通成员函数前面加入了关键字static:如: class Account{ public: static vo
  • 静态成员函数详解

    千次阅读 2020-02-02 18:10:48
    在类中,static 除了可以声明静态成员变量,还可以声明静态成员函数。普通成员函数可以访问所有成员(包括成员变量和成员函数),静态成员函数只能访问静态成员。 编译器在编译一个普通成员函数时,会隐式地增加一个...
  • 2、对于类静态数据成员,无论有多少个该类的对象,该静态数据成员在内存中只有一份拷贝(其他普通数据成员,每个类对象都有自己的内存拷贝),该静态数据成员由所有该类对象共享 3、静态数据成员存储在全局数据区,...
  • C++ static静态成员函数详解

    千次阅读 2022-02-02 19:24:08
    C++ static静态成员函数详解 在类中,static 除了可以声明静态成员变量,还可以声明静态成员函数。普通成员函数可以访问所有成员(包括成员变量和成员函数),静态成员函数只能访问静态成员。 编译器在编译一个普通...
  • This指针,静态成员函数和非静态成员函数

    千次阅读 多人点赞 2019-02-27 14:12:12
    C++中,静态成员函数不能被声明为virtual函数。  例如,下面的程序会编译失败。 #include&lt;iostream&gt; class Test { public: // 编译错误:static成员函数不能声明为virtual virtual static ...
  • C++ 类的静态成员及静态成员函数  对象与对象之间的成员变量是相互独立的。要想共用数据,则需要使用静态成员和静态方法。  只要在类中声明静态成员变量,即使不定义对象,也可以为静态成员变量分配空间,...
  • 类的静态成员与静态成员函数

    千次阅读 2020-08-14 22:49:54
    声明静态成员 使用类的静态成员 定义静态成员 静态成员的类内初始化 静态成员能用于某些场景,而普通函数不能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 429,335
精华内容 171,734
关键字:

静态成员函数

友情链接: Modbus Master.zip