精华内容
下载资源
问答
  • c++之静态数据成员静态成员函数
    千次阅读
    2020-05-11 09:28:20

    什么是静态数据成员?

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

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

    但是当我们统计一个公有的数据,用数据成员有点麻烦
    比如每一辆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修饰静态成员函数
    • 静态成员函数只能访问静态数据成员,不可以访问普通的数据成员
    更多相关内容
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
    **************************C++中的static的用法********************************
    *******************************************************************************
    C++primer里面讲过:static成员它不像普通的数据成员,static数据成员独立于该类的任意对象而存在,每个static数据成员是与类关联的对象,并不与该类的对象相关联!这句话可能比较拗口,其实可以这么理解:每个static数据成员可以看成是类的一个对象,而不与该类定义的对象有任何关系!下面我们就来具体看看类中的static数据成员!
    一、static变量 修饰数据成员
    1、static变量 ( 修饰数据成员) 的例子: 
    #include<iostream>
    #include<string>
    using namespace std;
    
    class Person
    {
    private:
            string name;
            static int age;  //static数据成员age
    public:
            Person(const string &nm):name(nm){};
            void Print();
    };
    int Person::age = 20; //对static数据成员进行初始化
    
    void Person::Print(){
            cout<<name<<" is "<<age<<endl;
    }
    
    int main(int argc,char **argv)
    {
            Person person("tom");
            person.Print();
            Person person2("nike");
            person2.Print();
            person.Print();
            return 0;
    }
    
    解释一哈:
         对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论是这个类的对象被定义了多少个,静态数据成员在程序中也只有一份拷贝,由改类型的所有对象共享访问。也就是说,静态数据成员是该类的所有对象所共有的。对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员的值对每个对象都是一样的,他的值可以更新。
    对C++中静态数据成员的了解:
        静态数据成员初始化格式:<数据类型><类名>::<静态数据成员名>=<值>
       存储:static数据成员是存储在程序的静态存储区,并不是在栈空间上的。(一般程序的由new产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。
        初始化:在类中不能对static数据成员进行初始化,要初始化的话必须在类外进行定义! static数据成员不是通过类构造函数进行初始化的!如上面的代码所示:在类外定义int Persion::age = 20;这里前面就不加static 了。
        如何访问static数据成员:我们可以通过作用域操作符从类直接调用static数据成员;或者通过对象;或者通过引用;或者指向改类类型对象的指针间接调用(这种情况下static数据成员是public的访问权限,如果定义在private访问权限下是不行的)。
        注意:如果类中有多个static数据成员,static数据成员初始化的次序是按照static数据成员在类中的声明次序进行初始化的,初始化后,就可以使用static数据成员了。

        总结:在类中的static成员变量属于整个类所拥有,对类的所有对象只有一份拷贝。

    2、const static数据成员 的例子: 

    像上面说的,类的static成员,智能在类的定义体外进行初始化。const int 类型的static成员便可以在类定义体内部进行初始化。记住,一定只能是const int型的,换成const string ,double都不行的。

    #include<iostream>
    #include<string>
    using namespace std;
    class Person
    {
    private:
            string name;
            static const int age = 20;//在类的定义体内进行初始化
            static string address;
    public:
            Person(const string&nm):name(nm){}
            static string Address()
            {
                    return address;
            }
            void Print()
            {
                    cout<<name<<" is "<<age;
            }
    };
    string Person::address = "XiangGang"; //在类的定义体外进行初始化
    
    int main()
    {
            Person person("tom");
            person.Print();
            cout<<" and live in "<<person.Address();
            cout<<endl;
            return 0;
    }
    

    解释一哈:

        只有age才能在类定义体内进行初始化,address是不行的。

    3、****** 的例子: 

        static数据成员的类型可以是该成员所属的类的类型,非static数据成员被限定为其自生类的指针或引用。

    class Person
    {
    private:
            string name;
            static const int age = 20;//在类的定义体内进行初始化
            static string address;
            static Person person1;
            Person *person2;
            Person person3;
    public:
            Person(const string&nm):name(nm){}
            static string Address()
            {
                    return address;
            }
            void Print()
            {
                    cout<<name<<" is "<<age;
            }
    };
    

    解释一哈:

        如果没有定义person3,则能顺利通过编译,但是加上person3就不能通过编译了。


    二、static变量 修饰成员函数: 

    #include<iostream>
    using namespace std;
    class Myclass
    {
    public:
            Myclass(int a,int b,int c);
            static void GetSum();//声明静态成员函数
    private:
            int a,b,c;
            static int Sum;//声明静态数据成员
    };
    int Myclass::Sum = 0;//定义并初始化静态数据成员
    
    Myclass::Myclass(int a,int b,int c)
    {
            this->a = a;
            this->b = b;
            this->c = c;
            Sum += a+b+c;//非静态成员函数可以访问静态数据成员
    }
    
    void Myclass::GetSum() //静态成员函数的实现
    {
    //      cout<<a<<endl; //error a是非静态数据成员        
            cout<<"Sum = "<<Sum<<endl;
    }
    
    int main()
    {
            Myclass M(1,2,3);
            M.GetSum();
            Myclass N(4,5,6);
            N.GetSum();
            Myclass::GetSum();
    }
    

    解释一哈:

        非静态成员函数可以访问,静态数据成员与普通数据成员;静态成员函数只能访问,静态数据成员,不能访问非静态数据成员。

          说完了static成员后,我们再来看看static成员函数,static成员是类的组成部分并不是任何对象的组成部分,因此,static成员函数没有this指针。我们知道,一般而言,类中的成员函数具有一个附加的隐含实参,即指向该类对象的一个指针。这个隐含实参命名为this。因为static成员函数不是任何对象的组成部分,所以static成员函数就没有this形参了。由于成员函数声明为const说明该成员函数不会修改该成员函数所属的对象,所以static成员函数不能声明为const。为什么呢?因为static成员函数不是任何对象的组成部分。static成员函数可以直接访问所属类的static成员,但是不能直接使用非static成员函数!也不能访问static const 类型的成员!在上面的代码中static  string Address()函数中如果是return name或者是return age都不行! 

     注意:

         *出现在类体外的函数是不能指定关键字static的;

         *静态成员之间可以相互访问,  包括静态成员函数访问静态数据成员和访问静态成员函数;

          *非静态成员函数可以任意访问静态成员函数和静态数据成员;

          *静态成员函数不能访问非静态成员函数和非经验数据成员;

          *因为没有this指针的额外开销,因此静态成员函数与类的全局函数相比速度会有少许的增长;

          *调用静态成员函数,可以用成员访问操作符(.)(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以直接使用如下格式:
    <类名>::<静态成员函数名>(<参数表>)
    调用类的静态成员函数。

        总结:在类中的static成员函数属于整个类所拥有,这个函数不接受this指针,因而只能访问类的static成员变量。


    参考的网址:

       1》C++类中的static数据成员、static成员函数:https://www.cnblogs.com/yyxt/p/4802688.html

       2》C++中static的完全解析:https://blog.csdn.net/jsjwql/article/details/1788286

    展开全文
  • 静态数据成员静态成员函数

    万次阅读 多人点赞 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修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员...
  • PHP静态成员变量

    2021-01-20 00:58:47
    静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员...
  • 有关const成员、static成员、const static成员的初始化:1、const成员:只能在构造函数后的初始化列表中初始化(C++98); (C++11提供了类内初始化,因此内类常量可在声明类时进行类内初始化,因此该类内常量的作用...

    有关const成员、static成员、const static成员的初始化:

    1、const成员:只能在构造函数后的初始化列表中初始化(C++98);

       (C++11提供了类内初始化,因此内类常量可在声明类时进行类内初始化,因此该类内常量的作用域属于类级,即该类的所有对象均具有同一个值。)

    #include <iostream>
    using namespace std;
    class A {
    public:
    	A(int j) :m_j(j) {}
    private:
    	const int m_i = 6;
    	const int m_j;
    };
    int main()
    {
    	system("pause");
    	return 0;
    }

    const作为类成员为什么只能在初始化列表中被初始化呢?

    构造函数创建对象时,对象在执行构造函数函数体前(即大括号之前)被创建(即分配存储空间)。因此,调用构造函数将为对象的成员变量分配内存。然后程序流程进入到构造函数函数体(大括号中的代码),使用常规的赋值方式对成员变量进行赋值。因此,对于const数据成员,必须在执行到构造函数体之前,即创建对象(即为const变量分配内存时),进行初始化。因此,const成员不能通过普通的构造函数来初始化。

    2、static成员:初始化在类外,且不能加static修饰

    #include <iostream>
    using namespace std;
    class A {
    private:
    	//static int m_i = 5;错误
    	static int m_i;
    };
    int A::m_i = 5;
    int main()
    {
    	system("pause");
    	return 0;
    }

    3、const static成员:类只有唯一一份拷贝,且数值不能改变。因此,可以在类中声明处初始化,也可以像static在类外初始化

    #include <iostream>
    using namespace std;
    class A {
    private:
    	static const int m_i;
    	int k[m_i];//错误,编译期间无法获得m_i的值
    };
    const int A::m_i =6 ;
    int main()
    {
    	system("pause");
    	return 0;
    }

    #include <iostream>
    using namespace std;
    class A {
    private:
    	static const int m_i = 5;
    	int k[m_i];
    };
    const int A::m_i;
    int main()
    {
    	system("pause");
    	return 0;
    }

    如果要取static const 成员变量地址,则必须对其变量进”类外定义“(该定义不指定值,容易误解为声明),因为编译器要求,如果要对内类const进行取地址,必须提供定义式。而且注意:VS2015等编译期对此做了优化,可以不按上述说法,但是在g++中,需按上述说法严格执行

    #include <iostream>
    class A {
            public:
                    static const int m_i=5;
    };
    //const int A::m_i;
    
    int main()
    {
            A a;
            std::cout << &(a.m_i) << std::endl;
            return 0;
    }

    #include <iostream>
    class A {
            public:
                    static const int m_i=5;
    };
    const int A::m_i;
    
    int main()
    {
            A a;
            std::cout << &(a.m_i) << std::endl;
            return 0;
    }

    4.C++中普通成员变量可以在类内初始化吗?

    在g++中是不支持的,会提出警告,实验如下:
    #include <iostream>
    class A {
            public:
                    int i=6;
    };
    int main()
    {
            return 0;
    }

    但是在C++11标准允许在类定义时初始化数据成员,所以VS2015不会提出警告

    #include <iostream>
    using namespace std;
    class A {
    private:
    	const int m_i;
    };
    
    int main()
    {
    	system("pause");
    	return 0;
    }

    展开全文
  • 静态成员函数访问非静态数据成员静态数据成员静态成员函数 静态数据成员 定义格式: static 类型名 静态数据成员名 ; 详解:由于静态数据成员属于本类的所有对象共享,不属于特定类对象,因此在未产生类对象时作用...
  • -静态成员函数和静态数据成员,定义时,不需要加static修饰符,否则会报错:"Cannotdeclarememberfunction...tohavestaticlinkage"; -public方法访问static成员;static方法只能访问static成员; -在pubic方法中...
  • 静态数据成员静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • 2、静态成员变量 3、静态常成员变量(基本数据类型) 4、静态常成员变量(自定义数据类型) 二、常成员变量 C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式: const int c; int const c...
  • 1、静态数据成员 用static关键字修饰,在类中声明之后还需要在类外进行定义。 //头文件 class CharRange { private: static int temp; //类中声明 } //源文件 #include <iostream> using namespace std; #...
  • 2、static成员:初始化在类外,且不加static修饰 3、const static成员:类只有唯一一份拷贝,且数值不能改变。因此,可以在类中声明处初始化,也可以像static在类外初始化 示例:   #include using st
  • Java之静态成员

    千次阅读 2018-12-29 16:12:34
    静态成员最主要的特点是它不属于任何一个类的对象,它不保存在任意一个对象的内存空间中,而是保存在类的公共区域中,所以任何一个对象都可以直接访问该类的静态成员,都能获得相同的数据值,修改时,也在类的公共.....
  • (1)Static关键字作用修饰符 可以修饰成员成员属性 成员方法)(2)Static修饰成员的特点a 生命周期长 跟类相同b 用Static修饰的变量 所有对象共享c Static修饰变量 可以通过对象(.)点的形式调用 还可以通过类名...
  • const修饰数据成员,必须在构造函数的初始化列表中初始化 ● const修饰类的成员函数,实际修饰隐含的this指针,表示在类中不可以对类的任何成员进行修改 ● 在const修饰的成员函数中要对类的某个数据成员进行...
  • 类的静态成员

    千次阅读 2018-01-30 21:35:17
    由static关键字修饰的类成员(数据成员和成员函数)叫做静态成员静态成员不是对象的一部分,而是类的一部分,这是静态成员和普通成员之间最本质的区别。 声明静态成员  通过在成员的声明之前加上关键字static...
  • 程序员面试秘笈一书中 169页刚说可以用private隐藏信息 ,又在173就说private 控制不了静态数据成员。 那么到底能不能控制? 我的答案是:可以隐藏信息(禁止获取或修改),但是控制不了(还可以初始化) 1、private...
  • 静态成员变量属于类,而不是属于某个具体的对象,某个类创建了多个对象,这个静态成员变量也只有一份数据, 属于类,多个对象共享它 静态成员变量使用前要进行初始化操作,初始化操作只能在类外进行。 类型 类名:...
  • 3-6 静态数据成员静态成员函数

    千次阅读 2016-09-20 19:07:06
    3-6 静态数据成员静态成员函数 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 通过本题目的练习可以掌握静态数据成员静态成员函数的用法 要求设计一个点类Point,它...
  • 根据成员内部类的定义: 首先生成外部类的实例... //对于final修饰成员变量,说明该变量是只读变量,只能进行一次赋值操作,只能存在以下两种赋值情况,在这两个地方我们必须给它们赋初值。 //1)声明该成员变量...
  • 被static修饰的成员变量和成员方法独立于该类的任何对象。 被类所有的实例所共享。...声明为static关键词修饰的变量叫做静态成员变量,也叫全局变量。 静态成员变量的访问方式: (1)直接通过类...
  • 静态成员静态成员函数

    千次阅读 2017-07-24 15:52:50
    一、静态成员的特点:(1)static数据成员在类的内部声明,但只能在类的外部定义,在类的外部不能指定static,在类的定义时候进行初始化; (2)static数据成员只能在类的外部进行初始化(特例:当整型const static...
  • 静态成员:静态类中的成员加入static修饰符,即是静态成员,可以使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态成员,因为静态成员...
  • 静态成员的特性

    2019-05-16 21:59:44
    无论在c#或者java中,成员变量是不可缺少的一部分,它有静态和非静态成员变量...这里写了主要方法,第一个是通过非静态成员变量去赋值和取值,笫二个是通过静态成员变量去赋值和取值,两者都是通过for循环去添加数据...
  • 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或类以外的类型   静态全局变量 定义:在全局变量...
  • 网上总结的C++静态成员数据,我自己又重新总结了一下 一、结合实例进行说明 1. 静态成员数据变量的定义及应用 1)要在成员数据的定义之前加关键字static 2)静态成员数据必须有确定的值,但由于在类的定义中不...
  • 静态成员静态成员函数的总结

    千次阅读 2018-12-20 23:01:01
    一、静态成员的特点: (1)static数据成员在类的内部声明,但只能在类的外部定义,在类的外部不能指定static,在类的定义时候进行初始化; (2)static数据成员只能在类的外部进行初始化(特例:当整型const ...
  • 在正常情况下一个static修饰静态成员函数是无法对非静态成员变量进行访问与操作的 : #include &amp;lt;iostream&amp;gt; using namespace std; class Date { public : Date(int y = 1998, int m = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 164,563
精华内容 65,825
关键字:

修饰的数据成员是静态成员