c++创建型设计模式--工厂模式--简单工厂（单个产品的构建）

思想
主要是对于单个简单的产品进行构建
基类

#pragma once
#include <iostream>
/**
 * 基类指针
 *Date :[10/12/2018 ]
 *Author :[RS]
 */
 class  CarBase {
public:
	virtual ~CarBase() {
		std::cout << "析构 carBase" << std::endl;
	}
	virtual void PrintName() {
		printf("骑车生产厂商:%s\n",mStrName.c_str());
	}
protected:
	CarBase() {};
	CarBase(const std::string& name) :mStrName(name) {};
	std::string mStrName;

};

子类

#pragma once
#include "CarBase.hpp"
/**
 *3个基类的具体子类 
 *Date :[10/12/2018 ]
 *Author :[RS]
 */
class GMCar :public CarBase {
public:
	GMCar() :CarBase("通用汽车公司") {}
	void PrintName()override {
		std::cout << "GMCar PrintName" << std::endl;
		CarBase::PrintName();
	}
};

class FordCar :public CarBase {
public:
	FordCar() :CarBase("FordCar公司") {}
	void PrintName()override {
		std::cout << "GMCar PrintName" << std::endl;
		CarBase::PrintName();
	}
};

class ToyotaCar :public CarBase {
public:
	ToyotaCar() :CarBase("ToyotaCar汽车公司") {}
	void PrintName()override {
		std::cout << "GMCar PrintName" << std::endl;
		CarBase::PrintName();
	}
};

工厂类

#pragma once
#include "CarBaseExtens.hpp"
#include <memory>
#include <cassert>
/**
 *简单工厂类 
 *简单工厂比较适合从配置文件读取实例化的类型这样就可以通过配置文件指定
 实例化的对象指针
 *Date :[10/12/2018 ]
 *Author :[RS]
 */
class CarFactory {
public:
	static std::shared_ptr<CarBase> Create(const std::string &name) {
		std::shared_ptr<CarBase> car;
		if ("1" == name) {
			car = std::make_shared<GMCar>();
		}
		else if ("2" == name) {
			car=std::make_shared<FordCar>();
		}
		else if ("3" == name) {
			car = std::make_shared<ToyotaCar>();
		}
		else {
			assert(false);//弹出错误对话
		}
		return car;
	}
	static void TEST() {
		{
			auto car = CarFactory::Create("1");
			car->PrintName();
		}
		{
			auto car = CarFactory::Create("2");
			car->PrintName();
		}
		{
			auto car = CarFactory::Create("3");
			car->PrintName();
		}
	}
};

测试

#include "CarFactory.hpp"


void main() {
	CarFactory::TEST();
	system("pause");
}

为了体现开闭原则，我们将抛弃其三个子类实现。改成在原先的组件上添加Engine,Door,Wheel三个，然后写新的子类进行修改（仍使用新的基类CarBase）
新组件

#pragma once
#include<iostream>
/**
 *为了体现开闭原则，现在车子的引擎底盘和轮子我们自己生产 
 *Date :[10/12/2018 ]
 *Author :[RS]
 */

class Engine {
public:
	Engine() {
		printf("Engine constructor\n");
	}
	~Engine() {
		printf("Engine delete");
	}
};
class Door {
public:
	Door() {
		printf("Door constructor\n");
	}
	~Door() {
		printf("Door delete");
	}
};
class Wheel {
public:
	Wheel() {
		printf("Wheel constructor\n");
	}
	~Wheel() {
		printf("Wheel delete");
	}
};

新的实现类（子类）

#pragma once
#include "CarBase.hpp"
#include "CarOtherBase.h"
#include <memory>
/**
 *新的子类（不适用CarExtens） 
 *Date :[10/12/2018 ]
 *Author :[RS]
 */
class AssemblingCar :public CarBase {
public:
	AssemblingCar(Engine * pEngne, Door* pDoor, Wheel* pWheel) {
		mPtrEngine.reset(pEngne);
		mPtrDoor.reset(pDoor);
		mPtrWheel.reset(pWheel);
	}
	void PrintName()override {
		printf("AssemblingCar");
	}
private:
	std::shared_ptr<Engine> mPtrEngine;
	std::shared_ptr<Door> mPtrDoor;
	std::shared_ptr<Wheel> mPtrWheel;
};

新的工厂方法类

#pragma once
#include "AssembingCar.hpp"
/**
 *如果想讲改工厂方法类也抽象化，可以提取出他的基类方法 Create 
 *Date :[10/12/2018 ]
 *Author :[RS]
 */
class AssertCarFactory {
public:
	static std::shared_ptr<CarBase> Create() {
		std::shared_ptr<CarBase> car = std::make_shared<AssemblingCar>(new Engine(), new Door(), new Wheel());
		return car;
	}
	static void Test() {
		auto car=AssertCarFactory::Create();
		car->PrintName();
	}
};

测试入口

#include "Manager.hpp"
#include "CarFactory.hpp"
#include "CarFactoryMethod.h"
#include "AssemCarFactory.hpp"

void main() {
	//CarFactory::TEST();
	//CarFacotryMethod::Test();
	AssertCarFactory::Test();
	system("pause");
}