精华内容
下载资源
问答
  • 静态成员

    千次阅读 2017-12-11 19:51:15
    可以定义类的静态成员,能够实现同类的多个对象之间数据共享。使用类的静态成员的优点是: ①静态成员的名字是在类的作用域中,因此可以避免与其他类的成员或全局对象名字冲突; ②静态成员可以实施封装,可以是...

    1.静态数据成员
    可以定义类的静态成员,能够实现同类的多个对象之间数据共享。使用类的静态成员的优点是:
    ①静态成员的名字是在类的作用域中,因此可以避免与其他类的成员或全局对象名字冲突;
    ②静态成员可以实施封装,可以是私有成员,而全局对象不可以。
    ③静态成员是与特定类关联的,结构清晰。
    静态数据成员是类的一种特殊数据成员,它以关键字static开始,
    声明形式为:

    class 类名{//类体
    
    static 数据成员类型 数据成员名列表;//静态数据成员的声明
    };

    例如:

    class Data{
    public:
    static int count ;//静态数据成员
    int maxlevel;//非静态公有成员
    Data(int i=0){
    count++;
    } //构造函数 
    private :
    int level;//非静态私有数据成员 
    };// count设计的目的是计数Data类总共有多少个实例化对象。
    int Data::count=0;//静态数据成员定义并初始化 

    关于静态数据成员的说明:
    (1)通常,非静态数据成员存在于类类型的每个对象中,静态数据成员则独立于该类的任何对象,在所有对象之外单独开辟空间存储。在为对象所分配的空间中不包括静态数据成员所占的空间。
    (2)如果只声明了类而未定义对象,则类的非静态数据成员是不占存储空间的,只有在定义对象时,才为对象的数据成员分配空间。但是只要在类中定义了静态数据成员,即使不定义任何对象,也为静态数据成员分配空间,它可以在尚未建立对象时就被引用。
    (3)访问静态成员时同样需要遵守公有及私有访问规则。
    4)静态数据成员必须在类外部定义一次(仅有一次),静态成员不能通过类构造函数进行初始化,而是在类外定义时进行初始化。定义静态数据成员的方式为:
    数据成员类型 类名::静态数据成员名=初值;
    (5)静态数据成员可用作默认实参,非静态数据成员不能用作默认实参,因为它的值不能独立于所属的对象而使用。
    (6)有了静态数据成员,各对象之间实现了数据共享,因此可以
    不使用全局变量。
    举例:

    #include<iostream>
    using namespace std;
    class test{
        private:
            int x;
            int y;
        public:
            static int num;
            static int Getnum()
            {
                //x+=5;//错误,静态成员函数不能调用非静态数据成员
                num+=15;
                return num; 
            }
    };
    int test::num=10;
    int main(){
        test a;
        cout<<test::num<<endl;//输出
        test::num=20;
        cout<<test::num<<endl;//输出20
        cout<<test::Getnum()<<endl;//输出35
        cout<<a.Getnum()<<endl;//输出50
        return 0; 
    }

    2.静态成员函数
    成员函数也可以定义为静态的,在类中声明函数的前面加static就成了静态成员函数,声明的一般形式为:

    class 类名{
        ...
        static 返回类型 函数名(类型1 参数名1,类型2 参数名2) {
            return count;//静态成员函数 
        }
    };

    例如:static int getcount(){
    return count;//静态成员函数
    }

    和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分。如果要在类外调用公有的静态成员函数,可以类作用域运算符(::)和通过对象名调用静态成员函数,不能通过类名来调用类的非静态成员函数。例如:

     cout<<Data::getcount()<<"\t"<<d.getcount(); 

    静态成员函数与非静态成员函数的根本区别是:非静态成员函数有this指针,而静态成员函数没有this指针。因此,静态成员函数不能访问本类中的非静态成员。静态成员函数就是专门为了访问静态数据成员的。
    静态成员函数不能被声明为const。

    #include<iostream>
    using namespace std;
    class CTest{
        public:
            CTest(){
                s_total++;
                id=s_total;
                cout<<"构造"<<id<<" "; 
            }
            ~CTest(){
                s_total--;
                cout<<"析构"<<id<<" ";
            } 
            static int gettotal(){
                return s_total;
            }
            private:
                static int s_total;
                int id; 
    };
    int CTest::s_total=0;
    int main(){
        CTest a,b,c;
        CTest *p=new CTest;
        cout<<"合计"<<CTest::gettotal()<<"  ";
        delete p;
        cout<<"合计"<<CTest::gettotal()<<"";
        return 0; 
    } 
    class Test {
        public:
            void init(){}
                static void output(){
                }
    };
    int main(){
        Test::init();//编译出错,因为不能通过类名来调用类的非静态成员 init 
        Test::output();
    }
    class Test{
        public:
            void init(){}
                static void output(){
                }
    };
    int main(){
        Test t;
        t.init();
        t.output();
        return 0;
    }//编译通过,类的对象可以使用静态成员函数和非静态成员函数
    class Test{
        public:
        void init(){}
            static void output(){
                cout<<x<<endl;
            }
        private:
            int x;
    };
    int main(){
        Test t;
        t.output();
        return 0; 
    } //编译出错,因为静态成员函数不能使用非静态成员
    class Test{
        public:
            void init(){
                output();
             }
             static void output(){
             }
     }; 
     int main(){
        Test y;
        y.output();//编译可以通过,类的静态成员函数可以被非静态成员函数调用, 
        return 0;
     }
    class Test{
        public:
            Test(){m++;
             }
             ~Test(){m--;
             }
             static void output(){
                cout<<m<<endl;
             }
             private: 
             static int m;
    }; 
    //链接错误,因为类的静态数据成员在使用前必须先初始化。
    //int  Test::m=0; 
    int main(){
        Test t;
        t.output();
        return 0;
    }
    展开全文
  • 静态数据成员和静态成员函数

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

     

    展开全文
  • 声明静态成员 使用类的静态成员 定义静态成员 静态成员的类内初始化 静态成员能用于某些场景,而普通函数不能

    静态成员

    即定义出一些成员与类本身直接相关,而不是与类的各个对象保持关联。

    1,声明静态成员

    在成员的声明之前加上关键字static使得其与类关联在一起

    class Test
    {
    public:
        Test(int a) :a(a){}
        void add()
        {
            b++;
        }
        static void show()      //静态成员函数
        {
            cout << b << endl;;
        }
    private:
        int a;
        static int b;      //静态成员
    };

    2,使用类的静态成员

    • 使用作用域直接访问
    • 用类的对象访问
    • 用类的指针访问

        Test x, *y=&x;
        x.show();         //类对象
        y->show();             //类指针
        Test::show();             //作用域

    3,定义静态成员

    因为静态成员不属于类的任何一个对象,所以它并不是在创建类的对象时被定义的。这意味着它们并不是由类的构造函数初始化的。而且,一般来说不能在类内初始化静态成员。相反只能在外部定义和初始化每个静态成员。

    4,静态成员的类内初始化

    通常情况下,不能类内初始化,但是可以为静态成员提供const整数类型的类内初始值。不过要求静态成员必须是字面值常量类型的constexpr。

        constexpr static double rate = 6.5;     //如果不是const int类型则需要加上constexpr来声明是常量表达式
        static const int vecSize = 20;

    5,静态成员能用于某些场景,而普通函数不能

    因为静态成员独立于任何对象。因此某些非静态数据成员可能非法的场合,静态成员却可以正常使用。

    class Test1
    {
    private:
        static Test1 a;      //静态成员可以是不完全类型
        Test1 *b;          //指针可以是不完全类型
        //Test1 c;       错误,数据成员必须是完全类型   
    }

    静态成员函数

    可以通过类名加范围解析运算符 :: 的方式访问,。

    静态成员函数特点:只能访问静态成员数据其他静态成员函数类外部的其他函数

    因为静态成员函数也是属于类,并不是属于某一个对象,所以其中不包含 this 指针。因此不能访问非静态数据成员

    静态成员函数与普通成员函数的区别:

    • 静态成员函数没有 this 指针,只能访问静态成员(包括静态成员变量和静态成员函数)。
    • 普通成员函数有 this 指针,可以访问类中的任意成员;而静态成员函数没有 this 指针。
    #include<iostream>
    using namespace std;
    
    class Test
    {
    public:
    	Test(int a) :a(a){ b++; }
    	void show1()
    	{
    		cout << a << "    " << b << endl;
    	}
    	static void show2()
    	{
    		//cout << a << endl;     不能访问类的非静态成员
    		cout << b << endl;
    	}
    private:
    	int a;
    	static int b;
    };
    int Test::b = 0;
    
    int main()
    {
    	Test x(10);
    	x.show1();
    	Test y(20);
    	x.show1();
    	system("pause");
    	return 0;
    }

    运行结果:

    10    1
    10    2

    a是非静态成员,所以属于对象x自己,所以当新定义y对象后,x的a值仍然不变:

    b是静态成员,属于类,所以只要b变,则所有对象访问b的时候,值都会发生变化;

    展开全文
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是属于对象的,也就是说,在类实例化为对象之前,静态成员变量和静态成员函数就已经分配了内存空间了,而普通成员函数和成员变量只有在...

    C++的静态成员变量和静态成员函数

    静态成员变量和静态成员函数算是C++面向对象编程中的一个重点和难点,这里的静态具体指什么呢?与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是属于对象的,也就是说,在类实例化为对象之前,静态成员变量和静态成员函数就已经分配了内存空间了,而普通成员函数和成员变量只有在对象产生之后才会分配空间。下面我们来详细看看他们的用法

    (一)静态成员变量

    1.在类中声明静态数据成员只要加上static关键字即可:

    class A{
    private:
    	static int a;
    	//这样a就是类A的静态成员变量了
    };
    

    特别注意:在使用静态成员变量之前一定要初始化。初始化静态成员变量,必须在全局作用域中定义,如果定义的时候不给出初值,则默认初值为0。当然,静态成员变量在类中只能声明而不能定义的。

    2.静态成员变量不属于任何对象,静态成员变量是由类的所有对象共享的

    静态成员变量只存储一份供所有对象共用,所以在所有对象中都可以共享它的值,使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则,保证了安全性还可以节省内存。
    下面我们来看一个小例子:

    class A {
    public:
    	static int a;
    };
    int A::a = 0;
    
    int main() {
    	A temp0;
    	temp0.a = 5;
    	A temp1;
    	cout << temp0.a << endl;
    	cout << temp1.a << endl;
    }
    

    很显然输出结果是两个5,这也很容易说明静态成员变量是所有对象共享的,他的值在这个类中的任何一个对象中都相同。

    3.静态成员变量在const函数中可以修改

    class A {
    public:
    	static int a;
    	int b;
    	void changea(int i) const {
    		this->a = i;
    	}
    	/*void changeb(int j) const {
    		this->b = j;
    	}*/
    	//很显然,这段被注释的代码会报错
    };
    int A::a;
    
    int main() {
    	A temp0;
    	temp0.changea(6);
    }
    

    cosnt函数的作用是保护调用这个const函数的对象(即this指针指向的对象)的所有普通成员变量,使其不能被修改,但是静态成员变量不属于任何对象,所以可以修改。

    (二)静态成员函数

    静态成员函数的声明很简单,只要在类的成员函数前加上static关键字即可,静态成员函数也是属于类的,它并不属于任何对象。静态成员函数中是不能访问本类中的非静态成员变量的,所以在c++中,静态成员函数的主要功能就是访问静态成员变量。当然,非静态成员函数也可以访问静态成员变量。

    下面我们来看一个例子:

    class A {
    public:
    	static int a;
    	int b;
    	static void showa(){
    		cout << a << endl;
    	}
    	/*static void showb() {
    		cout << b << endl;
    	}*/
    	//这段被注释的代码会报错
    };
    int A::a = 9;
    
    int main() {
    	A temp0;
    	temp0.showa();
    }
    

    很明显我们可以看出静态成员函数无法访问非静态成员变量。

    下面列出使用静态成员函数的几个注意点:

    1.静态成员函数不能调用非静态成员函数,但是非静态成员函数可以调用静态成员函数
    2.静态成员函数没有this指针,也就是说静态成员函数不能使用const修饰符
    3.静态成员函数的地址可用普通函数指针储存,而普通成员函数地址需要用类成员函数指针来储存。

    静态成员函数的一个优点是可以在任何类的实例被创建之前调用它们,这使得它们可以用来执行复杂的初始化任务,这些任务必须在创建类的对象之前完成。

    总结一下:其实不论是静态成员变量还是静态成员函数,它们都是不依赖于对象而存在的。
    对于非静态成员变量和非静态成员函数,类在定义之后并不为他们分配存储空间,而是在定义类的对象的时候才分配存储空间。相反,静态的成员变量和静态的成员函数在定义类时已经在内存中开辟了内存空间,所以静态成员变量可以被独立的访问(在任何对象没有建立起来时都可以访问),并且静态成员函数不可以调用非静态成员函数,因为非静态成员函数只有在类对象建立以后才可以调用。

    2019年5月22日

    展开全文
  • 静态成员函数访问非静态成员

    万次阅读 2019-08-12 21:47:52
    有时候我们必须要使用静态成员函数, 比如把静态成员函数的指针传递到别的模块,以实现回调函数的机制,这个时候若不使用普通函数,则必须使用静态成员函数。 这时候我们有可能需要本类的非静态成员,具体做法很...
  • C++静态成员变量与静态成员函数

    千次阅读 多人点赞 2019-05-26 20:06:48
    类的静态成员有两种:静态成员变量和静态成员函数,语法是在普通成员变量和成员函数前加static关键字。 0、定义 class CRectangle{ public: void show();//普通成员函数 static void printTotal();//静态成员...
  • 在多人开发的项目中,一些通用的工具类接口可以用静态成员函数。方便调用,并且不容易调用错误。静态成员函数不传递this指针(不能-&gt;),不识别对象个体,所以经常用于对静态数据成员进行操作。不能操作非静态...
  • 静态成员方法:也称类方法,一般表示类的共通方法,跟对象无关。 静态成员变量:也称类变量,一般表示类的共通属性,跟对象无关,初始化在对象初始化之前,被多个对象共用。 静态块:一般用来初始化静态成员变量和...
  • C++中类的(static)静态成员变量与(static)静态成员函数

    万次阅读 多人点赞 2018-08-04 11:27:28
    而在C++的类中,也有静态成员变量同时还有静态成员函数,先来看看C++中静态成员变量与静态成员函数的语法: #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class ...
  • C++ 类的静态成员静态成员函数 ...  只要在类中声明静态成员变量,即使不定义对象,也可以为静态成员变量分配空间,进而可以使用静态成员变量。(因为静态成员变量在对象创建之前就已经被...
  • C++静态成员和非静态成员的区别

    千次阅读 2018-07-20 15:43:14
    可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.静态...
  • 静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员 静态成员分为: 静态成员变量 所有对象共享同一份数据 在编译阶段分配内存 类内声明,类外初始化 静态成员函数 所有对象共享同一个函数 ...
  • 类中的静态成员变量、静态成员函数? (1)类中的静态成员变量: 静态成员变量属于整个类,不属于某个特定的对象,因此无论创建了多少个对象,所有对象都共享类中的静态成员变量。静态成员变量必须在类内声明,类...
  • 原来... C++中静态成员函数访问非静态成员变量   C++中静态成员函数访问非静态成员变量   先看一个class class a { public:  static Fun
  • C++ 静态成员变量与静态成员函数

    千次阅读 2017-11-06 11:33:08
    一、静态成员变量1)定义静态成员变量 关键字 static 可以用于说明一个类的成员,静态成员提供了一个同类对象的共享机制  把一个类的成员说明为 static 时,这个类无论有多少个对象被创建,这些对象共享这个 ...
  • C++中的类静态成员静态成员函数

    千次阅读 2014-07-28 12:55:19
    静态成员
  • C++静态成员变量和静态成员函数

    千次阅读 2015-11-29 20:28:41
    C++静态成员变量和静态成员函数 数据成员可以分静态变量、非静态变量两种.  静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态...
  • /*静态成员(静态成员变量、静态成员函数)与正常成员间相互调用的访问权限问题: 静态成员不专属于某个对象,而是属于该类的所有对象,所有对象都可对其进行相关的操作;静态成员函数则只能使用静态的成员变量或成员...
  • c++ 静态成员变量用static 关键字来声明,是整个类的数据成员,其存储不占用某个具体对象的空间,其存储在静态存储区。 c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用...
  • 可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员. ...
  • 静态成员函数与类内静态变量相似,属于类,但是独立于对象存在,是共有的。而非静态成员函数属于类,依赖于对象。 静态成员函数没有存在对象的时候,是无法访问到依赖对象的非静态成员函数的,也不存在this指针。 ...
  • (1)加上static就是静态成员,不加就是非静态成员。 (2)在一个类中,既可以有静态成员,也可以有非静态资源。 (3)在调用实例成员时,需要使用对象名(实例).实例中的成员。 (4)在调用静态成员的时候,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,113
精华内容 21,645
关键字:

静态成员