SOLID Design Principle

这是Design Patterns in C++: Creational的学习笔记，课程链接：
https://app.pluralsight.com/library/courses/design-patterns-cpp-creational/table-of-contents

文章目录

Single Responsibility Principle
Open-closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle
Dependency Injection with Boost.DI
Monads

Single Responsibility Principle

Open-closed Principle

Entities should be open for extension but closed for modification

enum class Color {Red, Green, Blue};
enum class Size {Small, Medium, Large};template <typename T> struct ISpecification
{virtual bool is_satisfied(T* item) = 0;
};template <typename T> struct IFilter
{virtual std::vector<T*> filter(std::vector<T*> items, ISpecification<T>& spec) = 0;
};struct BetterFilter : IFilter<Product>
{typedef std::vector<Product*> Items;Items filter(Items items, ISpecification<Product>& spec) override{Items result;for (auto& p : items)if (spec.is_satisfied(p))result.push_back(p);return result;}
};struct ColorSpecification: ISpecification<Product>
{Color color;explicit ColorSpecification(const Color color): color{color}{}bool is_satisfied(Product* item) override {return item->color == color;}
};struct SizeSpecification: ISpecification<Product>
{Size size;explicit SizeSpecification(const Size size): size{size}{}bool is_satisfied(Product* item) override {return item->size == size;}
};template <typename T> struct AndSpecification : ISpecification<T>
{ISpecification<T>& first;ISpecification<T>& second;AndSpecification(ISpecification<T>& first, ISpecification<T>& second): first{first},second{second}{}bool is_satisfied(T* item) override {return first.is_satisfied(item) && second.is_satisfied(item);}
};int main()
{Product apple{ "Apple", Color::Green, Size::Small };Product tree{ "Tree", Color::Green, Size::Large };Product house{ "House", Color::Blue, Size::Large };std::vector<Product*> all{ &apple, &tree, &house };BetterFilter bf;ColorSpecification green(Color::Green);auto green_things = bf.filter(all, green);for (auto& x : green_things)std::cout << x->name << " is green" << std::endl;SizeSpecification big(Size::Large);AndSpecification<Product> green_and_big{ big,green };auto green_big_things = bf.filter(all, green_and_big);for (auto& x : green_big_things)std::cout << x->name << " is green and big" << std::endl;return 0;
}

Liskov Substitution Principle

Objects should be replaceable with instances of their subtypes withou altering program correctness.

Interface Segregation Principle

No client should be forced to depend on methods it does not use.
Many client-specifc interfaces better than one general-purpose interface.

struct Document;// ======================Bad Example below================
struct IMachine
{virtual void print(std::vector<Document*> docs) = 0;virtual void scan(std::vector<Document*> docs) = 0;virtual void fax(std::vector<Document*> docs) = 0;
};struct MFP : IMachine
{void print(std::vector<Document*> docs) override;void scan(std::vector<Document*> docs) override;void fax(std::vector<Document*> docs) override;
};// ===============Good Example below===============
// Break up your interface into lots of little interfaces
struct IPrinter
{virtual void print(std::vector<Document*> docs) = 0;
};struct IScanner
{virtual void scan(std::vector<Document*> docs) = 0;
};struct Printer : IPrinter
{void print(std::vector<Document*> docs) override;
};struct Scanner : IScanner
{void scan(std::vector<Document*> docs) override;
};//if you still want that big interface,
//use multiple inheritance for the interface type itself
struct IMachine : IPrinter, IScanner {};struct Machine : IMachine
{IPrinter& printer;IScanner& scanner;Machine(IPrinter& printer, IScanner& scanner): printer{printer},scanner{scanner}{}void print(std::vector<Document*> docs) override {printer.print(docs);}void scan(std::vector<Document*> docs) override {scanner.scan(docs);}
};

Dependency Inversion Principle

Dependencies should be abstract rather than concrete.
High-level modules should not depend on low-level modules, but both should depend on some form of abstraction.
Abstractions should not depend upon details, but details should depend upon abstractions.

Dependency Injection with Boost.DI

Monads

SOLID Design Principle相关推荐

design principle：java 回调与委派/委托机制
博客 design principle:模拟 android Button 控件点击事件主要说了一下模拟 android 的 Listener 模式,其实这就是一种委派与回调机制的体现. 委派, ...
Design Principle
Design Principle posted on 2013-12-04 14:34 JasonChang 阅读( ...) 评论( ...) 编辑收藏转载于:https://www.cnbl ...
设计模式-设计原则（Design Principle）
本文由@呆代待殆原创,转载请注明出处. 写在前面:所谓设计原则并不是一定要遵守的法则,只是一种建议,因为保持这些原则本身会有一定代价,若是这些代价超过了带来的好处就得不偿失了,所以一切还是以简单为准. ...
SOLID Design Principles in C#
Single Responsibility Principle Open-Closed Principle Liskov Substitution Principle Interface Segreg ...
Paper：2020年3月30日何恺明团队最新算法RegNet—来自Facebook AI研究院《Designing Network Design Spaces》的翻译与解读
Paper:2020年3月30日何恺明团队最新算法RegNet-来自Facebook AI研究院<Designing Network Design Spaces>的翻译与解读导读: 卧槽 ...
Paper之RegNet：《Designing Network Design Spaces》的翻译与解读—2020年3月30日来自Facebook AI研究院何恺明团队最新算法RegNet
Paper之RegNet:<Designing Network Design Spaces>的翻译与解读-2020年3月30日来自Facebook AI研究院何恺明团队最新算法RegNet ...
SOLID 设计原则 (有点长但很透彻)
面向对象设计原则 SOLID 应该是职业程序员必须掌握的基本原则,每个程序员都应该了然于胸,遵守这 5个原则可以帮助我们写出易维护.易拓展的高内聚低耦合的代码. 它是由罗伯特·C·马丁(知名的 Rob ...
从零学web前端_从零到前端英雄（第2部分）
从零学web前端 This article is part two of the "From Zero to Front-end Hero" series. In part one ...
程序员应知道这十大面向对象设计原则
面向对象设计原则是OOPS编程的核心, 但我见过的大多数Java程序员热心于像Singleton (单例) . Decorator(装饰器).Observer(观察者) 等设计模式, 而没有把足够多的 ...

SOLID Design Principle

文章目录

Single Responsibility Principle

Open-closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

Dependency Injection with Boost.DI

Monads

SOLID Design Principle相关推荐

最新文章

热门文章