设计模式之原型模式

在上篇博文中我们学习了有关单例模式，单例模式通俗点讲就是只有一个对象的类，这种设计模式最大的优点就是对象易于管理，这种设计模式是值得好好地学习下的，其他的我们就不多说了，接下来我们再来学习一下另外一个设计模式——原型模式，在列出代码之前，我们需要了解一下：什么叫原型模式，原型模式的定义：用原型实例指定创建对象的种类，并且通过使用拷贝这些原型创建新的对象。这句话怎么来理解呢，其实说白了，就是使用已有的对象来创建新对象，这种模式的使用最大的优点就是一个原型能够创建出无数个新的对象，其使用价值还是很高的，好了，下面就来看看具体的代码吧，代码如下：

#ifndef __PROTOTYPE__H
#define __PROTOTYPE__H

#include <stdio.h>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Person
{
    public:
        Person(){}
        ~Person(){}
        virtual void setName(string name){}
        virtual void setAge(int age){}
        virtual void display(){}
        virtual shared_ptr<Person> clone()
        {
            return shared_ptr<Person>(this);
        }
};

class Man : public Person
{
    public:
        Man(string name = string(),const int age = 0):name(name),age(age)
        {
        }
        ~Man(){}

        Man(const Man& man)
        {
            name = man.name;
            age = man.age;
        }

        Man& operator = (const Man& man)
        {
            name = man.name;
            age = man.age;
        }

        void display()
        {
            cout<<"name:"<<name<<" "<<"age:"<<age<<" ";
        }
        void setName(string name)
        {
            this->name = name;
        }
        void setAge(const int age)
        {
            this->age = age;
        }
        shared_ptr<Person> clone()
        {
            return shared_ptr<Person>(this);
        }
    private:
        string name;
        int age;
};

class Woman : public Person
{
    public:
        Woman(string name = string(),const int age = 0):name(name),age(age){}
        ~Woman(){}

        Woman(const Woman& woman)
        {
            name = woman.name;
            age = woman.age;
        }
        Woman& operator = (const Woman& woman)
        {
            name = woman.name;
            age = woman.age;
        }

        void display()
        {
            cout<<"name:"<<name<<" "<<"age"<<age<<" ";
        }
        void setName(string name)
        {
            this->name = name;
        }
        void setAge(const int age)
        {
            this->age = age;
        }
        shared_ptr<Person> clone()
        {
            return shared_ptr<Person>(this);
        }
    private:
        string name;
        int age;
};

class Car
{
    public:
        Car(){}
        ~Car(){}
        virtual void run()
        {
        }
        virtual void stop()
        {
        }
        virtual shared_ptr<Car> clone()
        {
            return shared_ptr<Car>(this);
        }
};

class BWMCar : public Car
{
    public:
        BWMCar(){}
        ~BWMCar(){}

        void run()
        {
            cout<<"BWMCar is runnig"<<endl;
        }
        void stop()
        {
            cout<<"BWMCar is stoping"<<endl;
        }
        shared_ptr<Car> clone()
        {
            return shared_ptr<Car>(this);
        }
};
class VolvoCar : public Car
{
    public:
        VolvoCar(){}
        ~VolvoCar(){}

        void run()
        {
            cout<<"VolvoCar is running"<<endl;
        }
        void stop()
        {
            cout<<"VolvoCar is stoping"<<endl;
        }
        shared_ptr<Car> clone()
        {
            return shared_ptr<Car>(this);
        }
};

class Manager
{
    public:
        Manager(shared_ptr<Person>& pson,shared_ptr<Car>& ca)
        {
            person = pson->clone();
            car = ca->clone();
        }
        ~Manager(){}
        void run()
        {
            person->display();
            car->run();
        }
    private:
        shared_ptr<Person> person;
        shared_ptr<Car> car;
};
#endif

测试程序：

#include "ProtoType.h"

int main()
{
    shared_ptr<Person> man(new Man("Tom",31));
    shared_ptr<Person> woman(new Woman("Lily",21));
    shared_ptr<Car> BWM(new BWMCar());
    shared_ptr<Car> Volvo(new VolvoCar());
    Manager manager1(man,BWM);
    Manager manager2(woman,Volvo);
    manager1.run();
    manager2.run();
    return 0;
}

测试结果

name:Tom age:31 BWMCar is runnig
name:Lily age21 VolvoCar is running

总结

      本篇博文简要地分析了设计模式中的原型模式，这种模型最大的好处用一个比较贴切的比方（也是从别人的博客里看到的）：就好比是一个原稿打印一堆复印稿的关系，当原稿需要修改一个地方时，只需要针对原稿进行修改即可，而不需改动复印稿，然后重新在打印即可。说到这里，想必大家应该能够明白原型模式到底是神马意思了吧，好好地体会一下吧，好了，本篇博文到此结束，下篇博文我们继续学习设计模式——建造者模式。

如果需要，请注明转载，多谢