asm, c, c++ are my all
-- Core In Computer
posts - 139,  comments - 123,  trackbacks - 0

[转]静态成员数据和静态成员函数

在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据,那么我们会设立全局对象,但面向对象的程序是由对象构成的,我们如何才能在类范围内共享数据呢?

  这个问题便是本章的重点:

  声明为static的类成员或者成员函数便能在类的范围内共同享,我们把这样的成员称做静态成员和静态成员函数。
  下面我们用几个实例来说明这个问题,类的成员需要保护,通常情况下为了不违背类的封装特性,我们是把类成员设置为protected(保护状态)的,但是我们为了简化代码,使要说明的问题更为直观,更容易理解,我们在此处都设置为public。

  以下程序我们来做一个模拟访问的例子,在程序中,每建立一个对象我们设置的类静态成员变自动加一,代码如下:

#include <iostream>
using namespace std;

class Internet
{
public:
    Internet(char *name,char *address)
    {
        strcpy(Internet::name,name);
        strcpy(Internet::address,address);
        count++;
    }
    static void Internet::Sc()//静态成员函数
    {
        cout<<count<<endl;
    }
    Internet &Rq();
public:
    char name[20];
    char address[20];
    static int count;//这里如果写成static int count=0;就是错误的
};

Internet& Internet::Rq()//返回引用的成员函数
{
    return *this;
}

int Internet::count = 0;//静态成员的初始化
void vist()
{
    Internet a1("中国软件开发实验室","
www.cndev-lab.com ");
    Internet a2("中国软件开发实验室","
www.cndev-lab.com ");
}
void fn(Internet &s)
{
    cout<<s.Rq().count;
}
void main()
{
    cout<<Internet::count<<endl;//静态成员值的输出
    vist();
    Internet::Sc();//静态成员函数的调用
    Internet b("中国软件","
www.cnsoft.com ");
    Internet::Sc();
    fn(b);
    cin.get();
}

  上面代码我们用了几种常用的方式建立对象,当建立新对象并调用其构造函数的时候,静态成员cout便运行加1操作,静态成员的初始化应该在主函数调用之前,并且不能在类的声明中出现,通过运行过程的观察我们发现,静态成员count的状态并不会随着一个新的对象的新建而重新定义,尽而我们了解到类的静态成员是属于类的而不是属于哪一个对象的,所以静态成员的使用应该是类名称加域区分符加成员名称的,在上面的代码中就是Internet::count,虽然我们仍然可以使用对象名加点操作符号加成员名称的方式使用,但是不推荐的,静态态类成员的特性就是属于类而不专属于某一个对象。

  静态成员函数的特性类似于静态成员的使用,同样与对象无关,调用方法为类名称加域区分符加成员函数名称,在上面的代码中就是Internet::Sc();,静态成员函数由于与对象无关系,所以在其中是不能对类的普通成员进行直接操作的。

  如果上面的 static void Internet::Sc()修改成为:


static void Internet::Sc()//静态成员函数
{
    cout<<name<<endl;//错误
    cout<<count<<endl;
}

  静态成员函数与普通成员函数的差别就在于缺少this指针,没有这个this指针自然也就无从知道name是哪一个对象的成员了。

  根据类静态成员的特性我们可以简单归纳出几点,静态成员的使用范围:

  1.用来保存对象的个数。

  2.作为一个标记,标记一些动作是否发生,比如:文件的打开状态,打印机的使用状态,等等。

  3.存储链表的第一个或者最后一个成员的内存地址。

  为了做一些必要的练习,深入的掌握静态对象的存在的意义,我们以前面的结构体的教程为基础,用类的方式描述一个线性链表,用于存储若干学生的姓名,代码如下:

#include <iostream>
using namespace std;

class Student
{
public:
    Student (char *name);
    ~Student();
public:
    char name[30];
    Student *next;
    static Student *point;
};

Student::Student (char *name)
{
    strcpy(Student::name,name);
    this->next=point;
    point=this;
}

Student::~Student ()//析构过程就是节点的脱离过程
{
    cout<<"析构:"<<name<<endl;

    if(point==this)
    {
        point=this->next;
        cin.get();
        return;
    }
    for(Student *ps=point;ps;ps=ps->next)
    {
        if(ps->next==this)
        {
        cout<<ps->next<<"|"<<this->next<<endl;
        ps->next=next;//=next也可以写成this->next;
        cin.get();
        return;
        }
    }
    cin.get();
}

Student* Student::point=NULL;
void main()
{
    Student *c = new Student("marry");
    Student a("colin");
    Student b("jamesji");
    delete c;
    Student *fp=Student::point;
    while(fp!=NULL)
    {
        cout<<fp->name<<endl;
        fp=fp->next;
    }
    cin.get();
}

  从上面的代码来看,原来单纯结构化编程需要的一个链表进入全局指针在这里被类的静态成员指针所替代(类的静态成员完全可以替代全局变量),这个例子的理解重点主要是要注意观察类成员的析构顺序,通过对析构顺序的理解,使用析构函数来进行节点的脱链操作。

静态成员的提出是为了解决数据共享的问题。实现共享有许多方法,如:设置全局性的变量或对象是一种方法。但是,全局变量或对象是有局限性的。这一章里,我们主要讲述类的静态成员来实现数据的共享。

  静态数据成员

  在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个对象的成员。

  使用静态数据成员可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。

  静态数据成员的使用方法和注意事项如下:

  1、静态数据成员在定义或说明时前面加关键字static。

  2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下:

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

  这表明:

        (1) 初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆。

  (2) 初始化时不加该成员的访问权限控制符private,public等。

  (3) 初始化时使用作用域运算符来标明它所属类,因此,静态数据成员是类的成员,而不是对象的成员。

  3、静态数据成员是静态存储的,它是静态生存期,必须对它进行初始化。

  4、引用静态数据成员时,采用如下格式:

   <类名>::<静态成员名>

  如果静态数据成员的访问权限允许的话(即public的成员),可在程序中,按上述格式来引用静态数据成员。

  下面举一例子,说明静态数据成员的应用:

#include
class Myclass
{
public:
Myclass(int a, int b, int c);
void GetNumber();
void GetSum();
private:
int A, B, C;
static int Sum;
};

int Myclass::Sum = 0;

Myclass::Myclass(int a, int b, int c)
{
A = a;
B = b;
C = c;
Sum += A+B+C;
}

void Myclass::GetNumber()
{
cout<<"Number="< }

void Myclass::GetSum()
{
cout<<"Sum="< }

void main()
{
Myclass M(3, 7, 10),N(14, 9, 11);
M.GetNumber();
N.GetNumber();
M.GetSum();
N.GetSum();
}


  从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时,将M对象的三个int型数据成员的值求和后赋给了Sum,于是Sum保存了该值。在初始化N对象时,对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上,于是Sum将保存另后的值。所以,不论是通过对象M还是通过对象N来引用的值都是一样的,即为54。
静态成员函数

  静态成员函数和静态数据成员一样,它们都属于类的静态成员,它们都不是对象成员。因此,对静态成员的引用不需要用对象名。

  在静态成员函数的实现中不能直接引用类中说明的非静态成员,可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时,可通过对象来引用。下面通过例子来说明这一点。

#include
class M
{
public:
M(int a) { A=a; B+=a;}
static void f1(M m);
private:
int A;
static int B;
};

void M::f1(M m)
{
cout<<"A="< cout<<"B="< }

int M::B=0;
void main()
{
M P(5),Q(10);
M::f1(P); file://调用时不用对象名
M::f1(Q);
}

  读者可以自行分析其结果。从中可看出,调用静态成员函数使用如下格式:
   <类名>::<静态成员函数名>(<参数表>);

posted on 2006-07-31 02:54 Jerry Cat 阅读(265) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理



<2006年7月>
2526272829301
2345678
9101112131415
16171819202122
23242526272829
303112345

常用链接

留言簿(7)

随笔档案

最新随笔

搜索

  •  

最新评论

阅读排行榜

评论排行榜