C++ 类中的静态变量和静态成员函数（转）

静态数据成员：

下面看一个例子：
 #include <iostream.h>
class Point
{
public:
void output()
{
}
static void init()
{ 
}
};
void main( void )
{
Point pt;
pt.init();
pt.output();
}
这样编译是不会有任何错误的。

下面这样看
#include <iostream.h>
class Point
{
public:
void output()
{ 
}
static void init()
{ 
}
};
void main( void )
{
Point::output();
}
这样编译会处错，错误信息：illegal call of non-static member function，为什么？
因为在没有实例化一个类的具体对象时，类是没有被分配内存空间的。

好的再看看下面的例子:
#include <iostream.h>
class Point
{
public:
void output()
{ 
}
static void init()
{ 
}
};
void main( void )
{
Point::init();
}
这时编译就不会有错误，因为在类的定义时，它静态数据和成员函数就有了它的内存区，它不属于类的任何一个具体对象。

好的再看看下面的例子:
#include <iostream.h>
class Point
{
public:
void output()
{ 
}
static void init()
{
   x = 0;
   y = 0;
}
private:
int x;
int y;
};
void main( void )
{
Point::init();
}
编译出错：
illegal reference to data member 'Point::x' in a static member function
illegal reference to data member 'Point::y' in a static member function
在一个静态成员函数里错误的引用了数据成员，
还是那个问题，静态成员（函数），不属于任何一个具体的对象，那么在类的具体对象声明之前就已经有了内存区，
而现在非静态数据成员还没有分配内存空间，那么这里调用就错误了，就好像没有声明一个变量却提前使用它一样。
也就是说在静态成员函数中不能引用非静态的成员变量。

好的再看看下面的例子:
#include <iostream.h>
class Point
{
public:
void output()
{
   x = 0;
   y = 0;
   init(); 
}
static void init()
{

}
private:
int x;
int y;
};
void main( void )
{
Point::init();
}
好的，这样就不会有任何错误。这最终还是一个内存模型的问题，
任何变量在内存中有了自己的空间后，在其他地方才能被调用，否则就会出错。

好的再看看下面的例子:
#include <iostream.h>
class Point
{
public:
void output()
{
}
static void init()
{
   x = 0;
   y = 0;
}
private:
static int x;
static int y;
};
void main( void )
{
Point::init();
}
编译：
Linking...
test.obj : error LNK2001: unresolved external symbol "private: static int Point::y" (?y@Point@@0HA)
test.obj : error LNK2001: unresolved external symbol "private: static int Point::x" (?x@Point@@0HA)
Debug/Test.exe : fatal error LNK1120: 2 unresolved externals
执行 link.exe 时出错.
可以看到编译没有错误，连接错误，这又是为什么呢？
这是因为静态的成员变量要进行初始化，可以这样：
#include <iostream.h>
class Point
{
public:
void output()
{
}
static void init()
{
   x = 0;
   y = 0;
}
private:
static int x;
static int y;
};
int Point::x = 0;
int Point::y = 0;
void main( void )
{
Point::init();
}
在静态成员数据变量初始化之后就不会出现编译错误了。

再看看下面的代码：
#include <iostream.h>
class Point
{
public:
void output()
{
}
static void init()
{
   x = 0;
   y = 0;
}
private:
static int x;
static int y;
};
void main( void )
{
}
编译没有错误，为什么？
即使他们没有初始化，因为我们没有访问x，y，所以编译不会出错。

后记————今天在增加模块checkemailaddr.c and checkemailaddr.h 文件的时候出现的编译连接错误。

static初始化的方法就是

int Point::x = 0;
int Point::y = 0;

link问题还没搞太清楚 在h文件里面定义static 而在cpp文件当中 初始化。

为什么在h文件当中初始化有问题。？ 如果在哪初始化 没问题。类声明之后？？

C++静态数据成员(static member)—静态成员的初始化不应该在头文件中，静态数据成员被类的所有对象共享、包括派生类的对象，在类中可以声明所属类自己的静态数据成员对象、不可以定义非静态数据成员对象，  

2011-03-08 10:24:27|  分类：C/C++程序设计_基 |字号 订阅

最终总结出静态数据成员的特点有::

          1、静态数据成员仅仅在初始化时，不受访问权限的约束；

          2、静态数据成员最好不要在.h文件中进行声明，而是放在.o文件中声明；

          3、静态数据成员被类的所有对象所共享，包括类的派生类的所有对象；——即派生类和基类共享一个静态成员。

          4、静态数据成员的类型可是所属类自己，即在一个类中可以声明该类自己的类型的静态成员对象，但是，不可以定义普通的成员对象，(指针可以)

          5、在const成员函数中，可以修改static成员变量的值。普通成员变量的值，是不能修改的。

          6、static成员函数只能访问static成员，不能访问非static成员，并且static成员函数不能定义为const函数。

详解 

    类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。

        和其他数据成员一样，静态数据成员也遵守public/protected/private访问规则。注意::仅仅是初始化时不遵守public/protected/private的规则

        同时，静态数据成员还具有以下特点：

 

1、静态数据成员的定义(初始化)不能在头文件中。 
     静态数据成员实际上是类域中的全局变量。所以，静态数据成员的定义(初始化)不应该被放在头文件中。 
    其定义方式与全局变量相同。举例如下：
xxx.h文件
class base{
       private:
       static const int _i;           //声明，标准c++支持有序类型在类体中初始化,但vc6不支持。
};

xxx.cpp文件
const int base::_i=10;     //定义(初始化)时不受private和protected访问限制.

           注：不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。

 

 

2、静态数据成员  被 类 的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。举例如下：
class base{
       public : 
       static int _num;         //声明
};
int base::_num=0;           //静态数据成员的真正定义

class derived:public base{
};

main()
{
      base a; 
      derived b;
      a._num++; 
      cout<<"base class static data number _num is"<<a._num<<endl;
      b._num++;
      cout<<"derived class static data number _num is"<<b._num<<endl;
}
// 结果为1,2;可见派生类与基类共用一个静态数据成员。

 

3、静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为所属类类型的 指针或引用。举例如下：

class base{
        public :
               static base _object1;                       //正确，静态数据成员
               base _object2;                                  //错误
               base *pObject;                                  //正确，指针 
                base &mObject;                              //正确，引用 （这个正确吗？？？？？）
};

 

 

4、静态数据成员的值在const成员函数中可以被合法的改变，而不破那个数据成员的值，不能在const成员函数中改变。

#include <iostream>
using namespace std;

class Student
{
 private:
  static int a;
  int b;
 public:
  void change() const;
  void setB(int b);
  int getB();
  static int getA();
};

void Student::change() const
{
          a++;          //这个可以，因为a是static成员变量。
          b++;          //不可以，因为是const函数
}
int Student::getA()
{
         return a;
}
void Student::setB(int b)
{
 this->b = b;
}
int Student::getB()
{
 return b;
}
int Student::a = 5;

int main(int argc,char *argv[])
{
 Student stu;
 stu.setB(10);
 stu.change();
 cout<<Student::getA()<<endl; 
 cout<<stu.getB()<<endl;
 return 0;