C++ 中的const、static、单例模式

只读(const):

• 只读对象:只读变量,表示对象的数据成员不能被类的成员函数修改。
• 只读数据成员:构造函数中用列表方式初始化。

• 只读函数成员:在函数中不能修改对象的数据成员,只读成员函数只能调用只读成员函数.

•  

  mutable 修饰的成员变量是可以在只读的成员函数中修改

   

  #include  <iostream>
  #include  <stdio.h>
  using namespace std;
  class   A
  {
  public:
  	A(int _a,int _b,int _c):b(_b)
  	{
  		a=_a;
  		//b=_b;//错误,不能对只读成员变量赋值
  		c=_c;
  	}
  	void  print() const;//注意只读函数const的位置
  
  	void  fun() const
  	{
  		cout<<b<<endl;//读取只读数据成员可以
  		cout<<"fun"<<endl;
  		a=6;
  	}
  private:
  	mutable int a;
  	const int b;//只读数据成员
  	int c;
  };
  void  A::print() const
  {
  	//a=400;//错误,只读成员函数中不能修改成员变量,如果非要修改要在变量前面加上mutable关键字修饰。
  	//fun();//错误.
  	cout<<a<<'\t'<<b<<'\t'<<c<<endl;
  }
  
  int main(int argc, char const *argv[])
  {
  	const A  a1(3,4,5);//只读对象(只读变量),对象数据成员成为只读
  	a1.fun();
  	a1.print();
  
  	return 0;
  }
  

  静态（static）：

• static 对象:静态局部对象,存储在数据段.在进程结束释放

• static数据成员:不属于对象,共享于所有对象
                          只能在类外初始化,不能再构造函数初始化
                          在类外访问静态数据成员前必须要初始化
                          可以通过类名或对象名访问
                          可以在一般函数中访问

• static函数成员:  可以通过对象调用也可以通过类名调用
                           静态成员函数只能使用静态数据成员 >>重点

#include  <iostream>
#include  <stdio.h>
using namespace std;
class  A
{
public:
	A(int _a)
	{
		a=_a;
	}
	void  print()
	{
		cout<<a<<endl;
	}
private:
	int a;
};

void   fun()
{
	int i;
	for(i=0;i<10;i++)
	{
		static A a2(200);//静态局部对象,存储在数据段.在进程结束释放
	}
}
int main(int argc, char const *argv[])
{
	A a1(100);
	a1.print();
	//static  A  a2(200); //静态对象,静态变量
	fun();
	return 0;
}

#include  <iostream>
#include  <stdio.h>
using namespace std;
class  A
{
public:
	void print()
	{
		cout<<a<<endl;
	}
	static int a; //静态数据成员
	//int b;
};
//初始化静态数据成员:
int A::a=100;

int main(int argc, char const *argv[])
{
	A a1;
	cout<<sizeof(a1)<<endl; //输出大小为1个字节，说明static数据成员不属于对象,共享于所有对象
	a1.a=400;
	A a2;
	cout<<a2.a<<endl; //被a1对象修改，a2这里输出400  可以通过类名或对象名访问.
	A::a=3000;
	cout<<a1.a<<endl;

	a1.print();
	return 0;
}

#include  <iostream>
#include  <stdio.h>
using namespace std;
class  A
{
public:
	A()
	{
		b=400;
	}
	//静态成员函数
	static void  funs()
	{
		//cout<<b<<endl; //错误,b非静态,静态成员函数只能使用静态数据成员
		cout<<"funs"<<endl;
	}
	void print()
	{
		cout<<a<<endl;
	}
	static int a; //静态数据成员
	int  b;
};
//初始化静态数据成员:
int A::a=100;

int main(int argc, char const *argv[])
{
	A a1;

	a1.print();
	a1.funs();
	A::funs();
	return 0;
}

单粒模式：

     这个类只能存在一个对象。

     关键是构造函数私有，并且定义一个空的静态对象

#include <iostream>
using namespace std;
class  A
{
public:
	static A *   initobj()
	{	
		if(obj==NULL)
		{
			obj=new A(10);//分配对象空间，并初始化成员变量。
		}		
		return obj;
	}
	void  fun()
	{
		cout<<"fun"<<endl;
	}
private:
	A(int _a)
	{
		a=_a;
	}
	int a;
	static A* obj;
};
A * A::obj=NULL;
int main(int argc, char const *argv[])
{
	//A a1(100);

	A  *obj=A::initobj();
	obj->fun();
	A  *obj2=A::initobj();
	obj2->fun();
	return 0;
}