blocks|key|2229330|text|在这里您并不真正需要它，因为您不需要捕获对象的销毁。您会注意到，Wikipedia页面上的示例保存了该类型存在的对象的总数，因此CRTP有两个方便的特性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2229331|2229332|，因为它是基类，所以它的析构函数被调用(成员也可以做到这一点)。|ordered-list-item|2229333|因为它是在派生类类型上模板化的，所以每个继承自它的类都有一个单独的计数器，如果它们使用多重继承，则包括层次结构中的不同类，每个类都包括自己的CRTP基，而不需要为每个类编写大量代码。|2229334|2229335|如果你只想让单个类的每个成员都有一个唯一的值，那么抛开线程安全不谈，你可以这样做：|2229336|int+get_id()+{
++++static+int+counter+=+0;
++++return+%2B%2Bcounter;
}

class+Address+{
++++int+addr;
++public:
++++Address()+:+addr(get_id())+{}
};|code-block|syntax|javascript|2229337|按照CRTP的例子，如果您有多个类要跟踪，并且希望每个类都有自己的ID空间，那么可以将get_id作为模板并使用Address作为参数。|offset|length|style|CODE|2229338|对于这个用例，如果你使用了CRTP，你可以将数据成员addr放在模板基类中，如果你有很多类，这是一个很好的选择，因为使用它的每个类的类型更少：|2229339|template+<typename+Derived>
class+unique_addr+{
++protected:
++++int+addr;
++++unique_addr()+:+addr(get_id<Derived>())+{}
};

class+Address+:+public+unique_addr<Address>+{
};

class+OtherAddress+:+public+unique_addr<OtherAddress>+{
};|2229340|entityMap^0|0|0|0|0|0|0|0|17|6|1K|7|0|Q|4|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|18|8|@$R|19|S|1A|T|U]|$R|1B|S|1C|T|U]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1D|8|@$R|1E|S|1F|T|U]]|9|@]|A|$]]|$1|X|3|Y|5|M|7|1G|8|@]|9|@]|A|$N|O]]|$1|Z|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|10|$]]

You don't really need it here, because you don't need to capture destruction of the object. You'll note that the example on that Wikipedia page keeps a running total of how many objects exist of the type, so CRTP has two handy features:

<ol>
<li>because it's a base class, its destructor is called (a member would also achieve this).</li>
<li>because it's templated on the derived class type, there's a separate counter for each class that inherits from it, including different classes in a hierarchy if they use multiple inheritance to each include their own CRTP base, without writing a lot of code for each class.</li>
</ol>

If you just want a unique value for each member of a single class, then thread-safety aside you can do it like this:

<pre><code>int get_id() {
 static int counter = 0;
 return ++counter;
}

class Address {
 int addr;
 public:
 Address() : addr(get_id()) {}
};
</code></pre>

Following the CRTP example, you could template <code>get_id</code> and use <code>Address</code> as the argument if you have multiple classes to track and want them to each have their own space of IDs. 

And for this use-case, if you did use CRTP you could put the data member <code>addr</code> in the template base class, which is a win if you have a lot of classes, since there's less to type for each class using it:

<pre><code>template &lt;typename Derived&gt;
class unique_addr {
 protected:
 int addr;
 unique_addr() : addr(get_id&lt;Derived&gt;()) {}
};

class Address : public unique_addr&lt;Address&gt; {
};

class OtherAddress : public unique_addr&lt;OtherAddress&gt; {
};
</code></pre>

blocks|key|139592|text|对于你正在尝试做的事情来说，这似乎有点过头了。如果您只需要一个唯一的值，则使用静态整数，并在每次实例化对象时递增它。然后将每个实例(即非静态)变量设置为该值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|139593|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|$]]

That seems like overkill for what you're trying to do. If all you need is a unique value, use a static integer and increment it each time you instantiate an object. Then set a per-instance (i.e. non-static) variable to that value.

blocks|key|2234368|text|当然，您可以完全按照您引用的维基百科文章中的说明进行操作。(除了它听起来不像是要递减dtor中的计数器。)或者，如果您只需要在Address类中使用它，那么您可以像CRTP实现那样一次性地执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2234369|static+int+n_addresses+=+0;
class+Address+{
++int+addr;
++Address()+{+addr+=+%2B%2Bn_addresses;+}
};|code-block|syntax|javascript|2234370|或者类似的东西。|2234371|entityMap^0|1R|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Sure, you can do it exactly as shown in the Wikipedia article you referenced. (Except that it doesn't sound as if you want to decrement the counter in the dtor.) Or, if you only need it for the <code>Address</code> class, you can just do what the CRTP implementation there does as a one-off:

<pre><code>static int n_addresses = 0;
class Address {
 int addr;
 Address() { addr = ++n_addresses; }
};
</code></pre>

or something of the kind.

blocks|key|2229365|text|public+class+Address
{
++++private+static+int+addrCounter+=+1;

++++public+int+addr+{+get;+private+set;+}

++++public+Address()
++++{
++++++++addr+=+addrCounter%2B%2B;
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2229366|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class Address
{
 private static int addrCounter = 1;

 public int addr { get; private set; }

 public Address()
 {
 addr = addrCounter++;
 }
}
</code></pre>

blocks|key|3829805|text|你也可以在类内部使用静态计数器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3829806|class+Address
{
++static+int+s_Count;+//+define+this+variable+in+appropriate+cpp+file
++int+addr;
public:
++Address+()+:+addr(%2B%2B+s_Count)+{}
};|code-block|syntax|javascript|3829807|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use also static counter internal to class:

<pre><code>class Address
{
 static int s_Count; // define this variable in appropriate cpp file
 int addr;
public:
 Address () : addr(++ s_Count) {}
};
</code></pre>

I want to implement a <code>class Address</code> that, when created, initializes its field <code>addr</code> to a unique value. That value has to increment by one every time I create an <code>Address</code> instance.

Let's make an example. After the following code has been executed:

<pre><code>Address x;
Address y;
</code></pre>

<code>x.addr</code> should be 1, while <code>y.addr</code> should be 2.

To accomplish that, I was thinking of the <a href="http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern#Object_counter" rel="nofollow">Curiously Recurring Template Pattern</a>. Would it be feasible?
Also, are there simpler methods to achieve the same behavior?

TIA,
Jir

Incremental number using the "Curiously Recurring Template Pattern"

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想实现一个在创建时将其字段addr初始化为唯一值的class Address。每次创建Address实例时，该值都必须递增1。让我们举个例子。在执行以下代码之后：Address x;Address y;x.addr应为1，而y.addr应为2。为了实现这一点，我想到了。这可行吗？另外，有没有更简单的方法来实现同样的行...

问使用“奇怪地重复出现的模板模式”的增量数字
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用“奇怪地重复出现的模板模式”的增量数字EN