template <typename T>
class Counting
{
public:Counting() { mCount++; }~Counting() { mCount--; }static int mCount;
};template <typename T> int Counting<T>::mCount = 0;class CountedA : public Counting<CountedA>{};
class CountedB : public Counting<CountedB>{};

#include "stdafx.h"
#include <stdio.h>template <typename T>
class Fucker
{
public:void doFuck() { printf("Failed :(\n"); }void Fuck() { ((T*)this)->doFuck(); }
};class AFucker : public Fucker<AFucker>
{};class BFucker : public Fucker<BFucker>
{
public:void doFuck() { printf("Shuang :)\n"); }
};int main(int argc, char** argv)
{Fucker<BFucker>* pFucker = new BFucker();pFucker->Fuck();return 0;
}

 1 template <class T>
 2 class LightRefBase
 3 {
 4 public:
 5     inline LightRefBase() : mCount(0) { }
 6     inline void incStrong(__attribute__((unused)) const void* id) const {
 7         __sync_fetch_and_add(&mCount, 1);
 8     }
 9     inline void decStrong(__attribute__((unused)) const void* id) const {
10         if (__sync_fetch_and_sub(&mCount, 1) == 1) {
11             delete static_cast<const T*>(this);
12         }
13     }
14     //! DEBUGGING ONLY: Get current strong ref count.
15     inline int32_t getStrongCount() const {
16         return mCount;
17     }
18
19     typedef LightRefBase<T> basetype;
20
21 protected:
22     inline ~LightRefBase() { }
23
24 private:
25     friend class ReferenceMover;
26     inline static void moveReferences(void*, void const*, size_t,
27             const ReferenceConverterBase&) { }
28
29 private:
30     mutable volatile int32_t mCount;
31 };

 1 class Base
 2 {
 3 public:
 4     Base() :mCount(0) {}
 5     int IncRef() { return ++mCount; }
 6     int DecRef() {
 7         if (--mCount <= 0) {
 8             delete this;
 9         }
10         return mCount;
11     }
12     virtual ~Base() {}
13 private:
14     int mCount;
15 };
16
17 class Derived : public Base
18 {};