设计模式迪米特原则

#include <iostream>
using namespace std;
#include <string>
#include <vector>
 
//迪米特法则 又叫最少知识原则
class AbstractBuilding {
public:
    virtual void sale() = 0;
    virtual string getQuality() = 0;
};
 
//楼盘A
class BuildingA : public AbstractBuilding {
public:
    BuildingA() {
        mQuality = "高品质";
    }
    virtual void sale() {
        cout << "楼盘A" << mQuality << "被售卖！" << endl;
    }
    virtual string getQuality() {
        return mQuality;
    }
public:
    string mQuality;
};
 
//楼盘B
class BuildingB : public AbstractBuilding {
public:
    BuildingB() {
        mQuality = "低品质";
    }
    virtual void sale() {
        cout << "楼盘B" << mQuality << "被售卖！" << endl;
    }
    virtual string getQuality() {
        return mQuality;
    }
public:
    string mQuality;
};
 
/*
//客户端调用
//这里没有用到抽象类 客户与BuildingA和B直接发生了交互
void test01() {
    //创建一个BuildingA对象
    BuildingA* ba = new BuildingA;
    //直接用BuildingA对象去访问其内存的成员变量和成员函数
    //在BuildingA中去寻找低品质楼盘
    if (ba->mQuality == "低品质") {
        ba->sale();
    }
    //同样的道理在BuildingB中去寻找低品质楼盘
    BuildingB* bb = new BuildingB;
    if (bb->mQuality == "低品质") {
        bb->sale();
    }
}
*/
 
//中介类
//这个类中提供了一个接口 
//让用户不再需要创建BuildingA或BuildingB对象
class Mediator {
public:
    Mediator() {
        //这里用抽象类指针对象去接收BuildingA和BuildingB
        //然后把两个对象压入vector容器里
        AbstractBuilding* building = new BuildingA;
        vBuilding.push_back(building);
 
        building = new BuildingB;
        vBuilding.push_back(building);
    }
 
    //对外提供接口
    AbstractBuilding* findMyBuilding(string quality) {
        //遍历容器                               // 说明it 中放的是 AbstractBuding * 类型；
        for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
            //*it就是building对象 因为是一个指针 用->通过抽象类对象访问BuildingA和BuildingB的getQuality实现
            //如果得到的品质返回值与传入参数相同 就返回这个品质
            if ((*it)->getQuality() == quality) {  // 说明 it 是指针的指针 ，it 指向了对象的指针  zane
                return *it;
            }
        }
        //如果遍历没有找到匹配的返回值 就返回空
        return NULL;
    }
    //析构函数
    ~Mediator() {
        //遍历容器 不等于空就删除 手动释放堆区内容
        for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
            if (*it != NULL) {
                delete* it;          // 释放 it变量没有意义，使用释放掉 it 所指的对象所以 delete* it;  zane
            }
        }
    }
public:
    //创建一个vector成员变量 是抽象类指针类型的
    //作为一个接口去访问它的子类存在vector中
    vector<AbstractBuilding*>vBuilding;
};
 
//客户端
//这里使用了中介Mediator类 
//不需要与BuildingA或者BuildingB直接交互
//而是通过抽象类接口
void test02() {
    //创建一个中介类对象
    Mediator* mediator = new Mediator;
    //直接通过中介类对象去的成员函数去找高品质楼盘 用一个抽象类指针接收
    AbstractBuilding* building = mediator->findMyBuilding("高品质");
    //不等于空便是找到 于是用抽象类指针去访问BuildingA或者BuildingB内部的成员函数
    if (building != NULL){
        building->sale();
    }
    else {
        //等于空即没有找到
        cout << "没有符合您条件的楼盘！" << endl;
    }
}
int main() {
    test02();
    //输出结果：楼盘A高品质被售卖！
    return 0;
}

总结：当要开发一个子系统的时候 最少知识原则说不要把主系统的所有细节都暴露给子系统 只要暴露一个接口就可以了 就好比这里客户去选择楼盘 可以想象一下 客户不需要去一家一家的实地考察每一个楼盘 只要通过一个中介接口 了解到哪些是高品质楼盘即可达到目的