blocks|key|4702618|text|直截了当地告诉我：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4702619|4702620|在每个类中创建一个整型静态字段。注意在每个(非静态)构造函数体的emulated+static+constructor.|unordered-list-item|offset|length|4702621|Increment+it中，整数overflow.|4702622|Initialize+it为0。|4702623|是一个静态函数，它返回整数静态字段的值。|4702624|注释：查看Mykola的评论。这将为A打印4，为B打印3，为C打印2，即将B的一个实例计为“一个A和一个B"，并将一个C计为”一个A，一个B和一个C“。这在某种程度上是正确的，但并不是问题所要求的。换句话说，我的答案是错误的:)|style|BOLD|4702625|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cpptalk.net/emulating-a-static-constructor-vt12077.html^0|0|0|W|R|0|0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|H|3|I|5|E|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@$F|19|G|1A|P|Q]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

Directly off my head:

<ul>
<li>Create an integer static field in
each class. Watch out for integer overflow.</li>
<li>Initialize it to 0 in an
<a href="http://www.cpptalk.net/emulating-a-static-constructor-vt12077.html" rel="nofollow noreferrer">emulated static constructor</a>.</li>
<li>Increment it at each (nonstatic)
constructor body. Decrement it in the
destructor.</li>
<li>GetInstancesCount() is a static function that returns the value of your integer static field.</li>
</ul>

Note: See Mykola's comments. This would print 4 for A, 3 for B and 2 for C i.e. it would count one instance of B as "one A and one B", and one C as "one A, one B and one C". Which is in a way true, but is not what the question asks for. In other words, my answer is wrong :)

blocks|key|3859715|text|对每个类使用static成员变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3859716|struct+A+{
++++A()+{+mInstances%2B%2B;+}
++++~A()+{+mInstances--;+}
++++static+size_t+mInstances;
++++static+size_t+GetInstancesCount()+{+return+mInstances;+}
};

size_t+A::mInstances;

int+main()+{
++++A*+a+=+new+A;
++++A*+aa+=+new+A;
++++cout+<<+A::GetInstancesCount()+<<+endl;
++++delete+a;
++++delete+aa;
++++cout+<<+A::GetInstancesCount()+<<+endl;
++++return+0;
}|code-block|syntax|javascript|3859717|entityMap^0|6|6|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|$]]

Use a <code>static</code> member variable for each class. 

<pre><code>struct A {
 A() { mInstances++; }
 ~A() { mInstances--; }
 static size_t mInstances;
 static size_t GetInstancesCount() { return mInstances; }
};

size_t A::mInstances;

int main() {
 A* a = new A;
 A* aa = new A;
 cout &lt;&lt; A::GetInstancesCount() &lt;&lt; endl;
 delete a;
 delete aa;
 cout &lt;&lt; A::GetInstancesCount() &lt;&lt; endl;
 return 0;
}
</code></pre>

blocks|key|639135|text|所提出的解决方案存在一个问题:当您创建B时，将自动调用A构造函数，从而递增A的计数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|639136|class+A
{
public:
++++A(bool+doCount+=+true)
++++{
++++++++if+(doCount)
++++++++++++%2B%2BinstanceCount_;
++++}

++++static+std::size_t+GetInstanceCount()
++++{
++++++++return+instanceCount_;
++++}

++++virtual+~A(){}
private:
++++static+std::size_t+instanceCount_;
};

class+B:+public+A
{
public:
++++B(bool+doCount+=+true):A(false)
++++{
++++++++if+(doCount)
++++++++++++%2B%2BinstanceCount_;
++++}

++++static+std::size_t+GetInstanceCount()
++++{
++++++++return+instanceCount_;
++++}
private:
++++static+std::size_t+instanceCount_;
};

std::size_t+A::instanceCount_+=+0;
std::size_t+B::instanceCount_+=+0;|code-block|syntax|javascript|639137|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|$]]

There is a problem with proposed solutions: when you create B you A constructor will be called automatically and thus increment count of A. 

<pre><code>class A
{
public:
 A(bool doCount = true)
 {
 if (doCount)
 ++instanceCount_;
 }

 static std::size_t GetInstanceCount()
 {
 return instanceCount_;
 }

 virtual ~A(){}
private:
 static std::size_t instanceCount_;
};

class B: public A
{
public:
 B(bool doCount = true):A(false)
 {
 if (doCount)
 ++instanceCount_;
 }

 static std::size_t GetInstanceCount()
 {
 return instanceCount_;
 }
private:
 static std::size_t instanceCount_;
};

std::size_t A::instanceCount_ = 0;
std::size_t B::instanceCount_ = 0;
</code></pre>

blocks|key|3859788|text|有点“奇怪的重复出现的模板模式”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3859789|template<typename+P>
class+Counter
{
++++public:+Counter(bool+inc)
++++++++:m_wasInc(inc)
++++{
++++++++if+(m_wasInc)
++++++++{+++getCount()%2B%2B;}
++++}
+++++++++++~Counter()
++++{
++++++++if+(m_wasInc)
++++++++{+++getCount()--;}
++++}
++++static+std::size_t+GetInstancesCount()
++++{
+++++++++return+getCount();
++++}
++++private:
+++++++bool+m_wasInc;
+++++++/*
++++++++*+Alternatively+this+can+be+a+static+member+variable.
++++++++*+I+just+used+a+function+because+this+means+I+do+not+need+to+declare
++++++++*+the+variable+for+each+type+class.+The+down+size+is+that+it+becomes
++++++++*+more+complex+if+used+in+the+presence+of+a+DLL's.
++++++++*
++++++++*+But+that+is+way+easy+to+change.+See+Alternative+Version+below.
++++++++*/
+++++++static+std::size_t&+getCount()
+++++++{
+++++++++++static+std::size_t+count+=+0;
+++++++++++return+count;
+++++++}
};

class+A:+public+Counter<A>
{
++++public:+A(bool+count+=+true):+Counter<A>(count){}
};

class+B:+public+A,Counter
{
++++public:+B(bool+count+=+true):+A(false),+Counter(count){}
};

class+C:+public+A,+Counter<C>
{
++++public:+C(bool+count+=+true):+A(false),+Counter<C>(count){}
};

template<typename+P>
class+CounterAlt
{
++++public:+CounterAlt()
++++{++++%2B%2Bcount;
++++}
++++static+std::size_t+GetInstancesCount()
++++{
+++++++++return+count;
++++}
++++private:
+++++++static+std::size_t+count;
};

class+D:+public+CounterAlt<D>
{
};
std::size_t+CounterAlt<D>::count+=+0;|code-block|syntax|javascript|3859790|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|$]]

A bit of the "Curiously reoccurring template pattern". 

<pre><code>template&lt;typename P&gt;
class Counter
{
 public: Counter(bool inc)
 :m_wasInc(inc)
 {
 if (m_wasInc)
 { getCount()++;}
 }
 ~Counter()
 {
 if (m_wasInc)
 { getCount()--;}
 }
 static std::size_t GetInstancesCount()
 {
 return getCount();
 }
 private:
 bool m_wasInc;
 /*
 * Alternatively this can be a static member variable.
 * I just used a function because this means I do not need to declare
 * the variable for each type class. The down size is that it becomes
 * more complex if used in the presence of a DLL's.
 *
 * But that is way easy to change. See Alternative Version below.
 */
 static std::size_t&amp; getCount()
 {
 static std::size_t count = 0;
 return count;
 }
};

class A: public Counter&lt;A&gt;
{
 public: A(bool count = true): Counter&lt;A&gt;(count){}
};

class B: public A,Counter&lt;B&gt;
{
 public: B(bool count = true): A(false), Counter&lt;B&gt;(count){}
};

class C: public A, Counter&lt;C&gt;
{
 public: C(bool count = true): A(false), Counter&lt;C&gt;(count){}
};

template&lt;typename P&gt;
class CounterAlt
{
 public: CounterAlt()
 { ++count;
 }
 static std::size_t GetInstancesCount()
 {
 return count;
 }
 private:
 static std::size_t count;
};

class D: public CounterAlt&lt;D&gt;
{
};
std::size_t CounterAlt&lt;D&gt;::count = 0;
</code></pre>

blocks|key|4702766|text|一种非常粗糙的方式是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4702767|class+A
{
public:
++++static+int+m_instanceCount;
++++A(bool+derivedInstance+=+false)
++++{
++++++++if(!+derivedInstance)
++++++++{
++++++++++++%2B%2Bm_instanceCount;
++++++++}
++++}
++++virtual+~A()
++++{
++++++++--m_instanceCount;
++++}
++++virtual+int+GetInstanceCount()
++++{
++++++++return+m_instanceCount;
++++}
};

int+A::m_instanceCount+=+0;


class+B+:+public+A
{
public:
++++static+int+m_instanceCount;
++++B(bool+derivedInstance+=+false):+A(true)+
++++{
++++++++if(!+derivedInstance)
++++++++{
++++++++++++%2B%2Bm_instanceCount;
++++++++}
++++}
++++virtual+~B()
++++{
++++++++--m_instanceCount;
++++}
++++virtual+int+GetInstanceCount()
++++{
++++++++return+m_instanceCount;
++++}
};

int+B::m_instanceCount+=+0;


class+C+:+public+B
{
public:
++++static+int+m_instanceCount;
++++C():+B(true)+{%2B%2Bm_instanceCount;}
++++virtual+~C()
++++{
++++++++--m_instanceCount;
++++}
++++virtual+int+GetInstanceCount()
++++{
++++++++return+m_instanceCount;
++++}
};

int+C::m_instanceCount+=+0;




void+main(int+argc,char+*argv[])
{+++
++++A*+p1+=+new+A;
++++B*+p2+=+new+B;
++++C*+p3+=+new+C;
++++C*+p4+=+new+C;
++++A*+p5+=+new+A;

++++delete+p5;

++++std::cout<<p1->GetInstanceCount()<<"\n";
++++std::cout<<p2->GetInstanceCount()<<"\n";
++++std::cout<<p3->GetInstanceCount()<<"\n";
}+++|code-block|syntax|javascript|4702768|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|$]]

A very crude way would be:

<pre><code>class A
{
public:
 static int m_instanceCount;
 A(bool derivedInstance = false)
 {
 if(! derivedInstance)
 {
 ++m_instanceCount;
 }
 }
 virtual ~A()
 {
 --m_instanceCount;
 }
 virtual int GetInstanceCount()
 {
 return m_instanceCount;
 }
};

int A::m_instanceCount = 0;


class B : public A
{
public:
 static int m_instanceCount;
 B(bool derivedInstance = false): A(true) 
 {
 if(! derivedInstance)
 {
 ++m_instanceCount;
 }
 }
 virtual ~B()
 {
 --m_instanceCount;
 }
 virtual int GetInstanceCount()
 {
 return m_instanceCount;
 }
};

int B::m_instanceCount = 0;


class C : public B
{
public:
 static int m_instanceCount;
 C(): B(true) {++m_instanceCount;}
 virtual ~C()
 {
 --m_instanceCount;
 }
 virtual int GetInstanceCount()
 {
 return m_instanceCount;
 }
};

int C::m_instanceCount = 0;




void main(int argc,char *argv[])
{ 
 A* p1 = new A;
 B* p2 = new B;
 C* p3 = new C;
 C* p4 = new C;
 A* p5 = new A;

 delete p5;

 std::cout&lt;&lt;p1-&gt;GetInstanceCount()&lt;&lt;"\n";
 std::cout&lt;&lt;p2-&gt;GetInstanceCount()&lt;&lt;"\n";
 std::cout&lt;&lt;p3-&gt;GetInstanceCount()&lt;&lt;"\n";
} 
</code></pre>

blocks|key|3859851|text|这是一个简单的计数器，我经常使用每个计数器进行调试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3859852|//+counter.hpp
#ifndef+COUNTER_HPP
#define+COUNTER_HPP

template+<typename+T>
class+Counter
{
public:
++++Counter(+bool+do_count+=+true+)+:+counted(do_count)+
++++{+if+(+counted+)+get_count()%2B%2B;+}
++++~Counter()+{+if+(counted)+--count_;+}

++++static+unsigned+long+count()+{+return+count_;+}
++++static+unsigned+long&+get_count()+{+
+++++++static+unsigned+long+count=0;
+++++++return+count;
++++}
private:
++++bool+do_count;
};
#endif+|code-block|syntax|javascript|3859853|用法很简单，只是继承它：|3859854|class+BaseClass+:+public+Counter<BaseClass>
{
public:
+++explicit+BaseClass(+bool+do_count+=+true+)+
++++++:+Counter<BaseClass>(+do_count+)
+++{}
};
class+DerivedClass+:+public+BaseClass,+Counter<DerivedClass>
{
public:
+++explicit+DerivedClass(+bool+do_count+=+true+)
++++++:+BaseClass(false),+Counter<DerivedClass>(do_count)
+++{}
};|3859855|用户代码将调用无参数构造函数：|3859856|int+main()+{
+++BaseClass+b;+//+will+call+Counter<BaseClass>(true)
+++DerivedClass+d;+//+will+call+Counter<BaseClass>(false),+Counter<DerivedClass>(true)
}|3859857|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|$]]

This is a simple counter I use each so often for debugging:

<pre><code>// counter.hpp
#ifndef COUNTER_HPP
#define COUNTER_HPP

template &lt;typename T&gt;
class Counter
{
public:
 Counter( bool do_count = true ) : counted(do_count) 
 { if ( counted ) get_count()++; }
 ~Counter() { if (counted) --count_; }

 static unsigned long count() { return count_; }
 static unsigned long&amp; get_count() { 
 static unsigned long count=0;
 return count;
 }
private:
 bool do_count;
};
#endif 
</code></pre>

The usage is simple, just inherit from it:

<pre><code>class BaseClass : public Counter&lt;BaseClass&gt;
{
public:
 explicit BaseClass( bool do_count = true ) 
 : Counter&lt;BaseClass&gt;( do_count )
 {}
};
class DerivedClass : public BaseClass, Counter&lt;DerivedClass&gt;
{
public:
 explicit DerivedClass( bool do_count = true )
 : BaseClass(false), Counter&lt;DerivedClass&gt;(do_count)
 {}
};
</code></pre>

User code will call a parameterless constructor:

<pre><code>int main() {
 BaseClass b; // will call Counter&lt;BaseClass&gt;(true)
 DerivedClass d; // will call Counter&lt;BaseClass&gt;(false), Counter&lt;DerivedClass&gt;(true)
}
</code></pre>

blocks|key|1178820|text|通过工厂创建类，以便工厂能够跟踪已创建的类的数量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1178821|不像只是在类上调用new那样干净，但它可能会做你需要的事情。|1178822|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|$]]

Create the classes through a factory so the factory will be able to keep track of how many have been created.

Not as clean as just calling new on the class but it may do what you need.

blocks|key|4702910|text|当前的解决方案似乎都计入了构造函数，因此也计入了基类型的构造函数。(+Mykola除外，但该解决方案具有从bool+-bad的隐式转换)这种重复计数不是我们所希望的。然而，棘手的部分是，在构造派生类型的过程中，对象temporary具有中间基类型。而对于虚拟基类，这种情况甚至更糟。在这种情况下，中间类型甚至没有定义好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4702911|忽略这些瞬变，有一些重复计数的解决方案：|4702912|4702913|使用一个标志来禁用计数，使用一个受保护的基类构造函数|unordered-list-item|4702914|4702915|减少派生构造函数中基类的实例计数，并在一个专用的虚拟基类中进行计数。|4702916|4702917|后一种选择(虚拟基类)可能是最好的；编译器将强制它从最终的ctor初始化一次，并且只初始化一次。|4702918|class+counter+{
++++template<typename+T>+struct+perTypeCounter+{+static+int+count+=++0;+}
++++int*+count;+//+Points+to+perTypeCounter<MostDerived>::count

++++protected:
++++template<typename+MostDerived>+counter(MostDerived*)+
++++{
++++++++count+=+&perTypeCounter<MostDerived>::count;
++++++++%2B%2B*count;
++++}
++++~counter()+{+--*count;+}
};|code-block|syntax|javascript|4702919|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|X|8|@]|9|@]|A|$]]|$1|H|3|-4|5|G|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|G|7|Z|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|12|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

The current solutions all seem to count in constructors, and therefore also count in constructors of base type. (except Mykola, but that solution has an implicit conversion from bool - bad) This double-counting wasn't desired. The tricky part, though, is that during the construction of a derived type, the object temporary has intermediate base types. And with virtual base classes, this situation is even worse. In that case, the intermediate type isn't even well-defined.

Ignoring such transients, there are a few solutions to the double-counting:

<ul>
<li>Use a flag to disable counting </li>
<li>Use a protected base class constructor which doesn't count</li>
<li>Decrease the instance count of your base classes in derived constructors '*(this->base::count)--`</li>
<li>Keep the counts in a dedicated virtual base class. </li>
</ul>

The latter option (virtual base class) is probably the nicest; the compiler will enforce it's initialized once and only once, from the final ctor.

<pre><code>class counter {
 template&lt;typename T&gt; struct perTypeCounter { static int count = 0; }
 int* count; // Points to perTypeCounter&lt;MostDerived&gt;::count

 protected:
 template&lt;typename MostDerived&gt; counter(MostDerived*) 
 {
 count = &amp;perTypeCounter&lt;MostDerived&gt;::count;
 ++*count;
 }
 ~counter() { --*count; }
};
</code></pre>

blocks|key|1178881|text|您可以使用虚拟继承来强制计数基类构造函数由每个超类构造函数调用，并且只由该构造函数调用。这修复了重复计数问题。然后使用RTTI完成剩下的部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1178882|#include+<map>
#include+<typeinfo>
#include+<iostream>

struct+type_info_less
{
++++bool+operator()+(const+std::type_info+*+t1,+const+std::type_info+*+t2)+{
++++++++return+t1->before(*t2);
++++}
};

struct+InstCounter
{
++++typedef+std::map<const+std::type_info+*,+size_t,+type_info_less>+CountMap;
++++static+CountMap+countMap_;
++++const+std::type_info+*+my_type_;

++++InstCounter(const+std::type_info+&+type)+:+my_type_(&type){
++++++++%2B%2BcountMap_[my_type_];
++++}

++++~InstCounter()+{
++++++++--countMap_[my_type_];
++++}

++++static+size_t+getCount(const+std::type_info+&+type)+{
++++++++return+countMap_[&type];
++++}

++++size_t+getCount()+{
++++++++return+countMap_[my_type_];
++++}
};

InstCounter::CountMap+InstCounter::countMap_;

struct+A+:+public+virtual+InstCounter
{
++++A()+:+InstCounter(typeid(A))+{}
};

struct+B+:+public+A
{
++++B()+:+InstCounter(typeid(B))+{}
};

struct+C+:+public+B
{
++++C()+:+InstCounter(typeid(C))+{}
};


int+main(int+argc,+char+*+argv[])
{
++++std::cout+<<+"A:+"+<<+InstCounter::getCount(typeid(A))+<<+std::endl;
++++std::cout+<<+"B:+"+<<+InstCounter::getCount(typeid(B))+<<+std::endl;
++++std::cout+<<+"C:+"+<<+InstCounter::getCount(typeid(B))+<<+std::endl;

++++{
++++++++A+a1,+a2,+a3;
++++++++B+b1;
++++++++C+c1,+c2;

++++++++std::cout+<<+"A:+"+<<+InstCounter::getCount(typeid(A))+<<+std::endl;
++++++++std::cout+<<+"A:+"+<<+a1.getCount()+<<+std::endl;
++++++++std::cout+<<+"B:+"+<<+InstCounter::getCount(typeid(B))+<<+std::endl;
++++++++std::cout+<<+"B:+"+<<+b1.getCount()+<<+std::endl;
++++++++std::cout+<<+"C:+"+<<+InstCounter::getCount(typeid(C))+<<+std::endl;
++++++++std::cout+<<+"C:+"+<<+c1.getCount()+<<+std::endl;
++++}

++++std::cout+<<+"A:+"+<<+InstCounter::getCount(typeid(A))+<<+std::endl;
++++std::cout+<<+"B:+"+<<+InstCounter::getCount(typeid(B))+<<+std::endl;
++++std::cout+<<+"C:+"+<<+InstCounter::getCount(typeid(C))+<<+std::endl;

++++return+0;
}|code-block|syntax|javascript|1178883|这会导致|1178884|A:+0
B:+0
C:+0
A:+3
A:+3
B:+1
B:+1
C:+2
C:+2
A:+0
B:+0
C:+0|1178885|不幸的是，您必须将每个实例的类型存储为InstCounter::getCount()中的调用类型in+(*this)，返回InstCounter的type_info，而不是最派生的类型。(至少使用VS2005)|1178886|注意:+A、B和C的每个构造函数都必须显式调用InstCounter构造函数，然后传入它们的typeid。这有一个缺点，如果你为每个新的子类复制并粘贴这段代码，你可能会忘记将参数更改为typeid。|1178887|更新以添加递减析构函数。|1178888|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can use virtual inheritance to force the counting base class constructor to be called by every super class constructor and only that constructor. This fixes the double counting problem. Then use RTTI for the rest:

<pre><code>#include &lt;map&gt;
#include &lt;typeinfo&gt;
#include &lt;iostream&gt;

struct type_info_less
{
 bool operator() (const std::type_info * t1, const std::type_info * t2) {
 return t1-&gt;before(*t2);
 }
};

struct InstCounter
{
 typedef std::map&lt;const std::type_info *, size_t, type_info_less&gt; CountMap;
 static CountMap countMap_;
 const std::type_info * my_type_;

 InstCounter(const std::type_info &amp; type) : my_type_(&amp;type){
 ++countMap_[my_type_];
 }

 ~InstCounter() {
 --countMap_[my_type_];
 }

 static size_t getCount(const std::type_info &amp; type) {
 return countMap_[&amp;type];
 }

 size_t getCount() {
 return countMap_[my_type_];
 }
};

InstCounter::CountMap InstCounter::countMap_;

struct A : public virtual InstCounter
{
 A() : InstCounter(typeid(A)) {}
};

struct B : public A
{
 B() : InstCounter(typeid(B)) {}
};

struct C : public B
{
 C() : InstCounter(typeid(C)) {}
};


int main(int argc, char * argv[])
{
 std::cout &lt;&lt; "A: " &lt;&lt; InstCounter::getCount(typeid(A)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "B: " &lt;&lt; InstCounter::getCount(typeid(B)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "C: " &lt;&lt; InstCounter::getCount(typeid(B)) &lt;&lt; std::endl;

 {
 A a1, a2, a3;
 B b1;
 C c1, c2;

 std::cout &lt;&lt; "A: " &lt;&lt; InstCounter::getCount(typeid(A)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "A: " &lt;&lt; a1.getCount() &lt;&lt; std::endl;
 std::cout &lt;&lt; "B: " &lt;&lt; InstCounter::getCount(typeid(B)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "B: " &lt;&lt; b1.getCount() &lt;&lt; std::endl;
 std::cout &lt;&lt; "C: " &lt;&lt; InstCounter::getCount(typeid(C)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "C: " &lt;&lt; c1.getCount() &lt;&lt; std::endl;
 }

 std::cout &lt;&lt; "A: " &lt;&lt; InstCounter::getCount(typeid(A)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "B: " &lt;&lt; InstCounter::getCount(typeid(B)) &lt;&lt; std::endl;
 std::cout &lt;&lt; "C: " &lt;&lt; InstCounter::getCount(typeid(C)) &lt;&lt; std::endl;

 return 0;
}
</code></pre>

This results in

<pre><code>A: 0
B: 0
C: 0
A: 3
A: 3
B: 1
B: 1
C: 2
C: 2
A: 0
B: 0
C: 0
</code></pre>

Unfortunately you must store the type for each instance as calling typeid(*this) in InstCounter::getCount() returns the type_info for InstCounter and not the most derived type. (At least with VS2005)

NOTE: Each constructor for A, B and C have to call the InstCounter constructor explicitly then pass their typeid in. There is a down side to this, if you copy and paste this code for each new sub class you can forget to change the parameter to typeid.

Updated to add decrementing destructor.

blocks|key|3860019|text|在构造函数中计算对象时，避免重复计数的一种方法是使用RTTI在需要时计算对象，而不是在构造函数中。这是最低限度的干扰：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3860020|#include+<vector>
#include+<typeinfo>
#include+<iostream>
#include+<functional>


class+A
{

public:

++++A();
++++virtual+~A()+{+}

};

class+B:+public+A
{

public:

++++virtual+~B()+{+}
};

class+C:+public+B
{

public:

++++virtual+~C()+{+}

};

template<class+T>
struct+TypeIdsEqual:+public+std::binary_function<T,+T,+bool>
{
++++bool+operator()+(const+T&+obj1,+const+T&+obj2)+const
++++{
++++++++return+typeid(*obj1)+==+typeid(*obj2);
++++}
};

struct+Counter
{
++++static+std::vector<A*>+objects;

++++static+void+add(A*+obj)
++++{
++++++++objects.push_back(obj);
++++}

++++static+int+count(A*+obj)
++++{
++++++++return+std::count_if(objects.begin(),+objects.end(),
+++++++++++++++++++++++++++++std::bind1st(TypeIdsEqual<A*>(),+obj));
++++}

};

std::vector<A*>+Counter::objects;

//+One+intrusive+line+in+the+base+class+constructor.++None+in+derived+classes...
A::A()
{
++++Counter::add(this);
}

int+main(int+*argc,+char*+argv[])
{
++++A*+a++=+new+A;
++++B*+b++=+new+B;
++++C*+c++=+new+C;
++++C*+c2+=+new+C;
++++std::cout+<<+Counter::count(*a)+<<+std::endl;++//+Output:+1
++++std::cout+<<+Counter::count(*b)+<<+std::endl;++//+Output:+1
++++std::cout+<<+Counter::count(*c)+<<+std::endl;++//+Output:+2
}|code-block|syntax|javascript|3860021|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|$]]

One way to get around the double-counting when counting objects in the constructor is to count the objects at the point of need, rather than in the constructor, using RTTI. This is minimally intrusive:

<pre><code>#include &lt;vector&gt;
#include &lt;typeinfo&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;


class A
{

public:

 A();
 virtual ~A() { }

};

class B: public A
{

public:

 virtual ~B() { }
};

class C: public B
{

public:

 virtual ~C() { }

};

template&lt;class T&gt;
struct TypeIdsEqual: public std::binary_function&lt;T, T, bool&gt;
{
 bool operator() (const T&amp; obj1, const T&amp; obj2) const
 {
 return typeid(*obj1) == typeid(*obj2);
 }
};

struct Counter
{
 static std::vector&lt;A*&gt; objects;

 static void add(A* obj)
 {
 objects.push_back(obj);
 }

 static int count(A* obj)
 {
 return std::count_if(objects.begin(), objects.end(),
 std::bind1st(TypeIdsEqual&lt;A*&gt;(), obj));
 }

};

std::vector&lt;A*&gt; Counter::objects;

// One intrusive line in the base class constructor. None in derived classes...
A::A()
{
 Counter::add(this);
}

int main(int *argc, char* argv[])
{
 A* a = new A;
 B* b = new B;
 C* c = new C;
 C* c2 = new C;
 std::cout &lt;&lt; Counter::count(*a) &lt;&lt; std::endl; // Output: 1
 std::cout &lt;&lt; Counter::count(*b) &lt;&lt; std::endl; // Output: 1
 std::cout &lt;&lt; Counter::count(*c) &lt;&lt; std::endl; // Output: 2
}
</code></pre>

I'd like to be able to count instances of classes that belong in the same class hierarchy.

For example, let's say I have this:

<pre><code>class A;
class B: public A;
class C: public B;
</code></pre>

and then I have this code

<pre><code>A* tempA = new A;
B* tempB = new B;
C* tempC = new C;
C* tempC2 = new C;

printf(tempA-&gt;GetInstancesCount());
printf(tempB-&gt;GetInstancesCount());
printf(tempC-&gt;GetInstancesCount());
</code></pre>

the result of that should print 
 1 
 1 
 2 

The counting, ideally, should be done internally. Each class, and not some kind of manager, should know how many instances it has.

Any ideas?

Thanks!

Counting instances of individual derived classes

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我希望能够计算属于同一类层次结构的类的实例。例如，假设我有以下内容：class A;class B: public A;class C: public B;然后我有了这个代码A* tempA = new A;B* tempB = new B;C* tempC = new C;C* tempC2 = new C;prin...

问计算单个派生类的实例数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算单个派生类的实例数EN