创建型设计模式
概述
创建型设计模式是一类软件设计模式，它们关注对象的实例化过程，提供了一种在创建对象时解耦对象的创建和使用的方式。
分类
常见的创建型设计模式包括：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
1、单例模式：确保一个类只有一个实例，并提供一个全局访问点。
2、工厂方法模式：定义一个用于创建对象的接口，但是让子类决定实例化哪个类。这样可以将实例化的过程延迟到子类。
3、抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。
4、建造者模式：将一个复杂对象的构建过程与其表示相分离，使得同样的构建过程可以创建不同的表示。
5、原型模式：通过复制现有对象来创建新对象，而不是通过实例化。
细则
1.单例模式
懒汉式
在懒汉式中实例在首次调用时创建
//懒汉式
class Singleton
{
public:
//提供一个唯一的全局访问点
static Singleton * GetInstance()
{
std::lock_guard<std::mutex> guard(m_mutex);
if (nullptr == m_obj)
{
m_obj = new Singleton;
}
return m_obj;
}
public:
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {}
~Singleton() {}
static Singleton* m_obj;
static std::mutex m_mutex;
};
Singleton* Singleton::m_obj = nullptr;
std::mutex Singleton::m_mutex;
int main()
{
Singleton* singleton1 = Singleton::GetInstance();
Singleton* singleton2 = Singleton::GetInstance();
// 输出为 true，说明获取的是同一个实例
std::cout << (singleton1 == singleton2) << std::endl;
return 0;
}
饿汉式
在饿汉式中，实例在类加载时就被创建。
//饿汉式
class Singleton
{
public:
static Singleton* GetInstance()
{
return &m_obj;
}
public:
Singleton(const Singleton&) = delete;
Singleton& operator = (const Singleton&) = delete;
private:
Singleton() {}
~Singleton() {}
private:
static Singleton m_obj;
};
Singleton Singleton::m_obj;
int main()
{
Singleton* singleton1 = Singleton::GetInstance();
Singleton* singleton2 = Singleton::GetInstance();
// 输出为 true，说明获取的是同一个实例
std::cout << (singleton1 == singleton2) << std::endl;
return 0;
}
2.工厂方法模式
工厂方法模式是一种创建型设计模式，用于在不暴露对象创建逻辑的情况下创建对象。它将对象的创建委托给子类，由子类来决定实例化哪个具体的类。工厂方法模式通过提供一个抽象的工厂接口和多个具体的工厂类来实现这一目的。
工厂方法模式通常有四个核心角色：抽象产品、具体产品、抽象工厂和具体工厂。让我更详细地解释一下每个角色以及它们的作用：
抽象产品（Abstract Product） ：定义产品的接口，具体产品类将实现这些接口。
具体产品（Concrete Product） ：实现抽象产品定义的接口。
抽象工厂（Abstract Factory） ：定义一个创建产品的接口，通常包含一个工厂方法（Factory Method），让子类实现以便创建具体产品。
具体工厂（Concrete Factory） ：实现抽象工厂定义的接口，负责创建具体产品的实例。
#include <iostream>
//抽象产品
class Product
{
public:
virtual void use() = 0;
};
//具体产品A
class AProduct : public Product
{
public:
virtual void use()
{
std::cout << "use A" << std::endl;
}
};
//具体产品B
class BProduct : public Product
{
public:
virtual void use()
{
std::cout << "use B" << std::endl;
}
};
//抽象工厂
class Factory
{
public:
virtual Product* createProduct() = 0;
};
//A工厂
class AFactory : public Factory
{
public:
virtual Product* createProduct()
{
return new AProduct();
}
};
//B工厂
class BFactory : public Factory
{
public:
virtual Product* createProduct()
{
return new BProduct();
}
};
int main()
{
//我们需要创建一个A产品
Factory *aFactory = new AFactory;
Product* pA = aFactory->createProduct();
pA->use();
//我们需要创建一个B产品
Factory *bFactory = new BFactory;
Product* pB = bFactory->createProduct();
pB->use();
delete aFactory;
delete pA;
delete bFactory;
delete pB;
return 0;
}
3.抽象工厂模式
抽象工厂模式是一种创建型设计模式，它提供了一个接口用于创建一系列相关或依赖对象的家族，而不需要指定具体的类。这种模式属于工厂模式的一种扩展，它通过引入一个抽象工厂接口和多个具体工厂类来实现。
//抽象产品A
class ProductA
{
public:
virtual void use() = 0;
};
//具体产品A1
class ProductA1 : public ProductA
{
public:
virtual void use()
{
std::cout << "A1 use" << std::endl;
}
};
//具体产品A2
class ProductA2 : public ProductA
{
public:
virtual void use()
{
std::cout << "A2 use" << std::endl;
}
};
//抽象产品B
class ProductB
{
public:
virtual void eat() = 0;
};
//具体产品B1
class ProductB1 : public ProductB
{
public:
virtual void eat()
{
std::cout << "B1 eat" << std::endl;
}
};
//具体产品B2
class ProductB2 : public ProductB
{
public:
virtual void eat()
{
std::cout << "B2 eat" << std::endl;
}
};
//抽象工厂
class absFactory
{
public:
virtual ProductA* createProductA() = 0;
virtual ProductB* createProductB() = 0;
};
//具体抽象工厂A1使用B2吃
class A1B2_Factory : public absFactory
{
public:
virtual ProductA* createProductA()
{
return new ProductA1();
}
virtual ProductB* createProductB()
{
return new ProductB2();
}
};
//具体抽象工厂A2使用B2吃
class A2B2_Factory : public absFactory
{
public:
virtual ProductA* createProductA()
{
return new ProductA2();
}
virtual ProductB* createProductB()
{
return new ProductB2();
}
};
int main()
{
absFactory * factory = new A1B2_Factory();
ProductA *pa = factory->createProductA();
ProductB *pb = factory->createProductB();
pa->use();
pb->eat();
absFactory * factory2 = new A2B2_Factory();
ProductA *p2a = factory2->createProductA();
ProductB *p2b = factory2->createProductB();
p2a->use();
p2b->eat();
delete factory;
delete factory2;
delete pa;
delete p2a;
delete pb;
delete p2b;
return 0;
}
4.建造者模式
建造者模式是一种创建型设计模式，用于构建复杂对象。它允许你逐步构造一个复杂对象，同时使得构造过程和最终对象分离，从而可以使用相同的构建过程来创建不同的表示。
在建造者模式中，通常会有以下几个角色：
Director（指挥者）：负责指导构建过程，它不直接创建对象，而是通过建造者来构建产品。
Builder（建造者）：定义了构建产品各个部件的接口，具体的建造者实现了这些接口，负责实际构建产品的各个部件。
Product（产品）：表示被构建的复杂对象。
建造者模式的核心思想是将一个复杂对象的构建过程与其表示分离开来，使得同样的构建过程可以创建不同的表示。这样做的好处是，可以更灵活地控制构建过程，以及构建过程中的每个部分，而不影响最终产品的表示。
//建造者模式
//建造者模式是一种创建型设计模式，用于构建一个复杂对象。它允许你逐步的构造一个复杂对象，同时使得构建过程与最终对象分离。使得相同的构建过程有不同的创建表达
//Product产品：表示被创建的复杂对象
//Builder建造者：定义了构建产品部件的各个接口,具体构建者实现了各个接口。
//Director指挥者：负责指导建造过程，它不直接创建对象，而是通过建造者建造产品
//负责产品
class Product
{
public:
void setPartA(std::string partA)
{
this->partA = partA;
}
void setPartB(std::string partB)
{
this->partB = partB;
}
void setPartC(std::string partC)
{
this->partC = partC;
}
void show()
{
std::cout << partA.c_str() << " " << partB.c_str() << " " << partC.c_str() << std::endl;
}
private:
std::string partA;
std::string partB;
std::string partC;
};
//抽象建造者
class Builder
{
public:
virtual void setPartA() = 0;
virtual void setPartB() = 0;
virtual void setPartC() = 0;
virtual Product* GetProduct() = 0;
};
//具体建造者1
class Builder1 : public Builder
{
public:
Builder1() { m_product = new Product(); }
~Builder1() { delete m_product; }
public:
virtual void setPartA()
{
if (m_product)m_product->setPartA("partA");
}
virtual void setPartB()
{
if (m_product)m_product->setPartB("partB");
}
virtual void setPartC()
{
if (m_product)m_product->setPartC("partC");
}
virtual Product* GetProduct()
{
return m_product;
}
private:
Product *m_product;
};
//指挥者
class Director
{
public:
Director(Builder*builder) :m_builder(builder){}
public:
void constrtProduct()
{
if (!m_builder)
return;
m_builder->setPartA();
m_builder->setPartB();
m_builder->setPartC();
}
private:
Builder *m_builder;
};
int main()
{
Builder *b1 = new Builder1();
Director *d1 = new Director(b1);
d1->constrtProduct();
Product *p1 = b1->GetProduct();
p1->show();
delete b1;
delete d1;
return 0;
}
5.原型模式
原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而不是通过实例化类来创建。这种模式通常用于需要创建复杂对象的情况，而且新对象的构建过程可能涉及复杂的操作，如数据库查询、文件 I/O 或网络请求等。
原型模式的关键在于使用原型对象作为创建新对象的模板。原型对象是被复制的对象，新对象通过对原型对象进行复制来创建。复制可以是浅复制（只复制对象本身）或深复制（复制对象以及对象所包含的所有子对象）。
在原型模式中，通常有以下几个角色：
原型（Prototype）：定义了一个克隆自身的接口。
具体原型（Concrete Prototype）：实现原型接口，负责克隆自身。
客户端（Client）：使用原型对象来创建新对象，而不是直接实例化类。
//原型模式
//原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新的对象，而不是通过类的实例化来创建对象。
class Prototype
{
public:
virtual Prototype* clone() = 0;
virtual void show() = 0;
};
class ConcreatePrototype : public Prototype
{
public:
ConcreatePrototype(std::string s1, std::string s2) :str1(s1), str2(s2) {}
ConcreatePrototype(const ConcreatePrototype& pCProtype)
{
str1 = pCProtype.str1;
str2 = pCProtype.str2;
}
public:
virtual Prototype* clone()
{
return new ConcreatePrototype(*this);
}
virtual void show()
{
std::cout << str1.c_str() << " " << str2.c_str();
}
private:
std::string str1;
std::string str2;
};
int main()
{
Prototype *p1 = new ConcreatePrototype("sdfss", "hgjhgj");
p1->show();
Prototype *p2 = p1->clone();
p2->show();
delete p1;
delete p2;
return 0;
}
扫一扫
3340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
