精华内容
下载资源
问答
  • C++静态数据成员引用
    千次阅读
    2017-03-04 22:51:24

    静态数据成员可以初始化,但只能在类体外进行初始化
    如:
    Int Box::height=10;
    不能够使用参数初始化列表对静态数据成员进行初始化。

    #include <iostream>
    
    using namespace std;
    
    class Box{
    public:
        Box(int,int);
        int volume();
        static int height;
        int width;
        int length;
    
    
    };
    Box::Box(int w , int len) {   //静态数据成员height必须在类外进行初始化
    
        width=w;
        length=len;
    
    }
    int Box::volume() {
        return(height*width*length);
    }
    int Box::height=10;     //对对象的静态数据成员进行初始化,并且对象的静态数据成员初始化,必须在类的外部进行初始化
    
    int main()
    {
        Box a(15,20),b(20,30);
        cout<<a.height<<endl;    //通过对象a引用静态数据成员
        cout<<b.height<<endl;     //通过对象b引用静态数据成员
        cout<<Box::height<<endl;     //通过类名引用静态数据成员,这个时候,要加上数据的作用域,即同一类型的作用域
        cout<<a.volume()<<endl;   //调用volume函数,计算体积,输出结果。
    
        return 0;
    }
    
    

    静态成员函数

    **#include <iostream>
    
    using namespace std;
    class Student{
    public:
        Student(int n,int a,int 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;
    
    
    };
    void Student::total() {               //对非静态成员函数进行初始化
        sum+=score;
        count++;
    }
    float Student::average() {                 //对静态成员函数进行初始化
        return (sum/count);
    }
    
    float Student::sum=0;
    int Student::count=0;
    
    
    
    int main()
    {
        Student stud[3]={
                Student(1001,18,70),
                Student(1002,19,78),
                Student(1005,20,98)
        };
       int n;
        cout<<"please input the number of students:";
        cin>>n;
        for(int i=0;i<n;i++)
        {
            stud[i].total();
        }
        cout<<"The average score of"<<n<<"student is"<<Student::average()<<endl;
        return 0;
    }
    
    **

    /home/andrew/文档/Clion/untitled5/cmake-build-debug/untitled5
    please input the number of students:3
    The average score of3student is82

    Process finished with exit code 0

    更多相关内容
  • 类的静态数据成员-用来统计对象存在的个数 引用静态数据成员(通过类本身或者通过类对象)的方式对结果没有影响,都等于创建的对象的个数
  • 下面小编就为大家带来一篇C++静态成员函数不能调用非静态成员变量(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 静态数据成员和静态成员函数

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

     

    展开全文
  • 静态成员函数只能访问静态数据成员、静态成员函数和类以外的函数和数据,不能访问非静态数据成员,但静态成员函数或静态数据成员可由任意访问许可的函数访问。原因是:当前对象的地址(this)是被隐含地传递到被调用...
  • 静态数据成员必须进行初始化,初始化应在类体外进行,静态数据成员也可以引用,但不能引用私有数据部分。 接下来看一个例子: #include #include using namespace std ; class Student { private : //静态成员...
  • 静态成员函数访问非静态数据成员【C++】

    千次阅读 多人点赞 2021-05-11 10:33:56
    详解:由于静态数据成员属于本类的所有对象共享,不属于特定类对象,因此在未产生类对象作用域就可见,即:在未产生类的实例,就可以对它进行操作。 初始化: 类型 类名 :: 静态数据成员 = 初始化值 ; 详解:...

    静态数据成员

    定义格式:

    static 类型名 静态数据成员名 ;

    详解:由于静态数据成员属于本类的所有对象共享,不属于特定类对象,因此在未产生类对象时作用域就可见,即:在未产生类的实例时,就可以对它进行操作。

    初始化:

    类型 类名 :: 静态数据成员 = 初始化值 ;

    详解:静态数据成员必须在类外初始化,不可在类体内,因为:构造函数中,如果可以,则每次建立对象,都会对静态数据成员的值进行修改,这违背静态数据成员的使用目的;类内也不可以初始化,不要忘记,类只是一种数据类型,数据类型中怎么能赋初值呢?

    静态成员函数

    定义格式:

    static 返回类型 静态成员函数名 (参数表) ;

    调用方式:

    类名 :: 静态成员函数名 (实参表) ;
    对象名 . 静态成员函数名 (实参表) ;

    注意:

    类外定义静态成员函数时,定义格式和普通成员函数定义格式相同,不再使用static修饰
    使用对象名和成员运算符(.)调用成员函数时,并非该函数属于某一对象,只是类与对象间的桥梁,为了能处理静态数据成员;

    静态成员函数不能默认引用本类非静态数据成员的原因:

    当调用一个对象的非静态成员函数时,系统会将该对象的起始地址赋予成员函数的this指针。然而,静态成员函数不属于对象,无this指针。所以静态成员函数不能访问类的默认非静态成员(非静态成员函数和非静态数据成员)。

    举例说明一种静态成员函数访问非静态数据成员的方式:

    #include <iostream>
    using namespace std;
    
    class Point {
    public:
    	Point(int a) {                      //构造函数
    		x = a;
    		y += x; 
    	}
    	static void f1(Point m);           //静态成员函数的原型声明
    private:
    	int x;
    	static int y;                      //静态数据成员
    };
    
    void Point::f1(Point m) {              //静态成员函数的类外定义      参数表中创建对象
    	cout << "x=" << m.x << endl;       //静态成员函数通过对象访问非静态数据成员
    	cout << "y=" << y << endl;         //静态成员函数处理静态数据成员
    }
    
    int Point::y = 0;                      //静态数据成员初始化
    
    int main() {
    	Point P1(5), p2(10);
    	Point::f1(P1);                     //静态成员函数调用时一般使用 类名::
    	Point::f1(p2);
    	return 0;
    }
    

    程序运行结果:

    x=5
    y=15
    x=10
    y=15
    

    对运行结果的分析,最后一次对静态数据成员y更新后,y=15所以两次输出y的值都是15。

    只要对静态数据成员的值更新一次,就可以保证所有对象都会存取更新后的值

    由本例可知:静态成员函数不能引用本类非静态成员并非绝对,只是不可以进行默认的访问,因为编译器不知道应该去寻找哪一个对象。若必须要访问,则有两种方式,且一般使用第二种居多。

    对象名 . 非静态成员 ;
    类名 :: 非静态成员 ;

    故:实例化对象即可完成对非静态数据成员的访问

    展开全文
  • 类的静态数据成员

    2020-06-09 09:41:17
    类的静态数据成员 如果想在同类的多个对象之间实现数据共享,可以用静态的数据成员,类的静态数据成员的安全性比全局变量的安全性要高。 //Human.h class Human { public: ...... int getCount(); private: ........

    类的静态数据成员

    如果想在同类的多个对象之间实现数据共享,可以用静态的数据成员,类的静态数据成员的安全性比全局变量的安全性要高。

    //Human.h
    class Human {
    public:
    	......
    	int getCount();
    private:
    	......
    
    	// 类的静态成员
    	static int count;
    };
    

    对于非const的类静态成员,只能在类的实现文件中初始化。
    同时,类的普通成员函数,可以直接访问非const静态数据成员(可读可写)

    #include "Human.h"	
    
    // 初始化类的静态成员
    int Human::count = 0;
    ......
    Human::Human() {
        ......
    	count++;
    }
    
    // 类的普通成员函数,可以直接访问静态成员(可读可写)
    int Human::getCount() {
    	return count;
    }
    

    const类静态成员,可以在类内设置初始值,也可以在类的实现文件中设置初始值。(但是不要同时在这两个地方初始化,只能初始化1次)

    //Human.h
    class Human {
    public:
    	......
    	int getCount();
    private:
    	......
    
    	// 类的静态成员
    	static const int count = 0;
    };
    

    在类的实现文件中设置初始值

    #include "Human.h"	
    
    // 初始化类的静态成员
    const int Human::count = 0;
    ......
    Human::Human() {
        ......
    	count++;
    }
    
    // 类的普通成员函数,可以直接访问静态成员(可读可写)
    int Human::getCount() {
    	return count;
    }
    

    关于静态数据成员的几点说明:
    1.静态数据成员不属于某一个对象,在为对象所分配的空间中不包括静态数据成员所占的空间。静态数据成员是在所有对象之外单独开辟空间。只要在类中定义了静态数据成员,即使不定义对象,也为静态数据成员分配空间,它可以被引用。

    2.静态数据成员不随对象的建立而分配空间,也不随对象的撤销而释放(一般数据成员是在对象建立时分配空间,在对象撤销时释放)。静态数据成员是在程序编译时被分配空间的,到程序结束时才释放空间。

    3 不能用参数初始化表对静态数据成员初始化。如在定义Box类中这样定义构造函数是错误的:
    Box(int h,int w,int len):height(h){ } //错误,height是静态数据成员
    如果未对静态数据成员赋初值,则编译系统会自动赋予初值0。

    4.静态数据成员既可以通过对象名引用,也可以通过类名来引用。
    cout<<a.height<<endl; //通过对象名a引用静态数据成员
    cout<<b.height<<endl; //通过对象名b引用静态数据成员
    cout<<Box::height<<endl; //通过类名引用静态数据成员
    请注意:程序中将height定义为公用的静态数据成员,所以在类外可以直接引用。可以看到在类外可以通过对象名引用公用的静态数据成员,也可以通过类名引用静态数据成员。即使没有定义类对象,也可以通过类名引用静态数据成员。这说明静态数据成员并不是属于对象的,而是属于类的,但类的对象可以引用它。

    5.如果静态数据成员被定义为私有的,则不能在类外直接引用,而必须通过公用的成员函数引用。

    展开全文
  • 数据成员:静态数据成员是类的一部分,为类的所有实例共享(静态区); 非静态数据成员,类的每个实例都有一份拷贝(动态区)。静态数据成员的访问:静态数据成员是类的一部分,在产生任何实例之前已经存在,通过 类名...
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
  • C++基础题

    千次阅读 2019-12-25 22:40:10
    1.关于类定义格式的描述中,( )是错的。 A. 一般类的定义格式分为说明部分和实现部分 ...2.下列关键字中,( )不是类中定义数据成员使用的关键字。 A. static B. float C. extern D. double 3.( )不...
  • 静态数据成员静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • 1 静态数据成员不能用参数初始化表对静态数据成员初始化 (1) 如果声明了类而未定义对象,则类的一般数据成员是不...只要在类中指定了静态数据成员,即使不定义对象,也为静态数据成员分配空间,它可以被引用。 (2)
  • 首先要明白:静态成员函数是可以调用非静态数据成员的,具体怎么调用,看下面。 class A { public: static void fun ( A a ) { cout << b <<endl;(错误) cout <&l...
  • 一般情况下,如果有n个同类的对象,那么每一个对象都分别有自己的数据成员,不同对象的数据成员各自有值,互不相干。但是有时人们希望有某一个或几个数据成员为所有对象所共有,这样可以实现数据共享。   可以使用...
  • C++ 静态数据成员与静态成员函数

    千次阅读 2017-05-12 14:40:11
    在类中的数据成员或成员函数定义或声明前以static关键词开头,即构成静态数据成员与静态成员函数。静态数据成员1.静态数据成员的实现class Time { public : void showtime(); private: static int hour; //定义...
  • 题目要求: 商店销售某一商品,商店每天公布统一的折扣(discount)。同时允许销售人员在销售灵活掌握售价(price),在此基础上,对一次购 10 件以上者,还可以享受 9.8 折...要求用静态数据成员和静态成员函数。
  • C++ 静态数据成员

    千次阅读 2018-08-21 22:59:45
    类体中的数据成员的声明前加上static关键字,该数据成员就成为了该类的静态数据成员静态数据成员实际上是类域中的全局变量。所以,静态数据成员的定义(初始化)不应该被放在头文件中(而是在相应的cpp文件中)。 ...
  • c++的静态数据成员初始化方法

    千次阅读 2020-03-18 14:51:35
    类的静态成员变量初始化...1、静态数据成员在定义或说明前面加关键字static。//静态变量的定义 2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下:  <数据类型><类名>::&l...
  • C++静态成员函数和静态数据成员

    千次阅读 2014-08-05 22:47:10
    当将类的某个数据成员声明为static,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。静态...
  • 定义字符型静态数据成员ServerName,保存其服务器名称;整型静态数据成员ClientNum,记录已定义的客户数量;定义静态函数ChangeServerName()改变服务器名称。 #include using namespace std; class Client { ...
  • C++:未定义引用静态成员?

    千次阅读 2019-08-24 14:33:54
    因此,类的静态成员需要类内声明,类外定义。并且注意定义尽量不要出现在头文件中,以免造成重复定义。 #include #include using namespace std; class Foo { public: static const int MEMBER = 1; }; ...
  • 静态成员

    2022-03-13 11:37:57
    静态数据成员和静态成员函数 静态成员的作用: 1.静态成员不属于某一个对象,而属于一个类(属于所有对象),无论建立多少个对象,都共享静态成员——是连接各个对象的桥梁。 2.静态数据成员主要用于各个对象共用数据...
  • 类的静态成员 采用static关键字来声明静态成员,... 用法:类名::标识符 对于静态数据成员,必须在文件作用域内采用类名限定对静态数据成员定 对于静态函数成员与静态数据成员一样用static关键字声明 ,属于整个...
  • 网上总结的C++静态成员数据,我自己又重新总结了一下 一、结合实例进行说明 1. 静态成员数据变量的定义及应用 1)要在成员数据的定义之前加关键字static 2)静态成员数据必须有确定的值,但由于在类的定义中不...
  • 为啥静态函数只能调用静态成员

    千次阅读 2020-06-25 23:04:54
    首先得知道为什么要使用静态数据成员: 在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个...
  • 创建一个QT的dll工程,生成lib、dll文件后,新建一个测试工程,将动态库的头文件、lib文件加入到该工程里,通过头文件引用dll的导出类. 编译测试工程报错: 1>GeneratedFiles\Release\moc_TestDll.cpp(58): ...
  • 静态数据成员定义

    千次阅读 2017-09-11 09:13:52
    其实这句话“静态成员变量是需要初始化的”是有一定问题的,应该说“静态成员变量需要定义”才是准确的,而不是初始化。两者的区别在于:初始化是赋一个初始值,而定义是分配内存。静态成员变量在类中仅仅是声明,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 263,664
精华内容 105,465
关键字:

引用静态数据成员时