在我以前的公司中,我们之所以这样做,是因为建立了一个宏观,将阶级名称作为参数,形成一个具有独特性(基于阶级名称)的当地静态,然后在返回静态成员的基类中确立一种虚拟功能。 这样一来,你就可以从物体等级的任何一种情况获得该身份证明,类似于ava物体的“Class()”方法,尽管更是原始。

我对迄今的答复感到不快,我为我找到了一种解决办法。 想法是用“Info”来计算一个字面。 每次在装货申请时都做过,因此没有超负荷运行。 这一解决办法还将使用共享图书馆作为名称,其名称和散射线一致。

这是我使用的法典。 这对我来说是巨大的。

#include <string>
#include <typeinfo>
#include <stdint.h>

//###########################################################################
// Hash
//###########################################################################
#if __SIZEOF_POINTER__==8
inline uint64_t hash(const char *data, uint64_t len) {
    uint64_t result = 14695981039346656037ul;
    for (uint64_t index = 0; index < len; ++index)
    {
        result ^= (uint64_t)data[index];
        result *= 1099511628211ul;
    }
    return result;
}
#else
inline uint32_t hash(const char *data, uint32_t len) {
    uint32_t result = 2166136261u;
    for (uint32_t index = 0; index < len; ++index)
    {
        result ^= (uint32_t)data[index];
        result *= 16777619u;
    }
    return result;
}
#endif
inline size_t hash(const std::string & str) { return hash(str.c_str(), str.length()); }

//###########################################################################
// TypeId
//###########################################################################
typedef size_t TypeId;

template<typename T>
static const std::string & typeName() {
    static const std::string tName( typeid(T).name() );
    return tName;
}
template<typename T>
static TypeId typeId() {
    static const TypeId tId = hash( typeName<T>() );
    return tId;
}

#include <stdint.h>
#include <stdio.h>

#define DEFINE_CLASS(class_name) 
    class class_name { 
    public: 
        virtual uint32_t getID() { return hash(#class_name); } 

// djb2 hashing algorithm
uint32_t hash(const char *str)
{
    unsigned long hash = 5381;
    int c;

    while ((c = *str++))
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

    return hash;
}

DEFINE_CLASS(parentClass)

    parentClass() {};
    ~parentClass() {};
};

DEFINE_CLASS(derivedClass : public parentClass)

    derivedClass() : parentClass() {};
    ~derivedClass() {};
};

int main() {
    parentClass parent;
    derivedClass derived;
    printf("parent id: %x
derived id: %x
", parent.getID(), derived.getID());
}

何种身份识别? 你们是否指望得到原子增长? 如果扼杀是罚款,那么:

static string s_id()
{
   return typeid(Foo<DERIVED>).name();
}

如果它必须是隐蔽的,但并非自动增加,那么你就可以知道,对于128个轨道的星群来说,不可能发生碰撞(尽管可能比你需要多得多)。

The following snippet work in VS(2015) and Release Building:

template <typename T>
struct TypeId
{
  static size_t Get()
  {
    return reinterpret_cast<size_t>(&sDummy);
  }

private:
  static char sDummy;
};

template <typename T>
char TypeId<T>::sDummy; // don t care about value

还在海合会第7.3号(Ubuntu 1604)和LFL诉10.0.0号(Mac OS High Sierra)上进行了试验和测试。

如何运作:每个瞬时使用<代码>TypeId<>模板都有其自己的独特的大陪审团,有其独特的地址。 为了诚实,我不全心全意地确定,为什么功能-统计版本在释放时没有工作——我怀疑同志同道合和优化。

阅读器的演练:至少应当获得与原始类型相同的类型识别。

没有任何标准。 此外,我没有发现这种无ool的黑板。

最好的一号是:

template < class DERIVED, int sid >
class Foo
{
    public:    
      static int s_id()    
      {        
          return sid;
      }    
};

Foo<MyClass, 123456>   derivedObject;

你可以做以下工作:

#include <iostream>


template <int id = 5>
class blah
{
public:
    static const int cid = id; 
};

int main(int argc, char *argv[])
{
    std::cout << blah<>::cid << " " << blah<10>::cid << std::endl;

}

我不知道这是否是一个好主意。 The blah<> part is a bit unuitive. 也许你会更妥善地调换手法,或者你能够打造一个基类,给它一个与你的班子相提的模板。