基本设计模式：单例模式和工厂模式代码实现
单例模式
单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问，但它不能阻止你实例化多个对象。一个最好的办法是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。
也就是说，很多时候我们需要全局的对象，如一个工程中，数据库访问对象只有一个，这时，可以考虑使用单例模式。单例模式比全局对象好还包括：单例类可以继承，如下例中的C++代码。
单例模式的关键点在于：构造函数私有，静态的GetInstance。
另外，在C++中必须注意内存的释放。C++、Java、C#中还要注意多线程时的同步问题，另外在多线程可以以合适的方式保证共享变量仅初始化一次
以下列出懒汉式的单例模式
C++实现：
class Singleton
{
public:
static Singleton * GetInstance()
{
if(NULL == m_pInstance)
m_pInstance = new Singleton();
return m_pInstance;
}
static void Release() //必须，否则会导致内存泄露
{
if(NULL != m_pInstance)
{
delete m_pInstance;
m_pInstance = NULL;
}
}
protected:
Singleton()
{
cout<<"C++ Singleton"<<endl;
};
static Singleton * m_pInstance;
};
Singleton* Singleton::m_pInstance = NULL;
class SingleDraw:public Singleton
{
public:
static SingleDraw* GetInstance()
{
if(NULL == m_pInstance)
m_pInstance = new SingleDraw();
return (SingleDraw*)m_pInstance;
}
protected:
SingleDraw()
{
cout<<"C++ SingleDraw"<<endl;
}
};
int main()
{
SingleDraw* s1 = SingleDraw::GetInstance();
SingleDraw* s2 = SingleDraw::GetInstance();
s2->Release();
return 0;
}
Java实现(这里仅给出类实现部分)：
public class Singleton{
private static Singleton instance=NULL;
private Singleton(){
System.out.println("Java Singleton");
}
public static Singleton getInstance(){
if(instance == NULL)
instance = new Singleton();
return instance;
}
}
还有另一种形式： 饿汉单例,也就是,类被加载的时候就已经创建好了单例，相比懒汉式只是加载new的地方发生了改变，这里代码重略
饿汉式和懒汉式的比较：
1 饿汉式单例,由于类被加载的时候就将自己实例化,所以,从资源利用的角度来说,饿汉式单例比懒汉式单例效率更差
2 懒汉式单例在实例化的时候,必须处理好多个线程同时引用造成的访问限制问题.也就是,很有可能有两个线程同时去调用了这个获取单例的方法,造成了单例被创建了多次，懒汉式单例模式线程安全问题：假如现在有两个线程A和线程B，线程A执行到 this.singletonPattern = new SingletonPattern()，正在申请内存分配，可能需要0.001微秒，就在这0.001微秒之内，线程B执行到if(this.singletonPattern == null)，你说这个时候这个判断条件是true还是false？是true，那然后呢？线程B也往下走，于是乎就在内存中就有两个SingletonPattern的实例了。所以，在编写懒汉式单例模式时，应注意线程安全问题（由全局变量及静态变量引起的），这里可以用互斥同步的方式去解决。（面试可考的地方）
3 饿汉式单例类可以在Java 语言内实现， 但不易在C++ 内实现，因为静态初始化在C++ 里没有固定的顺序，因而静态的m_instance 变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么GoF 在提出单例类的概念时，举的例子是懒汉式的。他们的书影响之大，以致Java 语言中单例类的例子也大多是懒汉式的
工厂模式
首先需要说一下工厂模式。工厂模式根据抽象程度的不同分为三种：简单工厂模式（也叫静态工厂模式）、这里所讲述的工厂方法模式、以及抽象工厂模式。工厂模式是编程中经常用到的一种模式。它的主要优点有：
- 可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
- 对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
- 降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。
C++实现：
#include <iostream>
using namespace std;
class IProduct
{
public:
virtual void productMethod() = 0;
};
class Product:public IProduct
{
public:
void productMethod()
{
cout<<"C++ productMethod call"<<endl;
}
};
class IFactory
{
public:
virtual IProduct* CreateProduct() = 0;
};
class ConcreateFactory:public IFactory
{
public:
IProduct* CreateProduct()
{
IProduct* p = new Product();
return p;
}
};
int main()
{
IFactory* pFactory = new ConcreateFactory();
IProduct* p = pFactory->CreateProduct();
p->productMethod();
delete p;
return 1;
}
Java实现
interface IProduct {
public void productMethod();
}
class Product implements IProduct {
public void productMethod() {
System.out.println("Java productMethod call");
}
}
interface IFactory {
public IProduct createProduct();
}
class Factory implements IFactory {
public IProduct createProduct() {
return new Product();
}
}
public class Client {
public static void main(String[] args) {
IFactory factory = new Factory();
IProduct prodect = factory.createProduct();
prodect.productMethod();
}
}