blocks|key|892258|text|一个空类可以被用作一个“令牌”来定义一些独特的东西；在某些模式中，您需要一个唯一的实例的实现无关的表示，除了它的唯一性之外，它对开发人员没有任何价值。一个例子是Unit+of+Work；您可能一点也不关心您的执行器内部发生了什么，但是您希望告诉该执行器您告诉它要执行的任务是原子集的一部分。在这种情况下，向外界表示工作单元的空类可能是完美的；几乎任何工作单元对象可以存储或执行的操作(封装DB事务、公开提交/回滚行为)都会将您绑定到特定的实现，但是对象引用对于提供对原子任务集的唯一但可复制和可传递的引用非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|892259|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An empty class could be used as a "token" defining something unique; in certain patterns, you want an implementation-agnostic representation of a unique instance, which has no value to the developer other than its uniqueness. One example is Unit of Work; you may not care one bit about what's going on inside your performer, but you want to tell that performer that the tasks you're telling it to perform are part of an atomic set. An empty class representing the Unit of Work to the outside world may be perfect in this case; almost anything a Unit of Work object could store or do (encapsulating a DB transaction, exposing Commit/Rollback behaviors) would start tying you to a particular implementation, but an object reference is useful to provide a unique but copyable and passable reference to the atomic set of tasks.

blocks|key|1107264|text|“空”类是指没有数据成员的类吗？它们通常声明typedefs或成员函数，您可以使用自己的类扩展它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1107265|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

"empty" classes means classes which have no data members?
They typically declare typedefs or member functions, and you can extend them with your own classes.

blocks|key|892325|text|Here是一个有趣的链接，它回答了为什么它被允许。您可能会发现这对查找可能有用的情况很有帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|892326|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3382922/why-are-c-classes-allowed-to-have-zero-data-members^0|0|4|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="https://stackoverflow.com/questions/3382922/why-are-c-classes-allowed-to-have-zero-data-members">Here</a> is an interesting link with answers to why its allowed. You might find this helpful to find situations where it might be useful.

blocks|key|1107377|text|您可以将其用作检查目的的占位符，或用作特殊功能的启用符。例如，在Java+exist中，“空”接口serializable用于指定一个类是否可序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1107378|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can use it like a placeholder for checking purpose or as enabler to special functionality. For example in Java exist the "empty" interface Serializable used to specify if a class is serializable.

blocks|key|892457|text|在C%2B%2B的标准模板库中，例如你有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|892458|template<class+_Arg,
+class+_Result>
struct+unary_function
++++{+//+base+class+for+unary+functions
+typedef+_Arg+argument_type;
+typedef+_Result+result_type;
++++};|code-block|syntax|javascript|892459|在定义函数器时，您可以继承unary_function，然后您可以根据自己的需要自动定义类型定义。|892460|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In the STL, Standard Template Library of the C++, for example you have

<pre><code>template&lt;class _Arg,
 class _Result&gt;
struct unary_function
 { // base class for unary functions
 typedef _Arg argument_type;
 typedef _Result result_type;
 };
</code></pre>

When defining a functor, you can inherit unary_function, and then you have the typedef defined automatically at your disposal.

blocks|key|892523|text|例如，下面的代码可以用来拥有一个可以包含(SQL)+null值的boost::variant。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|892524|class+Null+{+};

typedef+boost::variant<Null,+std::string,+int>+Value;|code-block|syntax|javascript|892525|为了让它更有用，像operator==和operator<<这样的东西是很方便的。例如：|892526|std::ostream&+operator<<(std::ostream+&lhs,+const+Null+&rhs)
{
+++++lhs+<<+"*NULL*";
+++++return+lhs;
}

int+main()
{
++++Variant+v("hello");
++++std::cout+<<+v+<<+std::endl;
++++v+=+Null();
++++std::cout+<<+v+<<+std::endl;
++++...
}|892527|将给予：|892528|hello
*NULL*|892529|entityMap^0|W|E|0|0|9|A|K|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

The following can be used to have a <code>boost::variant</code> which can hold an (SQL) NULL value for example.

<pre><code>class Null { };

typedef boost::variant&lt;Null, std::string, int&gt; Value;
</code></pre>

To make it more useful things like <code>operator==</code> and <code>operator&lt;&lt;</code> are handy. For example:

<pre><code>std::ostream&amp; operator&lt;&lt;(std::ostream &amp;lhs, const Null &amp;rhs)
{
 lhs &lt;&lt; "*NULL*";
 return lhs;
}

int main()
{
 Variant v("hello");
 std::cout &lt;&lt; v &lt;&lt; std::endl;
 v = Null();
 std::cout &lt;&lt; v &lt;&lt; std::endl;
 ...
}
</code></pre>

Will give:

<pre><code>hello
*NULL*
</code></pre>

blocks|key|892606|text|MartinStettner的回答很好，不过这里要强调一点:迭代器标签的概念或C%2B%2B中的任何标签并不严格依赖于空类。如果stl编写者希望的话，C%2B%2B标记很可能是非空类；这应该可以工作，但它不会添加任何额外的值；至少对于编译时杂技，它通常是为之保留的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|892607|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/81424/martinstettner^0|0|E|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]]]]

The answer by <a href="https://stackoverflow.com/users/81424/martinstettner">MartinStettner</a> is fine though just to highlight an important point here: The concept of iterator tags or for that matter any tags in C++, is not strictly dependent on empty classes. The C++ tags, if stl writers would have wanted to, could well have been non-empty classes; that should work but then it won't add any additional value; at least for compile time acrobatics that it is usually reserved for.

blocks|key|892657|text|为了typeid|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|892658|假设我们有类似的接口Id。我们需要用这个接口的唯一实例填充一些容器。如何保证独立软件部件生成的Id实例的唯一性？“独立部件”是指一些不同的动态库，由不同的程序员在不同的位置编译而成|892659|其中一个决定是首先比较某种类型的typeid。如果typeid匹配，则转换并比较其他特定于实现的属性。C%2B%2B语言保证了进程内存中任何类型的唯一性。为此，应使用哪种类型？任何具有最小资源消耗的类型-空类型|892660|entityMap^0|2|6|0|A|2|1B|2|0|G|6|P|6|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

For the sake of <code>typeid</code>
Suppose we have comparable interface <code>Id</code>. We need fill some container with unique instances of this interface. How to guarantee the uniqueness of <code>Id</code> instances produced by independent software parts? «Independent parts» means some different dynamic libraries, compiled by different programmers from different locations
One of decisions is to compare <code>typeid</code> of some type first. If <code>typeid</code> matches, convert and compare other implementation specific properties. C++ language guarantees uniqueness of any type within process memory. Which type should be used for this purpose? Any type with minimum resource consumption — empty one

What could be the possible advantages/uses of having an empty class?

P.S: 
This question might sound trivial to some of you but it is just for learning purpose and has no practical significance. FYI googling didn't help.

Advantages of an empty class in C++

容器

Java

拥有一个空类可能有什么好处/用处？附言:这个问题对你们中的一些人来说可能是微不足道的，但它只是为了学习目的，没有实际意义。仅供参考，谷歌搜索也没什么帮助。

问C++中空类的优点
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中空类的优点EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中空类的优点
EN