class Test{
public:
    Test():a(0){}
    enum {size1=100,size2=200};
private:
    const int a;//只能在构造函数初始化列表中初始化
    static int b;//在类的实现文件中定义并初始化
    conststatic int c;//与 static const int c;相同。
};
 
int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。
cosnt intTest::c=0;//注意：给静态成员变量赋值时，不需要加static修饰符，但要加cosnt。

class foo{
public:
    foo():i(100){}
private:
    const int i=100;//error!!!
};
//或者通过这样的方式来进行初始化
foo::foo():i(100){}

class foo{
public:
    foo();
private:
staticint i;
};
 
intfoo::i=20;

class Test{
public:
    static const int mask1;
    conststatic int mask2;
};
constTest::mask1=0xffff;
constTest::mask2=0xffff;
//它们的初始化没有区别，虽然一个是静态常量一个是常量静态。静态都将存储在全局变量区域，其实最后结果都一样。可能在不同编译器内，不同处理，但最后结果都一样。

实例

#ifdef A_H_
#define A_H_
#include <iostream>
usingnamespace std;
class A{
    public:
        A(int a);
        staticvoid print();//静态成员函数
    private:
        static int aa;//静态数据成员的声明
        staticconst int count;//常量静态数据成员（可以在构造函数中初始化）
        const int bb;//常量数据成员
};
 
int A::aa=0;//静态成员的定义+初始化
const int A::count=25;//静态常量成员定义+初始化
 
A::A(int a):bb(a){//常量成员的初始化
    aa+=1;
}
 
void A::print(){
    cout<<"count="<<count<<endl;
    cout<<"aa="<<aa<<endl;
}
 
#endif
 
void main(){
    A a(10);
    A::print();//通过类访问静态成员函数
    a.print();//通过对象访问静态成员函数
}

实例

#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="<<a<<","<<b<<","<<c<<endl;
 }
 
void Myclass::GetSum(){
    cout<<"Sum="<<sum<<endl;
 }
 
void main(){
    Myclass M(3, 7, 10),N(14, 9, 11);
    M.GetNumber();
    N.GetNumber();
    M.GetSum();
    N.GetSum();
}

实例

#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="<<m.a<<endl;
    cout<<"B="<<b<<endl;
}
 
int M::B=0;
 
void main()
{
    M P(5),Q(10);
    M::f1(P); //调用时不用对象名
    M::f1(Q);
}

//-----------------Test.h----------------------------
#pragma once
class Test
{
private :
    int var1;
    // int var11= 4; 错误的初始化方法
    const int var2 ;
    // const int var22 =22222; 错误的初始化方法
    static int var3;
    // static int var3333=33333; 错误，只有静态常量int成员才能直接赋值来初始化
    static const int var4=4444; //正确，静态常量成员可以直接初始化    
    static const int var44;
public:
    Test(void);
    ~Test(void);
};
//--------------------Test.cpp-----------------------------------
#include ".\test.h"
 
int Test::var3 = 3333333; //静态成员的正确的初始化方法
 
// int Test::var1 = 11111;; 错误静态成员才能初始化
// int Test::var2 = 22222; 错误
// int Test::var44 = 44444; // 错误的方法，提示重定义
Test::Test(void)：var1(11111),var2(22222)正确的初始化方法//var3(33333)不能在这里初始化
{
    var1 =11111; //正确, 普通变量也可以在这里初始化
    //var2 = 222222; 错误，因为常量不能赋值，只能在 "constructor initializer （构造函数的初始化列表）" 那里初始化
          
    var3 =44444; //这个赋值是正确的，不过因为所有对象一个静态成员，所以会影响到其他的，这不能叫做初始化了吧
}
Test::~Test(void){}
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

// Initialization of Special Data Member
#include <iostream>
using namespace std;     
 
class BClass
{
public:
    BClass() : i(1),ci(2), ri(i) // 对于常量型成员变量和引用型成员变量，必须通过    
    {                // 参数化列表的方式进行初始化。在构造函数体内进行赋值的方式，是行不通的。
    } 
 
    voidprint_values()
    {
        cout<< "i =\t" << i << endl;
        cout<< "ci =\t" << ci << endl;
        cout<< "ri =\t" << ri << endl;
        cout<< "si =\t" << si << endl;
        cout<< "csi =\t" << csi << endl;
        cout<< "csi2 =\t" << csi2 << endl;
        cout<< "csd =\t" << csd << endl;
    }
 
private:
    inti; // 普通成员变量
    constint ci; // 常量成员变量
    int&ri; // 引用成员变量
    staticint si; // 静态成员变量
    //staticint si2 = 100; // error: 只有静态常量成员变量，才可以这样初始化
    staticconst int csi; // 静态常量成员变量
    staticconst int csi2 = 100; // 静态常量成员变量的初始化(Integral type) (1)
    staticconst double csd; // 静态常量成员变量(non-Integral type)
    //staticconst double csd2 = 99.9; // error: 只有静态常量整型数据成员才可以在类中初始化
};
// 静态成员变量的初始化(Integral type)
int BClass::si = 0;
// 静态常量成员变量的初始化(Integral type)
const int BClass::csi = 1;
// 静态常量成员变量的初始化(non-Integral type)
const double BClass::csd = 99.9;
 
// 在初始化(1)中的csi2时，根据Stanley B. Lippman的说法下面这行是必须的。
// 但在VC2003中如果有下面一行将会产生错误，而在VC2005中，下面这行则可有可无，这个和编译器有关。
const int BClass::csi2;
 
int main(void)
{
    BClassb_class;
    b_class.print_values(); 
    return0;
}

xxx.h文件 
class base{ 
private: 
    static const int _i;//声明，标准c++支持有序类型在类体中初始化,但vc6不支持。 
}; 
 
xxx.cpp文件 
const int base::_i=10;//定义(初始化)时不受private和protected访问限制.

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 datanumber _num is"<<b._num<<endl; 
} 
// 结果为1,2;可见派生类与基类共用一个静态数据成员。

class base{ 
public : 
    static int _staticVar; 
    int _var; 
    void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员 
    void foo2(int i=_var);//错误,_var为普通数据成员 
};

class base{ 
public : 
    static base_object1;//正确，静态数据成员 
    base _object2;//错误 
    base *pObject;//正确，指针 
    base &mObject;//正确，引用 
};

class base{ 
public: 
    base(){
        _i=0;
        _val=0;
    } 
 
    mutable int _i; 
    static int _staticVal; 
    int _val; 
    void test() const{//const 成员函数 
        _i++;//正确，mutable数据成员 
        _staticVal++;//正确，static数据成员 
        _val++;//错误 
    } 
}; 
int base::_staticVal=0;

class base{ 
    static int func1(); 
    int func2(); 
}; 
 
int (*pf1)()=&base::func1;//普通的函数指针 
int (base::*pf2)()=&base::func2;//成员函数指针

class base{ 
    virtual static void func1();//错误 
    static void func2() const;//错误 
    static void func3() volatile;//错误 
};