C++设计模式 | 概述及面向对象设计原则

概述

设计模式是在特定环境下人们解决某类重复出现问题的一套成功或有效的解决方案。

软件设计模式的种类：
创建型(Creational)模式： 如何创建对象；
结构型(Structural )模式： 如何实现类或对象的组合；
行为型(Behavioral)模式： 类或对象怎样交互以及怎样分配职责。

设计模式目前种类： GoF的23种 + “简单工厂模式” = 24种。

学习设计模式将有助于更加深入地理解面向对象思想, 让你知道：
1. 如何将代码分散在几个不同的类中？
2. 为什么要有“接口”？
3. 何谓针对抽象编程？
4. 何时不应该使用继承？
5. 如果不修改源代码增加新功能？
6. 更好地阅读和理解现有类库与其他系统中的源代码。

设计模式的基础是：多态

设计模式总览表

面向对象设计原则

对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的可复用性是一个至关重要的问题，如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。在面向对象设计中，可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，可以从不同的角度提升一个软件结构的设计水平。

面向对象设计原则为支持可维护性复用而诞生，这些原则蕴含在很多设计模式中，它们是从许多设计方案中总结出的指导性原则。面向对象设计原则也是我们用于评价一个设计模式的使用效果的重要指标之一。

原则的目的： 高内聚，低耦合

迪米特法则

里氏代换原则就是使用多态的意思

依赖倒转原则就是面向抽象类编程

合成复用原则意思是多用组合少用继承

开闭原则案例

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

//计算器类
class Caculaor{
public:
    Caculaor(int a, int b, string moperator){
        this->m_a = a;
        this->m_b = b;
        this->m_operator = moperator;
    }

    int getResult(){
        
        if (m_operator.compare("+") == 0){
            return m_a + m_b;
        }
        else if (m_operator.compare("-") == 0){
            return m_a - m_b;
        }
        else if (m_operator.compare("*") == 0){
            return m_a * m_b;
        }
        else if (m_operator.compare("/") == 0){
            return m_a / m_b;
        }

    }

private:
    int m_a;
    int m_b;
    string m_operator;
    int m_ret;
};

/*
    缺点： 如果增加取模的运算 需要修改getResult成员方法，如果增加新功能的情况下要修改源代码，那么
    就会有修改出错的可能性。我们应该在增加新的功能时候，不能影响其他已经完成的功能。这就是对修改关闭，
    对扩展开放，叫做开闭原则

*/

void test01(){
    Caculaor* caculator = new Caculaor(10, 20, "+");
    cout << caculator->getResult() << endl;
}



/* 计算器 开闭原则 start */

//计算器的抽象类
class AbstractCaculator{
public:
    AbstractCaculator(int a,int b) :m_a(a), m_b(b){}
    virtual int getResult() = 0;
protected:
    int m_a;
    int m_b;
};

//加法类
class Plus : public AbstractCaculator{
public:
    Plus(int a, int b) :AbstractCaculator(a, b){}
    virtual int getResult(){
        return m_a + m_b;
    }
};

//减法类
class Minute : public AbstractCaculator{
public:
    Minute(int a, int b) :AbstractCaculator(a, b){}
    virtual int getResult(){
        return m_a - m_b;
    }
};


void test02(){
    
    AbstractCaculator* caculator = NULL;
    caculator = new Plus(10,20);
    cout << caculator->getResult() << endl;

    delete caculator;

    caculator = new Minute(10,20);
    cout << caculator->getResult() << endl;

}

/* 计算器 开闭原则 end */

int main(){

    //test01();
    test02();

    system("pause");
    return EXIT_SUCCESS;
}

迪米特法则案例

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


//楼盘基类
class AbstractBuilding{
public:
    AbstractBuilding(string quality) :m_quality(quality){}
    virtual void sale() = 0;
    string getQuality(){
        return m_quality;
    }
protected:
    string m_quality; //楼盘品质
};

//A楼盘
class BuildingA : public AbstractBuilding{
public:
    BuildingA(string quality) :AbstractBuilding(quality){}
    virtual void sale(){
        cout << "A楼盘售卖" << m_quality << "的房子" << endl;
    }
};

//B楼盘
class BuildingB : public AbstractBuilding{
public:
    BuildingB(string quality) :AbstractBuilding(quality){}
    virtual void sale(){
        cout << "B楼盘售卖" << m_quality << "的房子" << endl;
    }
};

//房屋中介
class BuildingMediator{
public:
    BuildingMediator(){
        
        AbstractBuilding* building = NULL;
        building = new BuildingA("低档品质");
        this->addNewBuilding(building);

        building = new BuildingB("高档品质");
        this->addNewBuilding(building);

    }
    void addNewBuilding(AbstractBuilding* building){
        m_list.push_back(building);
    }
    AbstractBuilding* findBuilding(string quality){
        for (list<AbstractBuilding*>::iterator it = m_list.begin(); it != m_list.end();it ++){
            if ((*it)->getQuality().compare(quality) == 0){
                return *it;
            }
        }

        return NULL;
    }
private:
    list<AbstractBuilding*> m_list;
};

void test01(){
    
    BuildingMediator* mediator = new BuildingMediator;
    AbstractBuilding* building =  mediator->findBuilding("高档品质");
    if (building != NULL){
        building->sale();
    }
    else{
        cout << "没有符合要求的楼盘!" << endl;
    }
    
}



int main(){

    test01();


    system("pause");
    return EXIT_SUCCESS;

合成复用原则案例

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

class Car {
public:
    virtual void run() = 0;
};

class BWMCar : public Car{
public:
    virtual void run(){
        cout << "宝马车启动..." << endl;
    }
};

class DazhongCar : public Car{
public:
    virtual void run(){
        cout << "大众车启动..." << endl;
    }
};

class PersonA : public BWMCar{
public:
    void drive(){
        run();
    }
};

void test01(){
    
    PersonA* person = new PersonA;
    person->drive();

}

/*
    合成复用原则
    对于继承和组合 优先使用组合
*/
class PersonB{
public:
    PersonB(Car* car){
        pCar = car;
    }
    void drive(){
        pCar->run();
    }
    ~PersonB(){
        if (pCar != NULL){
            delete pCar;
        }
    }
private:
    Car* pCar;
};

void test02(){

    PersonB* person = new PersonB(new BWMCar);
    person->drive();
    delete person;

    person = new PersonB(new DazhongCar);
    person->drive();
    delete person;
}

int main(){

    //test01();
    test02();


    system("pause");
    return EXIT_SUCCESS;

依赖倒转原则案例

传统的设计模式通常是自顶向下逐级依赖，这样，底层模块，中间层模块和 高层模块的耦合度极高，若任意修改其中的一个，很容易导致全面积的修改，非 常麻烦，那么依赖倒转原则利用多态的先天特性，对中间抽象层进行依赖，这样， 底层和高层之间进行了解耦合。

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

class BankWorker{
public:
    void payService(){
        cout << "办理付款业务" << endl;
    }
    void transferService(){
        cout << "办理转账业务" << endl;
    }
    void  saveService(){
        cout << "办理存款业务" << endl;
    }
};

void test01(){
    
    BankWorker* worker = new BankWorker;
    worker->payService();//存款业务
    worker->saveService(); //存款业务
    worker->transferService();//转账业务

}

//依赖倒转原则
//抽象层
class AbstractWorkerBank{
public:
    virtual void doBussiness() = 0;
};

//只办理存款业务
class SaveBankWorker : public  AbstractWorkerBank{
public:
    virtual void doBussiness(){
        cout << "办理存款业务" << endl;
    }
};

//只办理转账业务
class TransferBankWorker : public  AbstractWorkerBank{
public:
    virtual void doBussiness(){
        cout << "办理存款业务" << endl;
    }
};

//只办理付款业务
class PayBankWorker : public  AbstractWorkerBank{
public:
    virtual void doBussiness(){
        cout << "办理存款业务" << endl;
    }
};

//高层模块
void DoBankBussiness(AbstractWorkerBank* worker){
    worker->doBussiness();
    delete worker;
}

void test02(){
    
    DoBankBussiness(new SaveBankWorker); //办理存款业务
    DoBankBussiness(new TransferBankWorker); //办理转账业务
    DoBankBussiness(new PayBankWorker); //办理付款业务

}
int main(){

    //test01();
    test02();

    system("pause");
    return EXIT_SUCCESS;
}