精华内容
下载资源
问答
  • 数据成员是指在类中定义的不能修改其值的一些数据成员,类似于我们以前学过的常变量,虽然是变量,也有自己的地址,但是一经赋初值,便不能再被修改
  • 类的静态数据成员的实际应用场景之一:用来统计该类对象存在的个数;并且如果在头文件中初始化静态变量将导致obj重复定义的错误,解决办法:将静态成员的初始化放到.cpp文件中
  • 静态数据成员和静态成员函数

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

     

    展开全文
  • c# static 静态数据成员

    2021-01-02 00:54:42
    静态数据成员区别于动态数据成员,静态变量并不是稳定的,只是静态变量在声明的时候不管有没有赋值,都市凭据它的类型分派对应的内存空间,他的可访问性和作用区间与动态变量是一样的 ============================...
  • 静态数据成员静态数据成员函数

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

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


    一、静态数据成员

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

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

    [cpp]  view plain  copy
    1. class Test{  
    2. private:  
    3.     //静态数据成员  
    4.     static int a;  
    5. };  

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

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

    [cpp]  view plain  copy
    1. class Test{  
    2. public:  
    3.     int GetA() const{return a;}  
    4. private:  
    5.     //静态数据成员  
    6.     static int a;  
    7. };  
    8. //int Test::a;如果这样定义不赋予初值则初值为零  
    9. int Test::a = 1;  
    10. #include <iostream>  
    11. int main()  
    12. {  
    13.     Test T;  
    14.     std::cout << T.GetA() << std::endl;  
    15. }  

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

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

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


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

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

    [cpp]  view plain  copy
    1. class Base{  
    2. public:  
    3.     //静态数据成员  
    4.     static int a;  
    5. };  
    6. class Derived : public Base{  
    7.   
    8. };  
    9. //int Test::a;如果这样定义不赋予初值则初值为零  
    10. int Base::a;  
    11. #include <iostream>  
    12. int main()  
    13. {  
    14.     Base B;  
    15.     Derived D;  
    16.     B.a++;  
    17.     std::cout << B.a << std::endl;  
    18.     D.a++;  
    19.     std::cout << D.a << std::endl;  
    20.       
    21. }  

    打印结果如下:


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


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

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

    [cpp]  view plain  copy
    1. class Test{  
    2. public:  
    3.     //静态数据成员  
    4.     static int a;  
    5.     int b;  
    6.     void fun_1(int i = a);//正确  
    7.     void fun_2(int i = b);//报错  
    8. };  


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

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

    [cpp]  view plain  copy
    1. class Test{  
    2. public:  
    3.     //静态数据成员  
    4.     static Test a;//正确  
    5.     Test b;//报错  
    6.     Test *pTest;//正确  
    7.     Test &m_Test;//正确  
    8.     static Test *pStaticObject;//正确  
    9. };  


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

    答:看个例子

    [cpp]  view plain  copy
    1. class Test{  
    2. public:  
    3.     Test():b(0){}  
    4.     //静态数据成员  
    5.     static int a;//正确  
    6.     int b;  
    7.     void test() const  
    8.     {  
    9.         a++;  
    10.         b++;//const指的不能修改当前调用该函数对象的数据成员  
    11.     }  
    12. };  
    13. int Test::a;  

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

    二、静态成员函数

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

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

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

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


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


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

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

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

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

    关于学生类的例子

    [cpp]  view plain  copy
    1. //定义Student类  
    2. #include <iostream>  
    3. class Student                    
    4. {  
    5. public:  
    6. //定义构造函数  
    7. Student(int n,int a,float s):num(n),age(a),score(s){ }        
    8. void total();  
    9. //声明静态成员函数  
    10. static float average();        
    11. private:  
    12.     int num;  
    13.     int age;  
    14.     float score;  
    15.     //静态数据成员,累计学生的总分  
    16.     static float sum;   
    17.     //静态数据成员,累计学生的人数  
    18.     static int count;             
    19. };  
    20. //在全局作用域对静态数据成员初始化,如果不赋予初值,则使用其默认值零  
    21. float Student::sum;                       
    22. int Student::count;  
    23. //定义非静态成员函数  
    24. void Student::total()                      
    25. {  
    26.     //累加总分  
    27.     sum+=score;  
    28.     //累计已统计的人数  
    29.     count++;                                 
    30. }  
    31. //定义静态成员函数  
    32. float  Student::average()                    
    33. {  
    34.     return(sum/count);  
    35. }  
    36. int main()  
    37. {  
    38.     Student stud[3]={      
    39.     //定义对象数组并初始化  
    40.     Student(1001,18,70),  
    41.     Student(1002,19,78),  
    42.     Student(1005,20,98)  
    43. };  
    44. int n;  
    45. std::cout<<"please input the number of students: ";  
    46.  //输入需要求前面多少名学生的平均成绩  
    47. std::cin>>n;                                
    48. //调用3次total函数  
    49. for(int i=0;i<n;i++)  
    50. {  
    51.     stud[i].total();  
    52. }  
    53. //调用静态成员函数  
    54. std::cout<<"the average score of "<<n<<" students is "<<Student::average( )<<std::endl;  
    55. return 0;  
    56. }  

    打印输出如下:


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

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

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

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

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

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

    Student::average。

    原文:http://blog.csdn.net/computer_liuyun/article/details/29235111

    展开全文
  • 当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。静态...
  • 所以全局变量和静态成员变量的功能差不多,只是创建的方式不同,类的静态成员创建在类中,全局变量创建在程序开头. 二.为什么要用类的静态成员而不用全局变量 全局变量在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,因此这是非法的),静态成员函数只能访问属于类的,不能访问具体对象所有的属性,因为静态成员函数不知道是哪一个的.
    静态成员函数只能访问类的静态成员函数.

    在这里插入图片描述

    展开全文
  • 静态数据成员是在一个类中用关键字static声明的数据成员。在C++中,一般使用静态成员来代替C语言的全局变量,以达到数据共享。C和C++的全局变量有一定的局限性,可以任意被修改,也容易和其它的变量名冲突,故在C++...
  • 什么是静态数据成员? 数据成员我们之前学过,是对象的属性。 同一个类,不同的对象,可能拥有不同的属性 例如一个车行,不同的车有不同的颜色,不同的耗油量。。。等等属性 但是当我们统计一个公有的数据,用数据...

    什么是静态数据成员?

    数据成员我们之前学过,是对象的属性。
    同一个类,不同的对象,可能拥有不同的属性

    例如一个车行,不同的车有不同的颜色,不同的耗油量。。。等等属性

    但是当我们统计一个公有的数据,用数据成员有点麻烦
    比如每一辆Car,里面有一个数据成员CarNum,记录了车行的总车数,
    如果每一个对象,都分别带着CarNum这个数据成员,会有些不方便。

    为此,我们需要一个类公有的数据成员,就是静态数据成员
    每个对象与静态数据成员关系如下图
    在这里插入图片描述

    静态数据成员的定义以及初始化

    静态数据成员用关键字 “static” 定义
    如果静态数据成员是public,可以在主函数里面
    用 类名::静态数据成员名 访问

    由于静态数据成员是类公有的,所以不能在构造函数初始化,应该在类定义完成后,对其进行初始化

    定义格式:

    class Car
    {
    public:
    	static int CarNum;
    	Car(){CarNum++;}//新建一个Car对象时候,车数量加一
    	~Car(){CarNum--;}//销毁一个Car对象时候,车数量减一
    };
    int Car::CarNum=0;	//静态成员函数的初始化
    

    什么是静态成员函数?

    上面我们了解了什么是静态数据成员。
    静态成员函数也可以类比,是一个类的共有的成员函数

    定义格式:

    class Car
    {
    public:
    	static int CarNum;
    	Car(){CarNum++;}//新建一个Car对象时候,车数量加一
    	~Car(){CarNum--;}//销毁一个Car对象时候,车数量减一
    	
    	static int getCarNum(){return CarNum;}
    };
    int Car::CarNum=0;	//静态成员函数的初始化
    
    int main()
    {
    	Car::getCarNum();	//静态成员函数调用
    	return0;
    }
    
    几点注意:
    • 由于静态成员函数是共有的,所以参数列表里面没有隐含this指针,不可以用const修饰静态成员函数
    • 静态成员函数只能访问静态数据成员,不可以访问普通的数据成员
    展开全文
  • 静态数据成员函数与子对象,定义一个圆类……………………
  • 静态数据成员与非静态数据成员

    千次阅读 2019-03-26 21:39:45
    静态数据成员   用static来声明静态成员,它是类的一部分,有该类中的所有对象共同使用和维护,实现类中数据的共享(静态区),要受private控制符影响。 非静态数据成员   类的每个实例都有一份拷贝(动态区)。 ...
  • 数据成员:静态数据成员是类的一部分,为类的所有实例共享(静态区); 非静态数据成员,类的每个实例都有一份拷贝(动态区)。静态数据成员的访问:静态数据成员是类的一部分,在产生任何实例之前已经存在,通过 类名...
  • 首先要明白:静态成员函数是可以调用非静态数据成员的,具体怎么调用,看下面。 class A { public: static void fun ( A a ) { cout << b <<endl;(错误) cout <&l...
  • 类的静态数据成员-用来统计对象存在的个数 引用静态数据成员(通过类本身或者通过类对象)的方式对结果没有影响,都等于创建的对象的个数
  • 易语言实现类静态数据成员的方法源码,实现类静态数据成员的方法,方法1,方法2
  • 在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据,那么我们会设立全局对象,但面向对象的程序是由对象构成的,我们如何才能在类范围内共享数据呢? 这个问题便是本章的重点:
  • C++中静态数据成员

    千次阅读 2019-05-01 16:18:59
    类的静态数据成员都有着单一的存储空间,所以存储空间必须定义在一个单一的地方。如果一个静态数据成员被声明而没有被定义,链接器会报告一个错误“定义必须出现在类的外部而且只能定义一次”。因此静态数据成员的...
  • C++静态数据成员的继承

    千次阅读 2019-05-09 13:51:11
    C++静态数据成员的继承基类及其所有子类共用该基类的同一个静态成员变量测试代码:TestStatic.h:main.cpp: 基类及其所有子类共用该基类的同一个静态成员变量 真正理解:静态成员从属于类 测试代码: TestStatic.h...
  • 1.定义静态数据成员后要对静态数据成员进行初始化! 静态数据成员的初始化: <数据类型><类名>::静态数据成员 = <值> 2.静态数据成员往往数私有的,静态数据成员不能直接访问,要通过定义为公有...
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
  • C++ 静态数据成员

    千次阅读 2018-08-21 22:59:45
    类体中的数据成员的声明前加上static关键字,该数据成员就成为了该类的静态数据成员静态数据成员实际上是类域中的全局变量。所以,静态数据成员的定义(初始化)不应该被放在头文件中(而是在相应的cpp文件中)。 ...
  • 静态数据成员的使用方法和注意事项如下: 1、静态数据成员在定义或说明时前面加关键字static。//静态变量的定义 2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下:  <数据类型><...
  • 一、静态变量: 在了解静态变量之前,读者需要知道什么是全局变量和局部变量。局部变量直至定义在函数内部的变量,在函数调用结束后,局部变量将消失。全局变量是指在函数体外定义的变量,它的生命期随着程序的结束...
  • #include<iostream> using namespace std; class cat { public: cat() { numOfCats++; } static int getNumOfCats() { return numOfCats; } ~cat() { numO.
  • 类的静态数据成员

    2017-03-14 12:27:54
    定义类的静态数据成员:既可以在类的内部也可以在类的外部定义静态成员函数。当在类的外部定义静态数据成员时,不能重复static关键字,该关键字只出现在类的内部的声明语句中。 静态数据成员不属于类的任何一个对象...
  • 静态数据成员 1.为什么我们需要使用静态数据成员?  我们知道每一个对象都有自己独有的数据成员的值,那怎么去实现不同对象之间可以去共享数据呢?于是就有了两种的方法:一个是全局变量,但是由于全局变量也...
  • C++类静态数据成员与类静态成员函数当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 398,321
精华内容 159,328
关键字:

静态数据成员