精华内容
下载资源
问答
  • 静态成员函数与非静态成员函数的区别 数据成员: 静态数据成员是类的一部分,为类的所有实例共享(静态区);非静态数据成员,类的每个实例都有一份拷贝(动态区)。 静态数据成员的访问: 静态数据成员是类的一部分,在...
  • 静态成员变量和静态成员函数 class ClassA { int a; int b; static int c; //静态成员变量 static void xxx_fun() //静态成员函数 { ... } } 普通成员变量每个对象都有各自的一份,静态成员变量所有对象...
  • 静态成员函数

    千次阅读 2013-10-24 22:17:19
    一个类的静态成员函数只产生一个而无论生成的对象有多少个,且静态函数只能使用静态成员 一段代码就能说明: #include #include using namespace std; class test{ public: static void fun(){ cout() "; //...

    一个类的静态成员函数只产生一个而无论生成的对象有多少个,且静态函数只能使用静态成员

    一段代码就能说明:

    #include<iostream>
    #include<string>
    using namespace std;
    class test{
        public:
            static void fun(){
                cout<<"fun() "<<i<<endl;
                //cout<<name<<endl;//静态函数使用非静态成员编译错误
            }
            void show(){
                cout<<"show() "<<i<<" "<<name<<endl;
            }
            test(string y="...."):name(y){};
        private:
            static int i;
            string name;
    };
    int test::i=10;//静态成员变量在类外初始化,不加static
    int main(){
        test::fun();
        //test::show();//这种方法只适用于静态成员函数,编译错误
        test one("xxxx");
        one.fun();//对象可以使用静态成员函数
        one.show();
        return 0;
    }
    fun() 10
    fun() 10
    show() 10 xxxx

    展开全文
  • 介绍C++中静态成员函数与费静态成员函数的区别。

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


    数据成员:

    静态数据成员是类的一部分,为类的所有实例共享(静态区);非静态数据成员,类的每个实例都有一份拷贝(动态区)。

    静态数据成员的访问:

    静态数据成员是类的一部分,在产生任何实例之前已经存在,通过类名::静态成员变量名访问。


    函数成员(都在代码区):

    静态函数成员与非静态函数成员都为类所有,对象并不存在函数的拷贝。静态成员函数和非静态成员函数的根本区别在于非静态函数由对象名.或者对象指针->调用,调用时编译器会向函数传递this指针;静态成员函数则有类名::或者对象名.调用,编译器不向函数传递this指针,不识别对象个体,经常用来操作类的静态数据成员,要访问类的非静态成员可以通过对象来实现


    内存角度分析:

    类的静态成员(数据成员和函数成员)为类本身所有,在类加载的时候就会分配内存,可以通过类名直接访问;非静态成员(数据成员和函数成员)属于类的实例所有,所以只有在创建类的实例的时候才会分配内存,并通过实例去访问。

    注意:类的静态数据成员是静态存储,它是静态生存周期,必须进行初始化。

    注意:静态数据成员的初始化在类体外进行,前面不加static以免与一般静态变量或者对象混淆。


    静态成员函数访问非静态成员报错:

    类的静态成员在类加载的时候就已经分配内存,而此时类的非静态成员尚未分配内存,访问内存中不存在的东西自然会出错。


    例子:

    #include <iostream>
    
    using namespace std;
    
    class Test
    {
    	public:
    		Test(int a){ A = a; ++B;}
    		static void smf(Test tt);
    	private:
    		int A;
    		static int B;
    };
    
    void Test::smf(Test tt)
    {
    	cout << "tt.A : " << tt.A << endl;    //静态成员函数中通过对象来引用非静态成员
    	cout << "Test::B : " << Test::B << endl;
    	cout << "tt.B : " << tt.B << endl;
    }
    
    int Test::B = 0; //静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>
    
    int main()
    {
    	Test t1(100);
    	Test t2(200);
    	Test::smf(t1);
    	Test::smf(t2);//静态成员函数调用时不用对象名
    
    	system("pause");
    	return 0;
    }
    



    展开全文
  • C++中静态成员函数访问非静态成员的实例 实现代码: #include /* 静态成员函数只能访问静态数据成员、静态成员函数和类以外的函数和数据,不能访问非静态数据成员,但静态成员函数或静态数据成员可由任意访问许可...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 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。

     

    展开全文
  • 和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分。如果要在类外调用公用的静态成员函数,要用类名和域运算符“∷”。如 Box∷volume( ); 实际上也允许通过对象名调用静态成员函数,如 a....
    和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分如果要在类外调用公用的静态成员函数,要用类名和域运算符“∷”。如
    Box∷volume( );
    实际上也允许通过对象名调用静态成员函数,如
    a.volume( );
    但这并不意味着此函数是属于对象a的,而只是用a的类型而已
    静态成员函数的作用是为了能处理静态数据成员
    可以说,静态成员函数与非静态成员函数的根本区别是: 非静态成员函数有this指针,静态成员函数并不属于某一对象,它与任何对象都无关,静态成员函数没有this指针。由此决定了静态成员函数不能访问本类中的非静态成员。
    在C++程序中,静态成员函数主要用来访问静态数据成员,而不访问非静态成员。假如在一个静态成员函数中有以下语句:
    cout<<height<<endl;             //若height已声明为static,则引用本类中的静态成员,合法
    cout<<width<<endl;              //若width是非静态数据成员,不合法


    那有需要访问怎么办?一是实例化一个类,比如staticfunc(a.getval)来调用,或者用指针,传入自己的对象指针。

    class A
    {
    public:
      static void func(A & obj);
      int getval() const; //non-static member function
    private:
     int val;
    };

    静态成员函数func()会使用参照obj来访问非静态成员val。

    voidA::func(A & obj)
    {
      int n = obj.getval();
    }


    静态数据成员和普通数据成员区别较大,体现在下面几点: 
      (1)普通数据成员属于类的一个具体的对象,只有对象被创建了,普通数据成员才会被分配内存。而静态数据成员属于整个类,即使没有任何对象创建,类的静态数据成员变量也存在。 

      (2)因为类的静态数据成员的存在不依赖与于任何类对象的存在,类的静态数据成员应该在代码中被显示的初始化,一定要在类外进行,例如上例。 

      (3)外部访问类的静态成员只能通过类名来访问,例如:test::getCount()。 
      (4)类的静态成员函数无法直接访问普通数据成员(可以通过类的指针等作为参数间接访问),而类的任何成员函数都可以访问类的静态数据成员。 

      (5)静态成员和类的普通成员一样,也具有public、protected、private3种访问级别,也可以具有返回值、const修饰符等参数。

    展开全文
  • 在多人开发的项目中,一些通用的工具类接口可以用静态成员函数。方便调用,并且不容易调用错误。静态成员函数不传递this指针(不能-&gt;),不识别对象个体,所以经常用于对静态数据成员进行操作。不能操作非静态...
  • 静态成员函数不能访问非静态成员,这是因为静态函数属于类而不是属于整个对象,静态函数中的 member可能都没有分配内存。静态成员函数没有隐含的this自变量。所以,它就无法访问自己类的非静态成员
  • 静态成员函数暗含this指针,调用非静态成员函数,需要this指针,如执行非静态成员函数merge(),实际是this->merge(),而静态成员函数不含this,因此无法调用 调用构造函数,不需要this,因此静态成员函数可以...
  • 其实我们从直观上可以很好的理解静态成员函数不能调用非静态成员变量这句话因为无论是静态成员函数还是静态成员变量,它们 都是在类的范畴之类的,及在类的整个生存周期里始终只能存在一份。然而非静态成员变量和非...
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    C++的静态成员变量和静态成员函数 静态成员变量和静态成员函数算是C++面向对象编程中的一个重点和难点,这里的静态具体指什么呢?与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是...
  • 静态成员函数和非静态成员函数的区别? 一个静态成员函数不与任何对象相联系,故不能对非静态成员进行默认访问。 它们的根本区别在于静态成员函数没有this指针,而非静态成员函数有一个指向当前对象的指针this。...
  • 主要介绍了C++中静态成员函数与静态成员变量(static )的相关资料,需要的朋友可以参考下
  • 静态成员函数和非成员函数的区别 从知乎上看到一个问题,看得我怀疑人生,咬牙切齿,如下图: 对于面试官的解释,把我整蒙圈了;于是自己写代码验证如下: #include<iostream> using namespace std; class A...
  • C++中,静态成员函数不能被声明为virtual函数。  例如,下面的程序会编译失败。 #include&lt;iostream&gt; class Test { public: // 编译错误:static成员函数不能声明为virtual virtual static ...
  • C++中静态成员函数

    千次阅读 多人点赞 2019-03-28 09:33:46
    静态成员函数总结: 静态成员函数是类中的特殊的成员函数 静态成员函数没有隐藏的this指针:当调用一个对象的非静态成员函数时,系统会将该对象的起始地址赋值给成员函数的this指针.但是,静态成员函数不属于某个...
  • 下面小编就为大家带来一篇C++静态成员变量和静态成员函数的使用方法总结。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 代码详解了普通成员函数、普通类成员函数和类静态成员函数的使用方法,已测试,可直接使用
  • C++静态成员函数 与数据成员类似,成员函数也可以定义为静态的,在类中声明函数的前面加static就成了静态成员函数。如 static int volume( ); 和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一...
  • 详细地解说了static关键词,以及静态成员变量和静态成员函数
  • 静态成员函数访问非静态成员

    万次阅读 2019-08-12 21:47:52
    有时候我们必须要使用静态成员函数, 比如把静态成员函数的指针传递到别的模块,以实现回调函数的机制,这个时候若不使用普通函数,则必须使用静态成员函数。 这时候我们有可能需要本类的非静态成员,具体做法很...
  • 大家都知道C++中类的成员函数默认都提供了this指针,在非静态成员函数中当你调用函数的时候,编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面,类还具备了静态成员和静态函数,即 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 376,395
精华内容 150,558
关键字:

静态成员函数