blocks|key|3341734|text|您可以为每种类型的图书创建不同的类。每个类都可以实现相同的接口，并重载一个方法来执行必要的类特定逻辑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3341735|我并不是说这一定更好，但这是一种选择。|3341736|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You could make a different class for each type of book. Each class could implement the same interface, and overload a method to perform the necessary class-specific logic.

I'm not saying that's necessarily better, but it is an option.

blocks|key|4752768|text|正如其他人所指出的那样，虚拟函数可能应该是您的首选。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4752769|如果由于某些原因，这对您的设计不是很有意义/效果很好，另一种可能是使用一个使用book.type的std::map作为键和指向函数(或函数等)的指针。作为关联值，因此您只需查找要对特定类型执行的操作(这几乎就是许多OO语言在幕后实现其等效虚函数的数量)。|offset|length|style|CODE|4752770|entityMap^0|0|1D|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

As others have pointed out, a virtual function should probably be your first choice.

If, for some reason, that doesn't make sense/work well for your design, another possibility would be to use an <code>std::map</code> using book.type as a key and a pointer to function (or functor, etc.) as the associated value, so you just lookup the action to take for a particular type (which is pretty much how many OO languages implement their equivalent of virtual functions, under the hood).

blocks|key|1190008|text|每种不同类型的图书都是父类的不同子类，并且每个类都使用相同的接口实现一个方法do_some_action()。当您希望发生操作时，可以调用该方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1190009|entityMap^0|12|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Each different type of book is a different sub-class of the parent class, and each class implements a method <code>do_some_action()</code> with the same interface. You invoke the method when you want the action to take place.

blocks|key|3341845|text|是的，这叫做循环：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3341846|struct+BookType+{
++++char+type;
++++void+*do();
};
BookType[]+types+=+{{A,+do_something},+{B,+do_something_else},+...};
for+(int+i+=+0;+i+<+types_length;+i%2B%2B)+{
++++if+(book.type+==+types[i].type)+types[i].do(book);
}|code-block|syntax|javascript|3341847|不过，对于更好的方法，如果do_something、do_something_else等是Book的方法就更好了，所以：|3341848|struct+Book+{
++++virtual+void+do()+=+0;
};
struct+A+{
++++void+do()+{
++++++++//+...+do_something
++++}
};
struct+B+{
++++void+do()+{
++++++++//+...+do_something_else
++++}
};|3341849|所以你只需要做：|3341850|book.do();|3341851|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Yes, it's called looping:

<pre><code>struct BookType {
 char type;
 void *do();
};
BookType[] types = {{A, do_something}, {B, do_something_else}, ...};
for (int i = 0; i &lt; types_length; i++) {
 if (book.type == types[i].type) types[i].do(book);
}
</code></pre>

For a better approach though, it's even more preferrable if do_something, do_something_else, etc is a method of Book, so:

<pre><code>struct Book {
 virtual void do() = 0;
};
struct A {
 void do() {
 // ... do_something
 }
};
struct B {
 void do() {
 // ... do_something_else
 }
};
</code></pre>

so you only need to do:

<pre><code>book.do();
</code></pre>

blocks|key|4752710|text|这些if-then-else-if构造是我最恼火的地方之一。我发现很难想出一个缺乏想象力的设计选择。但这已经足够了。接下来我们可以做些什么。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4752711|我已经使用了几种设计方法，这取决于要采取的操作的确切性质。|4752712|如果可能性很小，并且未来不太可能扩展，我可能只使用switch语句。但我敢肯定你大老远跑来SOF不是为了听这么无聊的话。|4752713|如果操作是赋值，那么表驱动的方法允许未来的增长，而不需要实际更改代码。只需添加和删除表项即可。|4752714|如果操作涉及复杂的方法调用，那么我倾向于使用责任链设计模式。我将构建一个对象列表，每个对象都知道如何处理特定情况下的操作。|4752715|将要处理的项传递给第一个处理程序对象。如果它知道如何处理该项目，则执行该操作。如果没有，它会将该项目传递给列表中的下一个处理程序。这将一直持续到项目被处理，或者它落入用于清理或打印错误的默认处理程序中。维护很简单--您可以在列表中添加或删除处理程序对象。|4752716|entityMap^0|2|F|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|W|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|X|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|Y|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

Those <code>if-then-else-if</code> constructs are one of my most acute pet peeves. I find it difficult to conjure up a less imaginative design choice. But enough of that. On to what can be done about it.

I've used several design approaches depending on the exact nature of the action to be taken.

If the number of possibilities is small and future expansion is unlikely I may just use a switch statement. But I'm sure you didn't come all the way to SOF to hear something that boring.

If the action is the assignment of a value then a table-driven approach allows future growth without actually making code changes. Simply add and remove table entries.

If the action involves complex method invocations then I tend to use the Chain of Responsibility design pattern. I'll build a list of objects that each knows how to handle the actions for a particular case.

You hand the item to be processed to the first handler object. If it knows what to do with the item it performs the action. If it doesn't, it passes the item off to the next handler in the list. This continues until the item is processed or it falls into the default handler that cleans up or prints an error or whatever. Maintenance is simple -- you add or remove handler objects from the list.

blocks|key|1932728|text|您可以为每种图书类型定义一个子类，并定义一个虚拟函数do_something。每个子类A、B等都会有自己的do_something版本，然后do_some_default_thing就会成为基类中的do_something方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1932729|不管怎样，只有一种可能的方法。你必须评估它是否真的让你的事情变得更容易……|1932730|entityMap^0|Q|C|17|1|19|1|1H|C|1Y|L|2R|C|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

You could define a subclass for each book type, and define a virtual function <code>do_something</code>. Each subclass <code>A</code>, <code>B</code>, etc would have its own version of <code>do_something</code> that it calls into, and <code>do_some_default_thing</code> then just becomes the <code>do_something</code> method in the base class.

Anyway, just one possible approach. You would have to evaluate whether it really makes things easier for you...

blocks|key|4752797|text|我认为你需要的是Strategy+Design+Pattern。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4752798|entityMap|0|LINK|mutability|MUTABLE|url|http://sourcemaking.com/design_patterns/strategy/cpp/1^0|8|N|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://sourcemaking.com/design_patterns/strategy/cpp/1" rel="nofollow">Strategy Design Pattern</a> is what I think you need.

blocks|key|1187791|text|作为为每本书提供不同类的另一种选择，可以考虑使用从书类型到函数指针的map。那么你的代码应该是这样的(对于伪代码，很抱歉，C%2B%2B现在不在我的指尖)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1187792|if+book.type+in+booktypemap:
+++++booktypemap[book.type]();
else
+++++defaultfunc();|code-block|syntax|javascript|1187793|entityMap^0|Y|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

As an alternative to having a different class for each book, consider having a <code>map</code> from book types to function pointers. Then your code would look like this (sorry for pseudocode, C++ isn't at the tip of my fingers these days):

<pre><code>if book.type in booktypemap:
 booktypemap[book.type]();
else
 defaultfunc();
</code></pre>

I have the following piece of code:

<pre><code>if (book.type == A) do_something();
else if (book.type == B) do_something_else();
....
else do so_some_default_thing.
</code></pre>

This code will need to be modified whenever there is a new book type
or when a book type is removed. I know that I can use enums and use a switch
statement. Is there a design pattern that removes this if-then-else? 

What are the advantages of such a pattern over using a switch statement?

C++ design pattern to get rid of if-then-else

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有下面这段代码：if (book.type == A)  do_something();else if (book.type == B) do_something_else();....else do so_some_default_thing.每当有新的图书类型或删除图书类型时，都需要修改此代码。我知道我可以使用枚举和switch语句。有没有一种设计模式可以去掉这个if-then-else？与

问摆脱if-then-else的C++设计模式
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问摆脱if-then-else的C++设计模式EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问摆脱if-then-else的C++设计模式
EN