精华内容
下载资源
问答
  •  中的数据成员声明前加上static,则表示该数据成员为静态数据成员。除了与其他数据具有相同的public/private/protect访问属性外,还有一些其他的属性:  1、不能在中进行初始化,只能在外。  因为静态数据...

    一、静态数据成员

           类中的数据成员声明前加上static,则表示该数据成员为静态数据成员。除了与其他数据具有相同的public/private/protect访问属性外,还有一些其他的属性:
           1、不能在类中进行初始化,只能在类外。
              因为静态数据成员为所有类对象公有(包括派生类),不占用类对象的存储空间。若在类中初始化,容易造成对其他对象中该数据成员的影响。
           2、可以直接通过类名来访问:如:base::_staticVar
           3、静态数据成员可以成为成员函数的可选参数,而普通数据成员则不可以。举例如下: 
    class base{ 
    public : 
    static int _staticVar; 
    int _var; 
    void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员 
    void foo2(int i=_var);//错误,_var为普通数据成员 
    }; 
          4、静态数据成员的类型可以是所属类的类型,而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用。举例如下: 
    class base{ 
    public : 
    static base _object1;//正确,静态数据成员 
    base _object2;//错误 
    base *pObject;//正确,指针 
    base &mObject;//正确,引用 
    }; 
         5、静态数据成员的值在const成员函数中可以被合法的改变。举例如下: 
    class base{ 
    public: 
    base(){_i=0;_val=0;} 
    
    mutable int _i; 
    static int _staticVal; 
    int _val; 
    void test() const <span style="font-family: Arial, Helvetica, sans-serif;">//const 成员函数</span>
    <span style="font-family: Arial, Helvetica, sans-serif;">{ </span>
    _i++; //正确,mutable数据成员 
    _staticVal++;//正确,static数据成员 
    _val++;//错误 
    } 
    }; 
    int base::_staticVal=0; 

    二、静态成员函数

        静态成员函数也是在函数的声明前加上static关键词,具有以下特点:
         1、静态数据成员函数不能访问非静态数据成员和非静态成员函数
              因为静态成员函数中不包括this指针,所以不能访问非静态数据成员和非静态成员函数。但是可以通过参数传递一个对象名来实现在静态成员函数中访问非静态数据成员和非静态成员函数。
         2、静态成员函数不可以同时声明为 virtual、const、volatile函数。
    class MyClass
    {
     private:
         int a,b,c;
         static int Sum;
         static MyClass m;
         //MyClass mi;
     public:
         MyClass(int a,int b,int c);
         void GetSum() const;
         //virtual static int list(MyClass&); //错误 
         //static int uu(MyClass&) cosnt;  // 错误
         //static int uu(MyClass&) volatile; //错误 
         
    };

    参考文献:
          1、http://www.cnblogs.com/lzjsky/archive/2011/01/24/1943199.html
          2、http://blog.csdn.net/clc4210408/article/details/6775824

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

    千次阅读 2015-10-10 21:31:27
    各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。静态数据成员的用途之一是统计有...

    一、基本知识

    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。静态方法就是与该类相关的,是类的一种行为,而不是与该类的实例对象相关。

    静态数据成员的用途之一是统计有多少个对象实际存在。

    静态数据成员不能在类中初始化,实际上类定义只是在描述对象的蓝图,在其中指定初值是不允许的。也不能在类的构造函数中初始化该成员,因为静态数据成员为类的各个对象共享,否则每次创建一个类的对象则静态数据成员都要被重新初始化。

    静态成员不可在类体内进行赋值,因为它是被所有该类的对象所共享的。你在一个对象里给它赋值,其他对象里的该成员也会发生变化。为了避免混乱,所以不可在类体内进行赋值。

    静态成员的值对所有的对象是一样的。静态成员可以被初始化,但只能在类体外进行初始化。

    一般形式:

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

    注意:不能用参数初始化表对静态成员初始化。一般系统缺省初始为0。

    静态成员是类所有的对象的共享的成员,而不是某个对象的成员。它在对象中不占用存储空间,这个属性为整个类所共有,不属于任何一个具体对象。所以静态成员不能在类的内部初始化,比如声明一个学生类,其中一个成员为学生总数,则这个变量就应当声明为静态变量,应该根据实际需求来设置成员变量。

    #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;//10
        test::num = 20;//在类体外对静态数据成员再次赋值
        cout<<test::num<<endl;//20
        cout<<test::GetNum()<<endl;//35
        cout<<a.GetNum()<<endl;//50
        return 0;
    }
    

    通过上例可知:

    x+=5;   // 这行代码是错误的
    静态函数成员必须通过对象名来访问非静态数据成员。
    另外,静态成员函数在类外实现时候无须加static关键字,否则是错误的。

    若在类的体外来实现上述的那个静态成员函数,不能加static关键字,这样写就可以了:

      int test::Getnum()
      {
          .........
      }

    1、static成员的所有者是类本身和对象,但是多有对象拥有一样的静态成员。从而在定义对象是不能通过构造函数对其进行初始化。
    2、静态成员不能在类定义里边初始化,只能在class body外初始化。
    3、静态成员仍然遵循public,private,protected访问准则。
    4、静态成员函数没有this指针,它不能返回非静态成员,因为除了对象会调用它外,类本身也可以调用。
    5、静态成员函数可以直接访问该类的静态数据和函数成员,而访问非静态数据成员必须通过参数传递的方式得到一个对象名,然后通过对象名来访问。
    6、设定了静态成员变量,必须要为其赋初值。

    二、静态成员函数访问非静态成员

    类的静态成员(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问;非静态成员(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。

    在一个类的静态成员中去访问其非静态成员之所以会出错,是因为在类的非静态成员不存在的时候类的静态成员就已经存在了,访问一个内存中不存在的东西当然会出错。

    C++会区分两种类型的成员函数:静态成员函数和非静态成员函数。这两者之间的一个重大区别是,静态成员函数不接受隐含的this自变量。所以,它就无法访问自己类的非静态成员。

    例1:

    #include <iostream>
    
    using namespace std;
    class test
    {
    private:
        int x;
        int y;
    public:
        static int GetX()
        {
            //x += 5; //错误,静态成员函数不能调用非静态数据成员,要通过类的对象来调用。
            test *p = new test;// new一个类的对象!!!!
            p->x = 222;//使用类的对象调用非静态数据成员!!!!
            p->func();//使用类的对象调用非静态成员函数!!!!
            return p->x;
            delete p;//使用完后delete!!!!
        }
        void func(){cout<<"func()被静态成员函数调用"<<endl;}
    };
    int main()
    {
        test a;
    
        cout<<a.GetX()<<endl;
    
        return 0;
    }
    

    结果:

    func()被静态成员函数调用
    222
    
    Process returned 0 (0x0)   execution time : 0.212 s
    Press any key to continue.

    例2:

    #include <iostream>
    using namespace std;
    
    class M
    {
    public:
         M(int a) {A = a; B += a;}
         ~M(){}
         static void f1();
    private:
         int A;
         static int B;
    };
    
    void M::f1()
    {
         M m(5); //定义并初始化类对象
         cout<<"A="<<m.A<<endl; //静态成员函数中通过对象来引用非静态成员
         cout<<"B="<<B<<endl;
    }
    int M::B=5; //静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>
    
    int main()
    {
         M::f1(); //静态成员函数调用时不用对象名
         return 0;
    }
    

    结果:

    A=5
    B=10
    
    Process returned 0 (0x0)   execution time : 0.273 s
    Press any key to continue.

    三、访问私有静态成员数据

    如果把静态成员数据设为私有,可以通过公有静态成员函数!!!!!访问。

    #include <iostream>
    
    using namespace std;
    
    class Cat
    {
    public:
        Cat(int age):itsAge(age){HowManyCats++;}
        virtual ~Cat(){HowManyCats--;}
        virtual int getAge(){return itsAge;}
        virtual void setAge(int age){itsAge=age;};
        static int getHowMany()
        {//公有静态成员函数!!!!!!!!
            return HowManyCats;//访问私有静态成员数据!!!!!
        }
    private:
        int itsAge;
        static int HowManyCats;
    };
    int Cat::HowManyCats=0; //对静态成员数据如此赋值
    int main()
    {
        const int maxCats =5;
        Cat *catHouse[maxCats];
    
        for(int i=0; i<maxCats; i++)
            catHouse[i]=new Cat(i);
        for(int i=0; i<maxCats; i++)
        {
            cout<<"there are "<<Cat::getHowMany();//公有静态成员函数!!!
            cout<<" cats left!"<<endl;
            if(!Cat::getHowMany()) break;
            cout<<"delete the cat which is "<<catHouse[i]->getAge()<<" years old."<<endl;
            delete catHouse[i];
            catHouse[i] = 0;
        }
        return 0;
    }

    结果:

    there are 5 cats left!
    delete the cat which is 0 years old.
    there are 4 cats left!
    delete the cat which is 1 years old.
    there are 3 cats left!
    delete the cat which is 2 years old.
    there are 2 cats left!
    delete the cat which is 3 years old.
    there are 1 cats left!
    delete the cat which is 4 years old.
    
    Process returned 0 (0x0)   execution time : 0.409 s
    Press any key to continue.
    展开全文
  • C++ 静态数据成员与静态成员函数

    千次阅读 2017-05-12 14:40:11
    中的数据成员或成员函数定义或声明前以static关键词开头,即构成静态数据成员与静态成员函数。静态数据成员1.静态数据成员的实现class Time { public : void showtime(); private: static int hour; //定义...

    在类中的数据成员或成员函数定义或声明前以static关键词开头,即构成静态数据成员与静态成员函数。

    静态数据成员

    1.静态数据成员的实现

    class Time
    {
    public :
    	void showtime();
    private:
    	static int hour; //定义hour为静态数据成员
    	int minute;
    	int sec;
    };
    

    2.静态数据成员的意义

    C++为什么要进入静态数据成员这个概念,或者它有什么好处。
    静态数据成员可以实现一个类中不同对象的某个数据的值是一样的。比如一个类中包含的数据成员有:班级,姓名,学号,性别。那么对于一个班的几个同学,班级的值一定是一样的。假设每一个学生就是一个对象,那么不同的对象的数据中,班级这个数据就是一样的。
    所以这也就是静态的数据成员的意义,当班级的数据前加上static关键字后,班级被定义为静态数据成员,当这个值改变时,该类实例化出的每一个对象的班级数据全部随之改变。

    3.静态数据成员的特性

    (1)静态数据成员的属性:
    静态数据成员属于类,而不属于某一个对象。

    (2)静态数据成员的初始化:
    静态数据成员在类内定义,而不能在类内完成初始化,直接赋值和利用构造函数初始化都不可以。我是这样理解这个特性的:

    //直接赋值完成初始化
    class Time
    {
    public :
    	void showtime();
    private:
    	static int hour = 0;
    	int minute;
    	int sec;
    };
    

    这个很好理解,这显然是错的,因为只有静态常量才能在类内完成初试化,要改成这样才可以static const int hour = 0;但是如果写成这样,该数据成员将无法改变,显然我们并不希望如此。

    //利用构造函数初始化静态数据成员
    class Time
    {
    public :
    	Time()
    	{
    		hour = 0;
    		minute = 0;
    		sec = 0;
    	}
    	void showtime();
    private:
    	static int hour;
    	int minute;
    	int sec;
    };
    

    利用构造函数初始化静态数据成员,**这也是错的。**我们可以这样理解这件事,在构造函数的博客里提到:类中的构造函数在实例化对象时被系统调用,然后实现对成员数据的赋值工作,显然这些数据成员属于对象。而静态数据成员属于类,不属于任何一个对象。

    那么应该如何完成静态数据成员的初始化:静态数据成员的初始化只能在类体外完成。

    class Time
    {
    public :
    	void showtime();
    private:
    	static  int hour ;
    	int minute;
    	int sec;
    };
     int Time::hour= 10;
    

    **这是正确的方式!!**看着很奇怪有没有!!没有对象,直接用类名引用成员,这也恰恰说明了静态数据成员不属于任何对象,而属于类本身。

    (3)静态数据成员的引用:
    从(2)中已经看到了,可以直接用类名来引用静态数据成员。同时也可以通过对象来引用,这是因为虽然静态数据成员不属于某一个对象而是属于类,但是对象属于类,所有也就可以应用对象来引用静态数据成员。

    4.静态数据成员的应用

    #include <iostream>
    using namespace std;
    
    class Time
    {
    public :
    	Time(int,int);
    	void showtime();
    private:
    	static  int hour ;
    	int minute;
    	int sec;
    };
    Time::Time(int m,int s)
    {
    	minute = m;
    	sec = s;
    }
     int Time::hour= 10;
    void Time::showtime()
    {
    	cout<<"hour:"<<hour<<endl<<"min:"<<minute<<endl<<"sec:"<<sec<<endl;
    }
    int main()
    {
    	Time time1(2,3);
    	time1.showtime();
    	Time time2(4,5);
        time2.showtime();
    	getchar();
    	return 0; 
    }
    

    运行结果:
    hour:10
    minute:2
    sec:3
    hour:10
    minute:4
    sec:5

    可以看到:两个对象的hour成员都是10。

    静态成员函数

    和静态数据成员类似,静态成员函数一样也是在前面加入static关键字。
    1.静态成员函数的实现

    class Time
    {
    public :
    	static void showtimeh();//定义showtimeh()为静态成员函数
    	void showtime();
    private:
    	static int hour; //定义hour为静态数据成员
    	int minute;
    	int sec;
    };
    

    2.静态成员函数的意义

    静态成员函数可以使一切不需要实例化就可以有确定行为方式的函数使用起来更加方便,比如某些通用算法。由于静态成员函数只能访问本类中的静态数据成员,而无法访问非静态数据成员,这样使程序设计更加清晰。

    3.静态数据成员的特性

    (1)静态成员函数的属性:
    静态成员函数属于类,而不属于某一个对象。

    (2)静态成员函数的访问:
    静态成员函数只能访问本类中的静态数据成员
    非静态成员函数可以访问本类中的静态数据成员非静态数据成员
    4.静态数据成员的应用

    #include <iostream>
    using namespace std;
    
    class Time
    {
    public :
    	Time(int,int);
    	static void showtimeh();
    	 void showtime();
    private:
    	static  int hour ;
    	int minute;
    	int sec;
    };
    Time::Time(int m,int s)
    {
    	minute = m;
    	sec = s;
    }
     int Time::hour= 10;
    void Time::showtime()
    {
    	cout<<"hour:"<<hour<<endl<<"min:"<<minute<<endl<<"sec:"<<sec<<endl;
    }
    void Time::showtimeh()
    {
    	cout<<"hour:"<<hour<<endl;
    }
    int main()
    {
    	Time time1(2,3);
    	time1.showtime();
        Time::showtimeh();
    	getchar();
    	return 0; 
    }
    

    运行结果:
    hour:10
    minute:2
    sec:3
    hour:10

    展开全文
  • thinking in c++ 中有处错误,他认为静态数据成员的定义具有内部连接属性,可以放在头文件里面,这是不对的。下面具体说明。关于静态数据成员,他的定义必须在的外部,并且只能有次定义。这定义,...

    thinking in c++ 中有一处错误,他认为类的静态数据成员的定义具有内部连接属性,可以放在头文件里面,这是不对的。下面具体说明。

    关于类的静态数据成员,他的定义必须在类的外部,并且只能有一次定义。这个定义,具有外部连接属性,最好放在类的实现文件里面,不能放在类的头文件里面。

    下面的例子证明这一点。

    3个文件,一个header.h,header.c main.c

    首先是header.h

    #ifndef HEADER_H
    #define HEADER_H

    #include
    <iostream>
    using namespace std;

    class testClass
    {
        
    static int i;
        
    int j;
            
    public:
        testClass();
        testClass(
    int k);
        
    void print(){
            cout
    <<"i="<<i<<" j="<<j<<endl;
            
    return;
        }

    }
    ;
    //int testClass::i=5;
    #endif

     header.c

     

    #include"header.h"
    int testClass::i=5;
    testClass::testClass()
    {
        j
    =0;
    }

    testClass::testClass(
    int k)
    {
        j
    =k;
    }

    main.c

     

    #include"header.h"
    int main()
    {
        testClass A;
        testClass B(
    2);
        A.print();
        B.print();
        
    return 1;
    }

    上面这个例子中,静态变量i的定义,只能放在类的实现文件里面,不能放在头文件里面。否则会出现重定义。

    这说明具有外部连接属性。

    关于静态数据成员,有一类特殊的,那就是const的静态数据成员,

    类似:const static int i=0;

    可以在类的声明中定义。其他的都不可以。

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

    千次阅读 2014-08-05 22:47:10
    各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态数据成员的用途之一是...
  • C++中的静态数据成员的初始化

    千次阅读 2016-05-16 14:49:24
    每个只有一个存储单元,静态数据成员为该的所有对象共有,不属于某个对象。静态数据成员的初始化必须在以外进行定义性说明。 形式为: :: =值 静态成员注意以下几点: 1、静态成员必须初始化,如果其...
  • 3-6 静态数据成员与静态成员函数

    千次阅读 2016-09-20 19:07:06
    3-6 静态数据成员与静态成员函数 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 通过本题目的练习可以掌握静态数据...和一个静态数据成员count ,用以记录系统中创建点对
  • c++ 静态数据成员和静态成员函数

    千次阅读 2011-05-19 11:13:00
    静态数据成员不同于非静态的数据成员,一个类静态数据成员仅创建和初始化一次,且在程序开始执行的时候创建,然后被该的所有对象共享;而非静态的数据成员则随着对象的创建而多次创建和初始化。下面是静态数据...
  • 静态数据成员内只能声明,定义和初始化必须在外 可以这样 class a { int aa; static int aaa; //静态数据成员声明 }; int a::aaa=10; //静态数据成员的定义和初始化
  • 个静态数据成员total(总分)和count(学生人数)。成员函数scoretotalcount(float s)用于设置每学生的分数;静态成员函数sum()用于返回总分;静态成员函数average()用于求分数平均值。在main函数中,输入...
  • C++静态数据成员MAP如何初始化

    千次阅读 2017-08-24 09:55:00
    在写C++时博主遇到如何对静态...我们可以在中写一个静态成员函数用于对map初始化。 CGuitarSpec.hclass GuitarSpec//吉他的部分属性 { public: string GetColor(); int SetColor(Color); string GetType()
  • 各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少的对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态成员变量不能在中...
  • #include&lt;iostream&gt;using namespace std;class Dog{private: static int Dogs;public: static getDogs(); Dog() {Dogs++;}}; int Dog::getDogs() {return Dogs;} int Dog::Dogs=0;...
  • 如果某个属性为整个类所共有,不属于任何一个具体对象,则采用static关键字来声明为静态数据成员,例如:银行账户的利率 静态数据成员中只有一个拷贝,不占用对象的存储空间,由该的所有对象共同维护和使用 3....
  • 根据成员内部的定义: 首先生成外部的实例... //对于final修饰的成员变量,说明该变量是只读变量,只能进行次赋值操作,只能存在以下两种赋值情况,在这两地方我们必须给它们赋初值。 //1)声明该成员变量...
  • 在声明一个类时使用static关键字,具有两个方面的意义:首先,它防止程序员写代码来实例化该静态类;其次,它防止在的内部声明任何实例字段或方法。 静态类是自C# 2.0才引入的,C# 1.0不支持静态类声明。程序员...
  • 一个成员变量被声明为static类型时,该成员变量就是静态变量,属于的所有实例。也就是说静态变量是的所有该实例的全局变量。   静态成员变量的初始化,与其他变量的初始化很不一样,静态成员...
  • 各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态数据成员的用途之一是...
  • 、C#静态和实例概念 静态概念:公共的、全局的、不属于个别实例的定义。 实例概念:new 出来的具体单个对象。随着作用域定义,使用,销毁(多数实例,通过垃圾回收机制自动销毁)。 静态 实例 关键字...
  • 静态成员成员常量 静态字段: 被所有实例共享,所有实例都访问同一内存位置。被一个实例改变,所有实例可见。 可使用 .字段名 直接访问。 静态函数: 类似于静态字段,没有的...
  • 我们知道,当调用一个对象的成员函数(非静态成员函数)时,系统会把当前对象的起始地址赋给 this 指针。而静态成员函数并不属于某一对象,它与任何对象都无关,因此静态成员函数没有 this 指针。既然它没有指向某一...
  • (1)静态数据成员在每个中只有一个拷贝,由所有该的对象共同维护,从而实现同一个类的不同对象数据共享;一般数据成 员,是实例属性,每个对象拥有一个拷贝。 (2)静态数据成员只能通过类名和静态函数成员对...
  • 不允许 dllimport 静态数据成员

    万次阅读 2014-10-07 17:28:52
    不允许 dllimport 静态数据成员 View Code 当要使用一个类的时候必须要有其定义,有2种方式: 1、引用其头文件,即#include "xxx.h"。这是传统的方式。 2、使用导出。 什么是‘导出’,很...
  • C++对象的生存周期和静态成员

    千次阅读 2018-01-04 19:22:50
    对象的生存周期 静态生存周期:全局变量具有静态生存周,局部变量的...第一,静态数据成员一个类的所有对象公有的属性 静态成员在每个中只有一个副本,由该的所有对象共同维护和使用,从而实现了同一的不同
  • 对于普通的实例类属性,每一个类实例的每一个变量都有自己的copy(单独的内存空间),相互独立。但是有时会要求一个类的所有实例都共享变量的一个版本,也就是说所有实例都共享同一个copy,该变量对所有实例都是可见...
  • 静态类静态成员 总结

    千次阅读 2012-08-26 16:37:41
    的成员  从级别来分,的成员包括静态成员和动态成员。静态成员是级别,不属于的实例,而... 从功能来分,的成员包括字段、属性、方法、索引器、构造函数等,其中字段属于数据成员,方法属于函数成员。
  • 1、什么是静态类和非静态类 (1)、静态类的建立上加上static关键词 比如我们在看C#视频中使用的File,就是静态类。...比如在FileStream,定义这个类的时候,如下示 public class FileStream : St...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,904
精华内容 83,561
关键字:

一个类的静态数据成员所表示属性