CSDN博客

img Apollo_HolyFire

独一无二----静态成员变量

发表于2001/9/10 16:47:00  1340人阅读

分类: 面向对象 C++ 编程思想

独一无二

                                          ----静态成员变量

作者:HolyFire

我们学习C++的时候知道静态变量的特性,他不是临时变量,在编译期间就已经产成。用一个例子就能说明问题。

#include <iostream>

using namespace std;

class A{

public:

        A(){ cout << "Can you see me Now!" << endl; }

        ~A(){ cout << "I'm Go Away!" << endl; }

};

void TestStatic( void )

{

        static A a;

}

void main()

{

        cout << "Program Start!" << endl;

        TestStatic();

        TestStatic();

        TestStatic();

        cout << "Program End!" << endl;

}

结果是:

Program Start!

Can you see me Now!

Program End!

I'm Go Away!

A a只被定义了一次,而且析构是在主程序退出以后才进行的。这说明了什么呢,A avoid TestStatic( void )是同一个实例,他存在于整个程序但是只有在void TestStatic( void )中能访问他。

不相信?那我们来试试看。

#include <iostream>

using namespace std;

class A{

private:

        int count;

public:

        A():count(0){ cout << "Can you see me Now!" << endl; }

        ~A(){ cout << "I'm Go Away!" << endl; }

        void Inc(){ count++; }

        int Count(){ return count; }

};

void TestStatic( void )

{

        static A a;

        a.Inc();

        cout << "count's value is : " << a.Count() << endl;

}

void main()

{

        cout << "Program Start!" << endl;

        TestStatic();

        TestStatic();

        TestStatic();

        cout << "Program End!" << endl;

}

结果是:

Program Start!

Can you see me Now!

count's value is : 1   //初始化count0Inc导致count自加值应该为1

count's value is : 2   //没有初始化,Inc导致count自加值应该为2

count's value is : 3   //没有初始化,Inc导致count自加值应该为3

Program End!

I'm Go Away!

事实说明了一切,那么他是如何实现的呢,C++编译器里,他被创建在一个内存区域里,这块区域不是堆也不是栈,编译器在编译阶段就将他们记住,并为他们做好分配工作,如此一来就可以实现这个特性。

看起来他的作用有些象全局变量,但是我们知道,使用全局变量会整加模块的耦合性,降低代码的通用性,所以静态成员变量的出现为我们编程带来的灵活性。

如何将这个小东西用在我们的面向对象编程中呢。他扮演一个什么样的角色呢,这正是我要说的。

我们知道,类的成员变量表示了一个类的属性,对应着对象的物质特性,他们在类的某个实例创建的时候创建,消亡的时候消亡。但是上面说到,静态变量在编译期间就已经存在了,也就是并不随着实例创建的时候创建,消亡的时候消亡。是这样吗。看事实说话。

#include <iostream>

using namespace std;

class A{

public:

        A() { cout << "A is On!" << endl; }

        ~A() { cout << "A is OFF!" << endl; }

};

class B{

public:

        B() { cout << "B is On!" << endl; }

        ~B() { cout << "B is OFF!" << endl; }

private:

        static A a;

};

A B::a;

void main()

{

        cout << "Program Start!" << endl;

        B b1,b2,b3;

        cout << "Program End!" << endl;

}

结果是:

A is On!  //瞧我又说中了,主程序还没有运行,构造函数就开始工作了,这时B的实例还没有登场

Program Start!

B is On!  //b1创建了,但是b1.a并没有创建

B is On!

B is On!

Program End!

B is OFF!  //B的实例销毁了,但是成员变量a没有销毁

B is OFF!

B is OFF!

A is OFF!  //看吧,这才是A的析构函数

注意一个约定:

A B::a;

静态成员变量的初始化一定要在主函数外面,而且静态成员变量一定要初始化。

事实上B::a并不属于B,将他作为B的成员只是为了确定访问的权限

private:

        static A a;

因为这样设定以后只有B才能访问B::a,当然设计的时候要考虑清楚,如果aB并没有关系,那么这样的设计就没有什么实际的意义。

那么如何设计才能运用这个特性呢。

我们来举个例子。

我们有时候想知道类的实例有几个,也就是被实例化了几次。比如

class A;

A a1,a2,a3;

那么就应该被实例化了3次。能知道这个信息应该很不错。如果用一个全局变量,那么要考虑的问题很多,全局变量会被人任意修改,全局变量定义在那里以及全局变量初始化在那里也会带来困惑,全局变量会不会跟别的全局变量重名等等。

既然静态变量可以实现一些全局变量的功能,何不牛刀小试,看看效果如何。首先静态成员变量只有一个,而且不是类的真实属性,实际上只有一个变量,不会增加类的负担;第二可以给他加上访问限制,只要不是public那么就不能随意修改。既然好处多多,那么就开工。

#include <iostream>

using namespace std;

class A{

public:

       A(){ count++; };  //当产生一个实例的时候计数器加一

    ~A(){ count--; }  //当销毁一个实例的时候计数器减一

       int GetInstanceCount(){ return count; }

private:

       static int count;

};

int A::count = 0;

void main()

{

       cout << "Program Start! " << endl << endl;

       A a1,a2,a3;

       {

              A a4,a5,*pa;

              cout << "Now, Have a1 ,a2 ,a3 , a4 ,a5 Instances!" << endl;

              cout << "Number of class A's Instance is : " << a1.GetInstanceCount() << endl << endl;

              pa = new A;

              cout << "Now Creat a class A's Instance!" << endl;

              cout << "Number of class A's Instance is : " << a2.GetInstanceCount() << endl << endl;

              delete pa;

       }

       cout << "While class's Instances a4 , a5 , pa destroy!" << endl;

       cout << "Only a1 , a2 , a3 Left , is the Count of Instance is 3 ?" << endl;

       cout << "Number of class A's Instance is : " << a3.GetInstanceCount() << endl << endl ;

}

结果是:

Program Start!

Now, Have a1 ,a2 ,a3 , a4 ,a5 Instances!  //a1 ,a2 ,a3 ,a4 ,a5五个实例

Number of class A's Instance is : 5       //没错,正是五个

Now Creat a class A's Instance!        //在堆里创建了一个,使用pa得到他的引用

Number of class A's Instance is : 6      //跟想的一样,数目增加了

While class's Instances a4 , a5 , pa destroy!  //在堆里释放一个,栈里释放2

Only a1 , a2 , a3 Left , is the Count of Instance is 3 ? //6 – 1 –2 当然等于3

Number of class A's Instance is : 3  我说的没错吧。

因为在构造函数里操作的是同一个变量,所以才能得到正确的结果。这个技术在很多方面得到应用,比如,互斥信号,象动态连接库一样的引用计数器等等。

这里要记住的是,类的静态成员变量实际上只有一个,它不随着类的实例的创建/销毁而增加/减少。它不是类的真正成员,并不是类的一部分。

2001/9/7

丁宁 

0 0

相关博文

我的热门文章

img
取 消
img