C++ static、const和static const、引用类型成员变量声明以及初始化

const 定义的常量在超出其作用域之后其空间会被释放，static定义的静态常量在函数执行后不会释放其存储空间。

一、初始化：

1、const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。

class foo{
public:
	foo():i(100){}
private:
	const int i=100;//错误!!!
};

foo::foo():i(100){} //只能通过列表初始化方式来进行初始化

2、static静态成员变量不能在类的内部初始化，静态成员的提出是为了解决数据共享的问题。

class foo{
public:
	foo();
private:
    static int i;
};
 
intfoo::i=20; //不能带static

     （1） 数据类型 类名::静态数据成员名=值；

     （2）初始化在类体外进行（.cpp中），而前面不加static，以免与一般静态变量或对象相混淆.

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

     （3）遵循public和private等访问规则，初始化时不加该成员的访问权限控制符private、public等。

      （4）使用静态数据成员时，采用如下格式： <类名>::<静态成员名>

3、引用型成员变量的初始化，必须通过构造函数初始化列表的方式进行

4、类里的static cosnt 和 const static成员初始化。

class Test{
public:
	static const int mask1;
	const static int mask2;
    const static int mask3 = 5; //int型static const变量也可在此初始化
};

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

       （1）非int型 static cosnt变量在类体外初始化（和static成员变量一样）

       （2）int型static cosnt （1、在声明处。2、在类体外和static一样）

要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

实例：

#ifdef  A_H_
#define A_H_

#include 

usingnamespace std;

class Test{
public:
	Test()
    :a(0)  //const和&（引用）类型常量必须在此初始化
    ,d(1)
    {
           a0=122; //正确, 普通变量也可以在这里初始化
          
	 b=44444; //这个赋值是正确的，不过因为所有对象一个静态成员，所以会影响到其他的，这不能叫做初始化了吧
    } 

	enum{
        size1=100,
        size2=200
    };
    
    void f() const;       //const成员函数

    static void print();  //静态成员函数
    
private:
    int a0;
	const int a;             //只能在构造函数初始化列表中初始化
	static int b;            //在类的实现文件中定义并初始化
	const static int c;      //与 static const int c;相同。
    const static int c1 = ;  //int型static const变量也可以在此初始化。
    int & d;                 // 引用型成员变量
};
 
void Test::f() const     // 可以访问所有数据成员，但是不能改变其值
{
    cout<所有成员变量。
 
  
6、static成员函数主要目的是作为类作用域的全局函数。不能访问类的非静态数据成员，如果静态成员函数中要引用非静态成员时，可通过对象来引用。类的静态成员函数没有this指针，这导致：（1）不能直接存取类的非静态成员变量，调用非静态成员函数.。（2） 不能被声明为virtual。
 
  
      调用静态成员函数使用如下格式：
 　           <类名>::<静态成员函数名>(<参数表>);
 
  
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="<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"<
 
  
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.★这个特性，我不知道是属于标准c++中的特性，还是vc6自己的特性。 
静态数据成员的值在const成员函数中可以被合法的改变。举例如下：
 
  
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; 
 
  
静态成员函数 
 
  
静态成员函数没有什么太多好讲的。 
 
  
1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用类成员函数指针来储存。举例如下： 
 
  
class base{ 
    static int func1(); 
    int func2(); 
}; 
 
int (*pf1)()=&base::func1;//普通的函数指针 
int (base::*pf2)()=&base::func2;//成员函数指针 
 
  
2.静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。 

 3.静态成员函数不可以同时声明为 virtual、const、volatile函数。举例如下： 
 
  
class base{ 
    virtual static void func1();//错误 
    static void func2() const;//错误 
    static void func3() volatile;//错误 
}; 
 
  
最后要说的一点是，静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。