2. 程式人生 > 實用技巧 >幾種設計模式

幾種設計模式

阿新 • • 發佈：2020-08-06

設計模式

設計模式基礎

單一職責

為了實現高內聚，低耦合，做到職責分離，一個類只肩負一項職責

好處：提高程式碼的可讀性與可維護性。（除了類，在方法級別上亦當如此）

開閉原則

對擴充套件開放，對修改關閉。

分析：使用抽象來構建框架，實現來擴充套件細節，通過新增而不是修改來實現擴充

里氏替換原則

引用父類的地方透明地使用子類物件

分析：儘量不重寫父類中已經實現的方法

依賴倒置原則

高層不應該依賴底層，兩者都應該依賴於抽象；抽象不應該依賴於細節，細節應該依賴於抽象

分析：面向介面程式設計，介面制定約束，細節交給實現類

介面隔離

介面細化，類之間的依賴關係建立在最小介面上，介面的方法儘量少，服務於一個子模組

迪米特法則

最少知道，一個實體應該儘量減少與其他實體之間的相互作用，通過第三方轉發

單例模式

  • 類的例項物件只有一個，構造器通過private修飾
  • 執行緒安全
  • 禁止賦值和拷貝
  • 使用者通過介面獲取例項的引用
Lazy-Initialization
class Singleton{
private:
    Singleton(){
        std::cout<<"constructor called!"<<std::endl;
    }
    Singleton(Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Singleton* m_instance_ptr;  //記憶體洩漏，可用智慧指標
public:
    ~Singleton(){
        std::cout<<"destructor called!"<<std::endl;
    }
    static Singleton* get_instance(){
        if(m_instance_ptr==nullptr){  //執行緒安全，可加鎖
              m_instance_ptr = new Singleton;
        }
        return m_instance_ptr;
    }
};
Singleton* Singleton::m_instance_ptr = nullptr;
區域性靜態變數
class Singleton
{
public:
    ~Singleton() {
        std::cout << "destructor called!" << std::endl;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static Singleton& get_instance() {  //返回引用
        static Singleton instance;  //初始化如有併發，執行緒將會阻塞等待初始化結束
        return instance;            //生存期從宣告到程式結束
    }                             
private:
    Singleton() {
        std::cout << "constructor called!" << std::endl;
    }
};

工廠模式

簡單工廠
  • 一個工廠，多種產品，通過傳參指定具體產品
  • 通過工廠獲取虛基類指標，執行時多型
  • 建立邏輯對客戶端隱藏
class abstractProduct {
public:
    virtual void Operation() = 0;
    virtual ~abstractProduct() {}
};
class ProductA : public abstractProduct {
public:
    void Operation() { cout << "ProductA" << endl; }
};
class ProductB : public abstractProduct {
public:
    void Operation() { cout << "ProductB" << endl; }
};
class Factory {
public:
    abstractProduct* createProduct(int id) {
        switch (id) {
        case 1: return new ProductA(); break;
        case 2: return new ProductB(); break;
        default: break;
        }
    }
};
int main() {
    Factory* f = new Factory();
    f->createProduct(1)->Operation();  
    f->createProduct(2)->Operation();  
    delete f;
    return 0;
}
工廠方法模式
  • 符合擴充套件開放，修改關閉的原則
  • 工廠方法將類的例項化延遲到子類
class abstractProduct {
public:
    virtual ~abstractProduct() {}
    virtual void Operation() = 0;
};
class ProductA : public abstractProduct {
public:
    void Operation() { cout << "ProductA" << endl; }
};
class ProductB : public abstractProduct {
public:
    void Operation() { cout << "ProductB" << endl; }
};
class abstractFactory {
public:
    virtual abstractProduct* createProduct() = 0;
};
class FactoryA : public abstractFactory {
public:
    abstractProduct* createProduct() {
        return new ProductA();
    }
};
class FactoryB : public abstractFactory {
public:
    abstractProduct* createProduct() {
        return new ProductB();
    }
};
int main() {
    abstractFactory* factory = nullptr;
    factory = new FactoryA();
    factory->createProduct()->Operation();  
    factory = new FactoryB();
    factory->createProduct()->Operation();  
    delete factory;
    return 0;
}
抽象工廠模式
  • 每個工廠類可以生產多種產品
class Cpu {  //虛基類
public:
    virtual ~Cpu() {}
    virtual void Operation() = 0;
};
class amd3700x : public Cpu {
public:
    void Operation() { cout << "3700x" << endl; }
};
class intel10700k : public Cpu {
public:
    void Operation() { cout << "10700k" << endl; }
};

class Motherboard {  //虛基類
public:
    virtual ~Motherboard() {}
    virtual void Operation() = 0;
};
class x570 : public Motherboard {
public:
    void Operation() { cout << "x570" << endl; }
};
class z490 : public Motherboard {
public:
    void Operation() { cout << "z490" << endl; }
};

class abstractFactory {  //虛基類
public:
    virtual Cpu* createProductCpu() = 0;
    virtual Motherboard* createProductMotherboard() = 0;
};
class IntelFactory : public abstractFactory {
public:
    Cpu* createProductCpu() {
        return new intel10700k();
    }
    Motherboard* createProductMotherboard() {
        return new z490();
    }
};
class AmdFactory : public abstractFactory {
public:
    Cpu* createProductCpu() {
        return new amd3700x();
    }
    Motherboard* createProductMotherboard() {
        return new x570();
    }
};
int main() {
    abstractFactory* factory = nullptr;
    factory = new AmdFactory();
    factory->createProductCpu()->Operation();
    factory->createProductMotherboard()->Operation();

    factory = new IntelFactory();
    factory->createProductCpu()->Operation();
    factory->createProductMotherboard()->Operation();
    delete factory;
    return 0;
}

觀察者模式

定義了物件間一對多的依賴關係，當一個物件的狀態發生改變時，所有依賴於它的物件都得到通知並自動更新，是一種釋出-訂閱互動.

class Observer
{
public:
    virtual void update(string info) = 0;
};

class ObserverA :public Observer
{
    void update(string info) {
        std::cout << "ObserverA:" << info << std::endl;
    }
};

class ObserverB :public Observer
{
    void update(string info) {
        std::cout << "ObserverB:" << info << std::endl;
    }
};
class object
{
public:
    object() :information("notification") {};
    void attach(Observer* observer){
        observer_list.push_back(observer);
    }
    void detach(Observer* observer){
        observer_list.remove(observer);
    }
    void notify() {
        for (auto i : observer_list) {
            i->update(information);
        }
    }
    void set_status(string info){
        information = info;
    }
private:
    list<Observer*> observer_list;
    string information;
};
int main()
{
    object* lol = new object;
    ObserverA* Huya = new ObserverA;
    ObserverB* Douyu = new ObserverB;
    lol->attach(Huya);
    lol->attach(Douyu);
    lol->set_status("League of Legends World Championship begins");
    lol->notify();
    lol->detach(Huya);
    lol->detach(Douyu);
    delete lol;
    delete Huya;
    delete Douyu;
}

介面卡模式

定義包裝類Adapter，包裝Adaptee，使得Target能夠訪問Adaptee

class Target{
public:
	virtual void Request() {}
};

class Adaptee{
public:
	void Display(){
		cout << "do something here" << endl;
	}
};

class Adapter : public Target, public Adaptee
{
public:
	void Request(){
		this->Display();
	}
};

int main()
{
	Target* p = new Adapter();
	p->Request();
	delete p;  //釋放記憶體空間
	p = nullptr;  //避免野指標
	return 0;
}

策略模式

優點：擴充套件性良好，可以自由切換

缺點：策略類會增多，而且對外暴露

/*
 Context指向Strategy (由指標實現)；
 Context通過Strategy 介面，呼叫一系列演算法；
 ConcreteStrategy 實現了一系列具體的演算法
*/
#include<iostream>
using namespace std;
class Strategy { // 抽象演算法類
public:
    virtual void AlgorithmInterface() = 0; 
    virtual ~Strategy() {}
};

class ConcreteStrategyA : public Strategy { 
public:
    void AlgorithmInterface() {
        cout << "ConcreteStrategyA" << endl;
    }
};

class ConcreteStrategyB : public Strategy { 
public:
    void AlgorithmInterface() {
        cout << "ConcreteStrategyB" << endl;
    }
};

class Context {  //上下文
private:
    Strategy* strategy;
public:
    Context(Strategy* s) { strategy = s; }
    void ContextInterface() { 
        strategy->AlgorithmInterface();
    }
};

int main() {
    Strategy* s = new ConcreteStrategyA();
    Context* c = new Context(s);
    c->ContextInterface();  
    delete s;
    delete c;
    return 0;
}

相關推薦

理解js中的幾種設計模式

目錄 工廠模式 建構函式模式 原型模式 組合使用建構函式模式和原型模式 動態原型模式

幾種設計模式

設計模式 設計模式基礎 單一職責 為了實現高內聚，低耦合，做到職責分離，一個類只肩負一項職責

常見的幾種設計模式

前言 　　以下是對常見的幾種設計模式的介紹 　　實現程式碼的github地址：https://github.com/Chenrencun/design-pattern

23種設計模式之建造者模式

1、定義 將一個複雜物件的構造與它的表示分離，使同樣的構建過程可以建立不同的表示。建造者模式是將一個複雜的物件分解為多個簡單的物件，然後一步一步構建而成。它將變與不變相分離，即產品的組成部分是不變的，但

23種設計模式之工廠方法模式、抽象工廠模式

1、簡單工廠模式（靜態工廠方法模式） 1.1 定義 定義一個工廠類，根據傳入的引數不同返回不同的例項，被建立的例項具有共同的父類或介面。23種設計模式並不包括簡單工廠模式，它更像一種程式設計習慣。

23種設計模式之組合模式

1、定義 將物件組合成樹形結構以表示“部分-整體”的層次結構。組合模式使得使用者對單個物件和組合物件的使用具有一致性。

23種設計模式之模板方法模式

1、定義 定義一個操作中的演演算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個演演算法的結構即可重定義改演演算法的某些特定步驟。模板方法模式是一種基於繼承的程式碼複用技術。

23種設計模式之橋接模式

1、定義 將抽象部分和實現部分分離，使它們都可以獨立的變化。又稱為柄體（Handle and Body）模式或者介面（Interface）模式。

23種設計模式之介面卡模式

1、定義 將一個類的介面裝換成客戶希望的另外一個介面。介面卡模式使得原來由於介面不相容而不能一起工作的那些類可以一起工作。

23種設計模式之原型模式

1、定義 用原型例項指定建立物件的種類，並且通過拷貝這些原型建立新的物件。

23種設計模式之享元模式

1、定義 運用共享技術有效地支援大量細粒度物件的複用。系統只使用少量的物件，而這些物件都很相似，狀態變化很少，可以實現物件的多次複用。由於享元模式要求能夠共享的物件必須是細粒度物件，因此又稱為輕量級模式

單分派、雙分派及兩種設計模式

什麼是單分派和雙分派 分派（dispatch） 是指按照物件的實際型別為其繫結對應方法體的過程。

23種設計模式——工廠模式

23種設計模式——工廠模式 作用 實現了建立者和呼叫者分離 詳細分類 簡單工廠模式

23種設計模式——原型模式

23種設計模式——原型模式 1.淺克隆 package com.mjh.prototype; import java.util.Date; /** * 實現一個介面Cloneable

php 23種設計模式 - 觀察者模式

觀察者模式 某個物件可以被設定為是可觀察的，只要通過某種方式允許其他物件註冊為觀察者。每當被觀察的物件改變時，會發送資訊給觀察者。

23種設計模式——橋接模式

23種設計模式——橋接模式 橋接模式 將抽象部分與它的實現部分分離，使他們都可以獨立地變化。是一種物件結構模式

二十三種設計模式修煉手冊

不知不覺，在開發這條道路上摸爬打滾也有些年頭了，偶爾回頭看看以前寫的程式碼，真可謂粗糙至極。當然了，那時候還是小白，程式碼寫得難看些情有可原，不過現在可不能再用以前的標準去衡量自己了，因此掌握一些高

23種設計模式--代理模式(動態與靜態)

目錄代理模式定義:靜態代理靜態代理再分析動態代理優點缺點 代理模式 定義:

php 23種設計模式 - 迭代器模式

迭代器模式 迭代器模式 （Iterator），又叫做遊標（Cursor）模式。提供一種方法訪問一個容器（Container）物件中各個元素，而又不需暴露該物件的內部細節。

Java設計模式之23種設計模式詳解

一、什麼是設計模式 設計模式（Design pattern）是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性。 毫無疑問