设计模式

Posted on 2024-04-13 • 980 words • 5 minute read

Last updated on 2024-04-26

开篇

[[https://refactoringguru.cn/design-patterns/cpp][C++常用设计模式]]

[[https://refactoring.guru/design-patterns/catalog][The Catalog of Design Patterns]] /Entered on/ [2022-05-24 二 10:39]

UML 关系：关联依赖泛化实现

用例图：客户角度描述系统功能参与者用例关UML 关系：关联依赖泛化实现

用例图：客户角度描述系统功能参与者用例关系

面向对象遵循原则单一职责里氏替换接口隔离迪米特优先使用组合而不是继承

依赖倒置开闭原则

开闭：类的改动是通过增加代码实现，而不是源代码

依赖倒置：依赖抽象（接口），不要依赖具体类

单一职责：一个类只负责一项职责（职责扩散），引起类变化的原因只有一个

接口隔离：一个接口只提供一种对外功能

里氏替换：任何抽象类出现的地方都可以用他的实现进行替换

迪米特：一个对象应该对其他对象有尽可能少的了解，例如一个程序中，各个模块相互调用时，通常会提供一个统一的接口来实现

类A进行功能增强：修改类，继承，指针传递，obj汇编

多态：使用后来人写的代码(框架的例子：见demo02)

传统设计模式倾向于使用高层次的模块依赖于低层次的模块，抽象层依赖于具体的层次

两个人都往抽象层靠，实现业务和实现层的解耦合

23种设计模式

** 结构型(将对象和类组装成较大的结构) | 适配器 | 桥接 | 组合 | 装饰 | 外观 | | 享元 | 代理 |

** 行为模式(负责对象间的高效沟通和委派) | 责任链 | 命令 | 迭代器 | 中介者 | 备忘录 | | 观察者 | 状态 | 策略 | 模板方法 | 访问者 |

demo c++

创建单例模式

//保证一个类，只有一个实例存在，同时提供对该实例加以全局访问方法
#include <iostream>
using namespace std;

//使用：多个线程，只初始化一次资源；；整个程序空间使用全局变量，共享资源；；大规模系统，考虑为创建对象节省时间
//步骤：构造函数私有化；提供一个全局的静态方法；类中定义一个指针，指向本类的变量的静态变量指针

//懒汉式
class singleton{
 public:
   static singleton *getinstance() {
     if(m_single = NULL)
       m_single = new singleton;
     return m_single;
   }
  static singleton *freeinstance() {
     if(m_single != NULL)
       delete m_single;
     m_single = NULL;
   }
 private:
   singleton() {
     cout << "singleton 构造函数执行" << endl;
   }
   static singleton *m_single;
};

//静态变量初始化要放在类外面
singleton *singleton::m_single = NULL;
//恶汉式：不管调不调用，都new一个新的
//singleton *singleton::m_single = new singleton;


void main11() {
  singleton *p1 = singleton::getinstance();
  singleton *p2 = singleton::getinstance();
  if(p1 == p2)
    cout << "同一个对象" << endl;
  else
    cout << "不是同一个对象" << endl;

}

int main() {
  main11();
  return 1;
}

创建原型模式

//原型模式主要面对“某些结构复杂的对象”的创建工作，这些对象经常面临剧烈的变化，却拥有比较稳定一致的接口（自我复制功能）
#include <iostream>
#include <cstring>
using namespace std;

class person {
public:
  virtual person* clone() = 0;
  virtual void prinT() = 0;
  virtual void setresume(char *p) = 0;
};

class CPro :public person{
public:
  CPro() {
    m_name = "";
    m_age = 0;
    m_resume = "abcd";
  }
  CPro(string name, int age) {
    m_name = name;
    m_age =age;
    m_resume = "abcd";
  }
  virtual person* clone() {
    CPro *tmp = new CPro;
    *tmp = *this;
    return tmp;
  }
  void setresume(char *p) {
    if (m_resume != NULL) {
      delete m_resume;
    }
  m_resume = new char[strlen(p)+1];
  strcpy(m_resume,p);
  }
  virtual void prinT() {
    cout << "c++ programmer name is " << m_name << endl;
    cout << "c++ programmer age is " << m_age << endl;
    cout << "c++ programmer resume is " << m_resume << endl;
  }
private:
  string m_name;
  int m_age;
  char *m_resume;
};

class JavaPro {

};

int main() {
  person *c1 = new CPro("张三",23);
  c1->prinT();
  person *c2 = c1->clone();
  c2->prinT();
  return 1;
}

创建简单工厂模式

//一个类创建其他类。工厂类可以根据外界给定的信息，决定创建哪个具体类对象。工厂类包含逻辑判断，“高内聚”方面做的不好。但是当出现产品类型增多的情况时，可能要求工厂类做相应修改，扩展性不好
//“高内聚”：增加种类需要修改工厂代码，不符合开闭原则

#include <iostream>
#include <cstring>
using namespace std;

class Fruit {
public:
  virtual void getfruit() = 0;
};

class banana : public Fruit {
public:
  virtual void getfruit() {
  cout << "我是香蕉" << endl;
  }
};

class apple : public Fruit {
public:
  virtual void getfruit() {
  cout << "我是苹果" << endl;
  }
};

class Factory {
public:
  Fruit * create(char *p) {
    if (strcmp(p, "banana") == 0) {
      return new banana;
    }
    else if (strcmp(p,"apple") == 0) {
      return new apple;
    }
    else
      cout << "不支持" << endl;
  }
};


int main() {
  Factory *f = new Factory;
  Fruit *fruit = NULL;


  fruit = f->create("apple");
  fruit->getfruit();
  delete fruit;

  return 1;
}

创建抽象工厂模式

//工厂模式只能生产一个产品，抽象工厂可以生产一个产品族
#include <iostream>
using namespace std;

class fruit {
public:
  virtual void sayname() = 0;
};

class Absfactory {
public:
  virtual fruit* createapple() = 0;
  virtual fruit* createbanana() = 0;
};


class northbanana : public fruit
{
public:
  virtual void sayname()
  {
    cout << "北方香蕉" << endl;
  }
};


class northapple : public fruit
{
public:
  virtual void sayname()
  {
    cout << "北方苹果" << endl;
  }
};

class southbanana : public fruit
{
public:
  virtual void sayname()
  {
    cout << "南方香蕉" << endl;
  }
};

class southapple : public fruit
{
public:
  virtual void sayname()
  {
    cout << "南方苹果" << endl;
  }
};

class southfactory : public Absfactory {
public:
  virtual fruit* createapple() {
    return new southapple;
  }
  virtual fruit* createbanana() {
    return new southbanana;
  }
};

int main() {
  Absfactory *fac = NULL;
  fruit *fru = NULL;

  fac = new southfactory;
  fru = fac->createapple();
  fru->sayname();
  delete fru;
  fru = fac->createbanana();
  fru->sayname();
  delete fru;

  delete fac;
  delete fru;
  return 1;
}

创建建造者模式

//一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离
#include <iostream>
#include <cstring>
using namespace std;

class house {
public:
  void setdoor(string door) {
    this->m_door = door;
  }
  void setwall(string wall) {
    this->m_wall = wall;
  }

  void setwindow(string window) {
    this->m_window = window;
  }

  void getdoor() {
    cout << m_door << endl;
  }

  void getwall() {
    cout << m_wall << endl;
  }

  void getwindow() {
    cout << m_window << endl;
  }

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

class builder {
public:
  virtual void buildwall() = 0;
  virtual void builddoor() = 0;
  virtual void buildwindow() = 0;
  virtual house* gethouse() = 0;
};

class abuilder:public builder {
public:
  abuilder() {
    m_house = new house;
  }
  virtual void buildwall() {
    m_house->setdoor("a wall");
  }
  virtual void builddoor() {
    m_house->setwall("a door");
  }
  virtual void buildwindow() {
    m_house->setwindow("a window");
  }
  virtual house* gethouse() {
    return m_house;
  }
private:
  house *m_house;
};


class bbuilder:public builder {
public:
  bbuilder() {
    m_house = new house;
  }
  virtual void buildwall() {
    m_house->setdoor("b wall");
  }
  virtual void builddoor() {
    m_house->setwall("b door");
  }
  virtual void buildwindow() {
    m_house->setwindow("b window");
  }
  virtual house* gethouse() {
    return m_house;
  }
private:
  house *m_house;
};



//设计师负责建造逻辑
//建筑队负责具体的活
class director {
public:
  director(builder * build) {
    m_build = build;
  }
  void constructor() {
    m_build->buildwall();
    m_build->builddoor();
    m_build->buildwindow();
  }
private:
  builder * m_build;
};



int main()
{
  house *house = NULL;
  builder *bc = NULL;
  director *dc = NULL;

  bc = new bbuilder;
  dc = new director(bc);
  dc->constructor();

  house = bc->gethouse();
  house->getdoor();

  return 1;
}

结构适配器模式

//将一个类的接口转换为客户希望的另一个接口，使得原本由于不兼容而不能一起工作的那些类可以一起工作

#include <iostream>
using namespace std;

//current18
//current220
//adapter
class current18 {
public:
  virtual void usecurrent18v() {
    cout << "我是18v" << endl;
  }
};

class current220 {
public:
   virtual void usecurrent18v() {
    cout << "我是220v" << endl;
  }
};

class adapter: public current18 {
public:
  adapter(current220 *current) {
    m_current = current;
  }
  virtual void usecurrent18v() {
    cout << "适配器" << endl;
    m_current->usecurrent18v();
  }
private:
  current220 *m_current;
};

int main() {
  current220 *p = NULL;
  adapter *adap = NULL;

  p = new current220;
  adap = new adapter(p);

  adap->usecurrent18v();
  return 1;
}

Wxf`s Fantasy World

share something useful

设计模式

开篇

demo c++

创建单例模式

创建原型模式

创建简单工厂模式

创建抽象工厂模式

创建建造者模式

结构适配器模式

设计模式

开篇

demo c++

创建 单例模式

创建 原型模式

创建 简单工厂模式

创建 抽象工厂模式

创建 建造者模式

结构 适配器模式

创建单例模式

创建原型模式

创建简单工厂模式

创建抽象工厂模式

创建建造者模式

结构适配器模式