啃食c++(简单设计模式)

简单工厂模式
该设计模式是多态的一种应用实例，简单工厂模式是有一个生产对象决定生产那一产品，例如接下来的例子中，将friut作为父类，其子类就是各种水果，在这里就创建了两个子类引入，然后将各种水果对象作为生产者garden的私有数据成员，通过出生产者来获取想要的水果类型。

#include<iostream>
using namespace std;
enum{APPLE  = 0 ,GRAPES = 1};
class friut{
public :
    friut(){}
    virtual ~friut(){}
    virtual void plant(){} 
    virtual void grow(){}
    virtual void harvest() {}
};
class apple:public friut{
public:
    apple(){}
    ~apple() {}
    void plant(){
        cout<<"apple has been plant...."<<endl ;
    }
    void grow(){
        cout<<"apple is growing..."<<endl ;
    }
    void harvest(){
        cout<<"apple harvest!"<<endl ;
    }
};
class grapes:public friut{
public :
    grapes() {}
    ~grapes() {}
    void plant(){
        cout<<"grapes has been plant...."<<endl ;
    }
    void grow(){
        cout<<"grapes is growing..."<<endl ;
    }
    void harvest(){
        cout<<"grapes harvest!"<<endl ;
    }
};
//创建生产者的类
class garden{
public:
    garden(){}
    ~garden(){}
    //通过该方法实现不同水果的生产，并将该水果返回
    friut *getFriut(int fr){
        switch(fr){
            case APPLE:
              app = new apple;
                app->plant();
                app->grow();
                app->harvest();
                return app;
            case GRAPES:
                grps=new grapes ;
                grps->plant();
                grps->grow();
                grps->harvest();
                return grps ;
        }
    }
    //生产者当前能生存的水果种类
private:
    apple * app ;
    grapes * grps;
};
int main(){
    
    garden gd ;
    friut* app ;
    friut *grps ;
 //通过父类接收
    app= gd.getFriut(APPLE);
    grps=gd.getFriut(GRAPES);
//记得将申请的资源释放
    delete app ;
    delete grps;
    app = NULL ;
    grps = NULL;
}

运行截图：

单例模式
在学习java语言时，对单例模式有一个概念，但是也用java实现了一个简单的单例模式。单例模式自己对其理解就是，一个类只能产生一个对象，这种设计模式感觉用处挺大的，尤其在以后的面向对象的语言开发中，有写对象一个程序只能存在一个，这时就可以用这种设计模式来实现此功能。
对于c++单例设计模式，也时大同小异，在这里我将具体实现描述一下就行，以备以后复习所用。

#include<iostream>
#include<string>
using namespace std;
class single{
private:
    //单例创建一个，static关键字意味着这个对象之创建一次，作用域是整个类区
    static single *s ;
    //将单例构造函数设为私有
    single(){}
    ~single(){}
   // single& operator=(const single&){}
public:
//在公有方法区只留一个接口，供用户获得此单例，该方法为类方法，通过类名调用
    static single* getSingle(){
        if(s == NULL){
            s = new single;
            cout<<"single ton has been ..."<<endl;
        }
        return s ;
    }
    void dosomething(){
        cout<<"singleton singleton"<<endl ;
    }
    void deletemyself(){
        delete s;
        s = NULL;
        cout<<"the singleton has been destroy!"<<endl;
    }
};
//初始化单例指向NULL
single* single::s = NULL ;
int main(){
   
    single::getSingle()->dosomething();
    single::getSingle()->deletemyself();
}

感觉c++创建单例相比于java跟抽象一些，但都不是很难，以上创建单例的方法为c++中的懒汉单例模式，意思是只有在用时才创建该单例对象。还有一种时饿汉单例模式，即在用之前已经创建好了该单例。
只需上面的程序：在s初始化时直接new该类，外部调用get函数直接返回s即可。这就是饿汉模式。
好啦！！！对于c++总结告一段落，又要继续沉溺在c++中啦~~~