设计模式3-抽象工厂

在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品。

一、 go语言版

package main
import "fmt"
type Product interface {
    Show(name string) string
}
type ProductA struct{}
func (*ProductA) Show(name string) string {
    return fmt.Sprintf("MyProductA is %s", name)
}
type ProductB struct{}
func (*ProductB) Show(name string) string {
    return fmt.Sprintf("MyProductB is %s", name)
}
type PlusProduct interface {
    Show(name string) string
}
type PlusProductA struct{}
func (*PlusProductA) Show(name string) string {
    return fmt.Sprintf("MyPlusProductA is %s", name)
}
type PlusProductB struct{}
func (*PlusProductB) Show(name string) string {
    return fmt.Sprintf("MyPlusProductB is %s", name)
}
type Factory interface {
    CreateProduct() Product
    CreatePlusProduct() PlusProduct
}
type FactoryA struct{}
func (* FactoryA) CreateProduct() Product{
    return &ProductA{}
}
func (* FactoryA) CreatePlusProduct() PlusProduct{
    return &PlusProductA{}
}
type FactoryB struct{}
func (* FactoryB) CreateProduct() Product{
    return &ProductB{}
}
func (* FactoryB) CreatePlusProduct() PlusProduct{
    return &PlusProductB{}
}
func main() {
    var fac Factory 
    fac = new(FactoryA)
    pro := fac.CreateProduct()
    proplus := fac.CreatePlusProduct()
    
    s := pro.Show("product")
    ss := proplus.Show("product plus")
    fmt.Printf("return is %v %v\n", s, ss)
}

二、c++语言版

#include <iostream>
using namespace std;
class Product
{
    public:
        virtual void Show(string msg) = 0;
};
class ProductA : public Product
{
    public:
        void Show(string msg) {
            cout << "ProductA show msg: " << msg  << " " << endl;
        }
};
class ProductB : public Product
{
    public:
        void Show(string msg) {
            cout << "ProductB show msg: " << msg  << " " << endl;
        }
};
class PlusProduct
{
    public:
        virtual void Show(string msg) = 0;
};
class PlusProductA : public PlusProduct
{
    public:
        void Show(string msg) {
            cout << "PlusProductA show msg: " << msg  << " " << endl;
        }
};
class PlusProductB : public PlusProduct
{
    public:
        void Show(string msg) {
            cout << "PlusProductB show msg: " << msg  << " " << endl;
        }
};
class Factory
{
    public:
        virtual Product *CreateProduct() = 0;
        virtual PlusProduct *CreatePlusProduct() = 0;
};
class FactoryA : public Factory 
{
    public:
        Product *CreateProduct() {
            return new ProductA();
        }
        PlusProduct *CreatePlusProduct() {
            return new PlusProductA();
        }
};
class FactoryB : public Factory 
{
    public:
        Product *CreateProduct() {
            return new ProductB();
        }
        PlusProduct *CreatePlusProduct() {
            return new PlusProductB();
        }
};
int main() 
{
    Factory *fac = new FactoryA();
    Product *pro = fac->CreateProduct();
    PlusProduct *pluspro = fac->CreatePlusProduct();
    pro->Show("product");
    pluspro->Show("plusProduct");
    delete pro;
    delete pluspro;
    delete fac;
}

三、c语言版

#include <stdio.h>
typedef struct _Product {
    char name[64];
    void (*show)(char *msg);
}Product;
void productA_show(char *msg) 
{
    printf("ProductA show msg %s\n", msg);
}
Product productA = {
    .name = "product A",
    .show = productA_show,
};
void productB_show(char *msg) 
{
    printf("ProductB show msg %s\n", msg);
}
Product productB = {
    .name = "product B",
    .show = productB_show,
};
typedef struct _PlusProduct {
    char name[64];
    void (*show)(char *msg);
}PlusProduct;
void plusProductA_show(char *msg) 
{
    printf("plusProductA_show msg %s\n", msg);
}
PlusProduct plusProductA = {
    .name = "plusProduct A",
    .show = plusProductA_show,
};
void plusProductB_show(char *msg) 
{
    printf("plusProductB_show show msg %s\n", msg);
}
PlusProduct plusProductB = {
    .name = "plusProduct B",
    .show = plusProductB_show,
};
typedef struct _ProductFactory {
    Product *(*CreateProduct) ();
    PlusProduct *(*CreatePlusProduct) ();
}ProductFactory;
Product *CreateProductA()
{
    printf("Create Product A\n");
    return &productA; 
}
PlusProduct *CreatePlusProductA()
{
    printf("Create PlusProduct A\n");
    return &plusProductA; 
}
ProductFactory factoryA = {
    .CreateProduct = CreateProductA,
    .CreatePlusProduct = CreatePlusProductA,
};
Product *CreateProductB()
{
    printf("Create Product B\n");
    return &productB;
}
PlusProduct *CreatePlusProductB()
{
    printf("Create PlusProduct B\n");
    return &plusProductB; 
}
ProductFactory factoryB = {
    .CreateProduct = CreateProductB,
    .CreatePlusProduct = CreatePlusProductB,
};
int main()
{
    ProductFactory *fac = &factoryB;
    Product *pro = fac->CreateProduct();
    PlusProduct *proplus = fac->CreatePlusProduct();
    pro->show("product");
    proplus->show("plusproduct");
   
    return 0;
}