3、创建型模式

最新推荐文章于 2020-12-29 02:22:33 发布
原创 最新推荐文章于 2020-12-29 02:22:33 发布 · 147 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1、单列模式
实现常用步骤
（1）构造函数私有化
（2）提供一个全局的静态方法
（3）在类中定义一个静态指针，指向本来的变量的静态变量指针


//懒汉模式
class Singelton
{
public:
    static Singelton* getInstace() 
    {
        if (sl==NULL)
        {
            sl = new Singelton();
        }
        return sl;
    }
    static void freeInstance() 
    {
        if (sl!=NULL)
        {
            delete sl;
            sl = NULL;
            cout << "free" << endl;
        }
    }
private:
    static Singelton * sl;
    Singelton() 
    {
        cout << "构造函数" << endl;
    }
};

 Singelton * Singelton::sl = NULL;

void test01()
{

    Singelton * s1 = Singelton::getInstace();
    Singelton * s2 = Singelton::getInstace();

    if (s2==s1)
    {
        cout << "是同一个对象" << endl;
    }
    else
    {
        cout << "不是同一个对象" << endl;
    }

    Singelton::freeInstance();

    cout << "------------------------------------" << endl;
}

//饿汉模式
class Singelton
{
public:
    static Singelton* getInstace()
    {
        return sl;
    }
    static void freeInstance()
    {
        if (sl != NULL)
        {
            delete sl;
            sl = NULL;
            cout << "free" << endl;
        }
    }
private:
    static Singelton * sl;
    Singelton()
    {
        cout << "构造函数" << endl;
    }
};
// 不管三七二十一 new出来
Singelton * Singelton::sl = new Singelton(); 为啥能在类外访问 : 在类的作用域下能访问类的所有成员
//相当于一个全局变量，在全局区

void test01()
{

    Singelton * s1 = Singelton::getInstace();
    Singelton * s2 = Singelton::getInstace();

    if (s2 == s1)
    {
        cout << "是同一个对象" << endl;
    }
    else
    {
        cout << "不是同一个对象" << endl;
    }

    Singelton::freeInstance();

    cout << "------------------------------------" << endl;
}

多线程下的懒汉模式

解决双重判定 和加锁

static Singleton *Instantialize()
    {
        if(pInstance == NULL)  //double check 
        {   
            cs.Lock(); //只有当pInstance等于null时，才开始使用加锁机制 二次检查
            if(pInstance == NULL)
            {
                pInstance = new Singleton(); 
            }
            cs.Unlock();
        }
        return pInstance;
    }
    static Singleton *pInstance;

简单工厂模式
这里写图片描述


class Maker
{
public:
    virtual void getName() = 0;

};

class MakerSon:public Maker
{
public:
    virtual void getName() {
        cout << "Maker son" << endl;
    }
}; 

class MakerGirl :public Maker
{
public:
    virtual void getName() {
        cout << "Maker girl" << endl;
    }
}; 

//工厂
class Factory
{
public:

    Maker *create(char *s) 
    {
        if (strcmp(s,"son")==0)
        {
            return new MakerSon;
        }
        else if(strcmp(s,"girl")==0)
        {
            return new MakerGirl;
        }else
        return NULL;
    }
};

void test01()
{
    Factory f;
    Maker *m = NULL;
    m=f.create("girl");
    m->getName();
    delete m;
    cout << "------------------------------------" << endl;
}

简单工厂模式不符合高内聚
工厂模式
这里写图片描述


//抽象类
class Maker
{
public:
    virtual void getName() = 0;

};

//具体类
class MakerSon :public Maker
{
public:
    virtual void getName() {
        cout << "Maker son" << endl;
    }
};
//具体类
class MakerGirl :public Maker
{
public:
    virtual void getName() {
        cout << "Maker girl" << endl;
    }
};

//抽象工厂
class AbFactory
{
public:
    virtual Maker* CreateProduct() = 0;

};

//具体工厂
class GirlFactory:public AbFactory
{
public:
    virtual Maker* CreateProduct() 
    {
        return new MakerGirl();
    };

};
//具体工厂
class SonFactory :public AbFactory
{
public:
    virtual Maker* CreateProduct()
    {
        return new MakerSon();
    };

};

void test01()
{
    AbFactory * abfac = NULL;
    Maker * maker = NULL;
    abfac = new SonFactory;
    maker=abfac->CreateProduct();
    maker->getName();


    abfac = new GirlFactory;
    maker = abfac->CreateProduct();
    maker->getName();

    delete abfac;
    delete maker;
    cout << "------------------------------------" << endl;
}

工厂模式 ：只能生产一个产品，
抽象工厂模式：可以一下生产一个商品族
这里写图片描述


//抽象类
class Fruit
{
public:
    virtual void sayname() = 0;

};

//抽象工厂
class AbstractFactory
{
public:
    //依赖 fruit
    virtual Fruit * CreateBanana() = 0;
    virtual Fruit * CreateApple() = 0;
};


//北方香蕉
class NorthBanana:public Fruit
{
public:
    virtual void sayname() 
    {
        cout << "我是北方香蕉" << endl;
    }
};

class NorthApple:public Fruit
{
public:
    virtual void sayname()
    {
        cout << "我是北方苹果" << endl;
    }


};

class  SourthBanan:public Fruit
{
public:
    virtual void sayname()
    {
        cout << "我是南方香蕉" << endl;
    }

};

class SourthApple :public Fruit
{
public:
    virtual void sayname()
    {
        cout << "我是南方苹果" << endl;
    }

};


class NorthFacorty :public AbstractFactory
{
public:
    virtual Fruit * CreateBanana() 
    {
        return new NorthBanana;
    }
    virtual Fruit * CreateApple() 
    {
        return new NorthApple;
    }

};


class SourthFacorty:public AbstractFactory
{
public:
    virtual Fruit *CreateBanana() 
    {
        return new SourthBanan;
    }

    virtual Fruit * CreateApple() 
    {
        return new SourthApple;
    }
};



void test01()
{
    AbstractFactory * fact = NULL;
    Fruit * fruit = NULL;

    fact = new SourthFacorty;
    fruit=fact->CreateBanana();
    fruit->sayname();
    fact->CreateApple();
    fruit->sayname();

    cout << "------------------------------------" << endl;
    fact = new NorthFacorty;
    fruit = fact->CreateBanana();
    fruit->sayname();
    fact->CreateApple();
    fruit->sayname();
}

创建者模式
使用场景：一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。
这里写图片描述
1) Builder：为创建产品各个部分，统一抽象接口。
2) ConcreteBuilder：具体的创建产品的各个部分，部分A， 部分B，部分C。
3) Director：构造一个使用Builder接口的对象。
4) Product：表示被构造的复杂对象。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
这里写图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

#define MAX 100

class House
{
public:
    void setDoor(string door) 
    {
        this->m_door = door;
    }

    string getDoor() 
    {
        cout << m_door << endl;
        return this->m_door;
    }
    void setWall(string wall) 
    {
        this->m_wall = wall;
    }
    string getWall() 
    {
        cout << m_wall << endl;
        return this->m_wall;
    }
    void setWindow(string window) 
    {
        this->m_window = window;
    }
    string getWindow() 
    {
        cout << m_window << endl;
        return this->m_window;
    }


private :
    string m_door;
    string m_wall;
    string m_window;
};

//抽象    工厂队
class Builder
{
public:
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildDoor() = 0;
    virtual House * getHouse() = 0;
};

//公寓工厂队
class FlatBuilder:public Builder
{
public:

    FlatBuilder() 
    {
        house = new House;
    }
    virtual void buildWall() 
    {
        house->setWall("flat  wall");
    }
    virtual void buildWindow()
    {
        house->setWindow("flat window");
    }
    virtual void buildDoor()
    {
        house->setDoor("flat door");
    }
    virtual House * getHouse() 
    {
        return house;
    }

private:
    House * house;
};

//设计师
//建筑队  具体干的活


class Director
{
public:
    Director(Builder *build) 
    {
        m_build = build;
    }

    void Construct() 
    {
        m_build->buildDoor();
        m_build->buildWall();
        m_build->buildWindow();
    }

private:
    Builder * m_build;
};


void test01()
{
    House *house = NULL;
    Builder *builder = NULL;
    Director * dir = NULL;

    builder = new FlatBuilder;

    dir = new Director(builder);
    dir->Construct();

    house = builder->getHouse();
    house->getDoor();
    house->getWall();
    house->getWindow();


    cout << "------------------------------------" << endl;
}


int main()
{
    test01();

    system("pause");
    return 0;
}

原型模式
为每一个对象提供一个接口，让一个复杂的对象具有自我复制的功能
一个复杂的对象，具有自我复制的功能 ，统一一套接口
这里写图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

#define MAX 100

class Person
{
public:
    virtual Person *clone() = 0;
    virtual void print() = 0;
};


class MyPerson:public Person
{
public:
    MyPerson() 
    {
        this->age = 0;
        this->name = "";
    };
    MyPerson(int age,string name)
    {
        this->age = age;
        this->name =name;
    };
    virtual Person *clone() 
    {

        MyPerson *tmp = new MyPerson;
        *tmp = *this;//==tmp->name =this->name;   tmp->age=this->age;//给成员指针开辟空间---记得
        return tmp;

    };
    virtual void print() 
    {
        cout <<"age="<< age<<"name="<<name << endl;
    };


private :
    int age;
    string name;
    //char * desc;  浅拷贝问题
};


void test01()
{

    Person *pers = new MyPerson(20,"hhah");
    pers->print();

    Person * cpy=pers->clone();
    cpy->print();

    cout << "------------------------------------" << endl;
}


int main()
{
    test01();



    system("pause");
    return 0;
}
TObject简要说明-对象的创建流程
在0与1之间的博客
12-08 1046
 TObject = class    //创建    constructor Create;    //释放    procedure Free;    //初始化实列    class function InitInstance(Instance: Pointer): TObject;    //清除实列    procedure CleanupInstance;    //获得类的类型   
单实例类的写法
yinxiaohui0212的博客
04-09 577
单实例类的写法 设计模式中有一种单实例设计模式，如果程序中有一些类只希望声明一个实例，比如写日志、读取配置文件等类，则可以将这些类定义为单实例类，其写法参考下面代码： #include <iostream> using namespace std; class CConfigFile { private: CConfigFile() { m_pInstance = NULL; }; // 构造函数定义成私有，防止声明类对象 // 类中嵌套类FreeInstance，用于释放 new出来的
FreeInstanceSharer:轻松的《魔兽世界》附加组件，可将您保存的实例共享给其他人
04-02
FreeInstanceSharer 一个轻松的《魔兽世界》插件，可以将您保存的锁定信息分享给其他人。 介绍 当收到预设的游戏内耳语或Battle.net消息时，通过邀请其他玩家来分享您保存的锁定，以及其他支持功能。 邀请向您发送预设消息的用户。 自动扩展您愿意共享的已保存锁定。 允许用户通过聚会聊天更改难度。 当您处理多个用户时，请对用户进行排队。 设置时间限制以等待玩家进入实例。 允许用户邀请他们的朋友加入聚会。 自定义您自己的消息。 贡献 将请求拉至该项目。 执照 麻省理工学院执照
[转]delphi中关于资源释放（Free/release/freeAndNil）的一点体会
嵌入式系统,linux,存储
03-17 1544
[转]delphi中关于资源释放（Free/release/freeAndNil）的一点体会 经过这段时间对delphi中free 和 release 的仔细学习，先总结如下：1。form.free直接释放资源后，调用OnDestroy事件，但是没有将form指针改为nil2。form.release 等待资源不再使用后释放资源，同样不修改form指针为nil，所以在destroy中最好使用 
CVPR2020: CenterMask:Real-Time Anchor-Free Instance Segmentation 阅读随笔
mathlxj的博客
03-18 1250
设计模式之创建型模式实验.docx
12-15
【设计模式之创建型模式实验】 创建型设计模式主要关注对象的创建，它们提供了一种在不指定具体类的情况下创建对象的方式，增强了系统的灵活性和可扩展性。在本实验中，我们将探讨五种常见的创建型设计模式：简单...
设计模式原理与应用之创建型模式.pptx
09-28
创建型模式是设计模式中的一个重要类别，它关注于对象的创建过程，帮助开发者封装创建细节，使系统独立于具体对象的创建方式。 1. **Singleton（单例模式）** 单例模式确保一个类只有一个实例，并提供全局访问点...
创建型设计模式.doc
12-15
原型模式是一种创建型模式，通过复制已有对象来创建新对象，避免了创建新对象的复杂过程。文件中提到克隆图形对象，比如圆形和矩形，这可以通过实现 `Cloneable` 接口并重写 `clone()` 方法来实现。当需要创建多个...
软件设计模式之创建型模式培训课件.ppt
最新发布
07-17
创建型模式是软件设计模式中的一类，主要用于对象的创建，它提供了一种在不指定创建对象的具体类的情况下创建对象的方法。创建型模式主要包括单例模式、抽象工厂模式、工厂方法模式、建造者模式和原型模式。它们在...
5种Java经典创建型模式详解
09-02
【Java 创建型模式详解】 创建型模式是设计模式中的一个重要类别，主要关注对象的创建过程，旨在解决如何在代码中优雅地创建对象的问题，降低耦合性，提高系统的可扩展性和可维护性。以下是五种Java经典创建型模式...
Java对象创建之new关键字和newinstance()方法
热门推荐
luckykapok918的专栏
12-05 1万+
new和newinstance()区别      在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别?它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。 　　Java中工厂模式经常使用newInstan
cd: 文件夹 : 不是目录_【攻略】公益CD插件版新增百度网盘下载地址！
weixin_39522423的博客
12-29 5738
魔兽世界第一幻化交流群公益CD插件版正式上线后，好多人下载解压后发现无法加载插件，凡是加载不了的，全部都是拷贝的文件夹拷贝错了，请注意看文件夹的名称，凡是带8.3.3尾缀的都不是正确的文件夹，需要打开这个文件夹后拷贝里面的那个不带8.3.3的文件夹！另外下载地址也增加一个百度网盘，从NGA无法下载的朋友们，可以从百度网盘进行下载！NGA下载地址：https://img.nga.178.c...
打破牢笼，展望更高层次的世界
weixin_34336292的博客
03-16 115
http://www.cnblogs.com/xdesigner/p/6552745.html *************************************************   打破牢笼，展望更高层次的世界 --------------------------------------------------------------     笔者袁永福是一个十多年的老程序猿出...
Instance Segmentation 和 Semantic Segmentation
l_b_yuan的博客
12-29 7713
本文转自： https://www.zhihu.com/question/51704852 周博磊 MIT博士在读, AI and Computer Vision 收录于 编辑推荐 •217 人赞同 最近也在做跟这个相关的问题，来分享一下自己的见解． 图1. 这张图清楚说明了image classification, object detection, semantic segmentat
单例模式
lzjsqn的专栏
11-22 657
单例模式单例模式 基本概念 使用场景 实现步骤 懒汉式单例模式 饿汉式单例模式 多线程下的单例模式 懒汉式单例模式的多线程改进 关于程序并发机制 总结基本概念　　单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。在代码上表现为整个程序中只调用一次该类的构造函数。 　　GoF对单例模式的定义是：保证一个类、只有一个
用Activator.CreateInstance代替new实现类的实例化（转）
weixin_30455365的博客
06-28 1482
一直想得到这样一个函数,输入一个类的名称为参数,返回一个相应的类的实例. 这在工厂模式中是非常有用的 这样,可以使程序有更高的扩展性,例如,,下面的例子 如果现在有一个类,专门用来计算交通工具的速度,不同的交通工具计算方法是不一样的,但是到底有那些交通工具是未知的或者是可变的,这种情况下,我们可能觉得要在添加交通工具的时候,需要修改用来计算速度的那个类, 但如果用Activato...
极简笔记 Instance Segmentation Survey
Hibercraft的博客
07-08 2711
极简笔记 Instance Segmentation Survey 本篇包含多篇实例分割论文笔记，因为大多都是较为早远的论文，因此每篇笔记奉行极简原则，在叙述大意的同时，尽量缩短篇幅。 Instance-aware Semantic Segmentation via Multi-task Network Cascades (MNC) Jifeng Dai, Kaiming He较早的实例分割...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值