Question

鉴于以下内容：

template<typename T>
class A
{
public:
    static const unsigned int ID = ?;
};

我希望ID为每个T生成一个唯一的编译时间ID。我认为__COUNTER__和增强PP库但到目前为止都没有成功。我怎样才能做到这一点？

编辑：ID必须可用作switch语句中的大小写

Edit2：基于静态方法或成员地址的所有答案都不正确。虽然它们确实创建了一个唯一的ID，但它们在编译时没有被解析，因此不能用作switch语句的情况。

Answer 1

这足以假设符合标准的编译器（关于一个定义规则）：

template<typename T>
class A
{
public:
    static char ID_storage;
    static const void * const ID;
};

template<typename T> char A<T>::ID_storage;
template<typename T> const void * const A<T>::ID= &A<T>::ID_storage;

来自C ++标准3.2.5一个定义规则[basic.def.odr]（大胆强调我的）：

...如果D是模板并且在多个翻译中定义单位，则适用上述清单中的最后四项要求来自模板中使用的模板封闭范围的名称定义（14.6.3），以及相关的名称实例化（14.6.2）。 如果D的定义满足所有这些要求，那么程序应该表现得好像有一个单一的 D的定义。如果D的定义不满足这些要求，那么行为是未定义的。

Answer 2

我通常使用的是：

template<typename>
void type_id(){}

using type_id_t = void(*)();

由于函数的每个实例化都有自己的地址，因此您可以使用该地址来识别类型：

// Work at compile time
constexpr type_id_t int_id = type_id<int>;

// Work at runtime too
std::map<type_id_t, std::any> types;

types[type_id<int>] = 4;
types[type_id<std::string>] = "values"s

// Find values
auto it = types.find(type_id<int>);

if (it != types.end()) {
    // Found it!
}

Answer 3

这似乎对我有用：

template<typename T>
class Counted
{
  public:
  static int id()
  {
    static int v;
    return (int)&v;
  }
};

#include <iostream>

int main()
{
  std::cout<<"Counted<int>::id()="<<Counted<int>::id()<<std::endl;
  std::cout<<"Counted<char>::id()="<<Counted<char>::id()<<std::endl;

}

Answer 4

可以使用this answer中的代码从字符串生成编译时HASH。

如果您可以修改模板以包含一个额外的整数并使用宏来声明变量：

template<typename T, int ID> struct A
{
    static const int id = ID;
};

#define DECLARE_A(x) A<x, COMPILE_TIME_CRC32_STR(#x)>

将此宏用于类型声明，id成员包含类型名称的哈希。例如：

int main() 
{
    DECLARE_A(int) a;
    DECLARE_A(double) b;
    DECLARE_A(float) c;
    switch(a.id)
    {
    case DECLARE_A(int)::id:
        cout << "int" << endl;
        break;
    case DECLARE_A(double)::id:
        cout << "double" << endl;
        break;
    case DECLARE_A(float)::id:
        cout << "float" << endl;
        break;
    };
    return 0;
}

当类型名称转换为字符串时，对类型名称文本的任何修改都会产生不同的ID。例如：

static_assert(DECLARE_A(size_t)::id != DECLARE_A(std::size_t)::id, "");

另一个缺点是由于可能发生哈希冲突。

Answer 5

使用静态函数的内存地址。

template<typename T>
class A  {
public:
    static void ID() {}
};

(&(A<int>::ID))将与(&(A<char>::ID))不同，依此类推。

Answer 6

我最近遇到了这个问题。我的解决方案：

counter.hpp

class counter
{
    static int i;
    static nexti()
    {
        return i++;
    }
};

Counter.cpp：

int counter::i = 0;

templateclass.hpp

#include "counter.hpp"

    template <class T>
    tclass
    {
        static const int id;
    };

    template <class T>
    int tclass<T>::id = counter::nexti();

它可以在MSVC和GCC中正常工作，但有一个例外是你不能在switch语句中使用它。

由于各种原因，我实际上更进一步，并定义了一个预处理器宏，它从给定的name参数创建一个新类，其中包含一个从公共库派生的静态ID。

Answer 7

使用this常量表达式计数器：

 $.ajax({
                        type: 'GET',
                        dataType: 'jsonp',
                        url: 'http://localhost:8983/solr/hruser/select?fq=id:*dev*&fq=org_id:18&indent=on&q=*:*&wt=json',

                        success: function(data) {
                            console.log(data)
                            
                        }
                    });

输出：（GCC，C ++ 14）

template <class T>
class A
{
public:
    static constexpr int ID() { return next(); }
};
class DUMMY { };
int main() {
    std::cout << A<char>::ID() << std::endl;
    std::cout << A<int>::ID() << std::endl;
    std::cout << A<BETA>::ID() << std::endl;
    std::cout << A<BETA>::ID() << std::endl;
    return 0;
}

缺点是您需要猜测常量表达式计数器的派生类数量的上限才能正常工作。

Answer 8

使用模板，如果constexpr，需要c++17

$bank->transactions->sum('amount');

Answer 9

好的.....所以这是我在this网站上发现的黑客攻击。它应该工作。您唯一需要做的就是向struct添加另一个模板参数，该参数采用计数器＆＃34;元对象＆＃34;。请注意，A int，bool和char都有唯一ID，但不保证int＆＃39; s 1 1}}和bool将是2等，因为模板启动的顺序不一定是已知的。

另一个注意事项：

这不适用于Microsoft Visual C ++

#include <iostream>
#include "meta_counter.hpp"

template<typename T, typename counter>
struct A
{
    static const size_t ID = counter::next();
};

int main () {
    typedef atch::meta_counter<void> counter;
    typedef A<int,counter> AInt;
    typedef A<char,counter> AChar;
    typedef A<bool,counter> ABool;
    switch (ABool::ID)
    {
        case AInt::ID:
            std::cout << "Int\n";
            break;
        case ABool::ID:
            std::cout << "Bool\n";
            break;
        case AChar::ID:
            std::cout << "Char\n";
            break;
    }

    std::cout << AInt::ID << std::endl;
    std::cout << AChar::ID << std::endl;
    std::cout << ABool::ID << std::endl;
    std::cout << AInt::ID << std::endl;
    while (1) {}
}

以下是meta_counter.hpp：

// author: Filip Roséen <filip.roseen@gmail.com>
// source: http://b.atch.se/posts/constexpr-meta-container

#ifndef ATCH_META_COUNTER_HPP
#define ATCH_META_COUNTER_HPP

#include <cstddef>

namespace atch { namespace {

  template<class Tag>
  struct meta_counter {
    using size_type = std::size_t;

    template<size_type N>
    struct ident {
      friend constexpr size_type adl_lookup (ident<N>);
      static constexpr size_type value = N;
    };

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

    template<class Ident>
    struct writer {
      friend constexpr size_type adl_lookup (Ident) {
        return Ident::value;
      }

      static constexpr size_type value = Ident::value;
    };

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

    template<size_type N, int = adl_lookup (ident<N> {})>
    static constexpr size_type value_reader (int, ident<N>) {
      return N;
    }

    template<size_type N>
    static constexpr size_type value_reader (float, ident<N>, size_type R = value_reader (0, ident<N-1> ())) {
      return R;
    }

    static constexpr size_type value_reader (float, ident<0>) {
      return 0;
    }

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

    template<size_type Max = 64>
    static constexpr size_type value (size_type R = value_reader (0, ident<Max> {})) {
      return R;
    }

    template<size_type N = 1, class H = meta_counter>
    static constexpr size_type next (size_type R = writer<ident<N + H::value ()>>::value) {
      return R;
    }
  };
}}

#endif /* include guard */

Answer 10

以下是一种可能的解决方案，主要基于模板：

#include<cstddef>
#include<functional>
#include<iostream>

template<typename T>
struct wrapper {
    using type = T;
    constexpr wrapper(std::size_t N): N{N} {}
    const std::size_t N;
};

template<typename... T>
struct identifier: wrapper<T>... {
    template<std::size_t... I>
    constexpr identifier(std::index_sequence<I...>): wrapper<T>{I}... {}

    template<typename U>
    constexpr std::size_t get() const { return wrapper<U>::N; }
};

template<typename... T>
constexpr identifier<T...> ID = identifier<T...>{std::make_index_sequence<sizeof...(T)>{}};

// ---

struct A {};
struct B {};

constexpr auto id = ID<A, B>;

int main() {
    switch(id.get<B>()) {
    case id.get<A>():
        std::cout << "A" << std::endl;
        break;
    case id.get<B>():
        std::cout << "B" << std::endl;
        break;
    }
}

请注意，这需要C ++ 14。

要将顺序ID与类型列表相关联，您需要做的就是将该列表提供给模板变量，如上例所示：

constexpr auto id = ID<A, B>;

从那时起，您可以通过get方法获取给定类型的给定ID：

id.get<A>()

就是这样。您可以根据请求在switch语句中使用它，如示例代码所示。

请注意，只要将类型附加到与数字ID关联的类列表中，每次编译后以及每次执行期间标识符都相同。
如果要从列表中删除类型，仍可以使用伪类型作为占位符，例如：

template<typename> struct noLonger { };
constexpr auto id = ID<noLonger<A>, B>;

这将确保A不再具有关联的ID，并且B的ID不会更改。
如果你不肯定删除A，你可以使用类似的东西：

constexpr auto id = ID<noLonger<void>, B>;

或者其他什么。

Answer 11

以下是使用__DATE__和__TIME__宏来获取类型<T>的唯一标识符的C ++代码

<强>格式：

// __DATE__ "??? ?? ????"
// __TIME__ "??:??:??"

这是一种质量差的哈希函数：

#define HASH_A 8416451
#define HASH_B 11368711
#define HASH_SEED 9796691    \
+ __DATE__[0x0] * 389        \
+ __DATE__[0x1] * 82421      \
+ __DATE__[0x2] * 1003141    \
+ __DATE__[0x4] * 1463339    \
+ __DATE__[0x5] * 2883371    \
+ __DATE__[0x7] * 4708387    \
+ __DATE__[0x8] * 4709213    \
+ __DATE__[0x9] * 6500209    \
+ __DATE__[0xA] * 6500231    \
+ __TIME__[0x0] * 7071997    \
+ __TIME__[0x1] * 10221293   \
+ __TIME__[0x3] * 10716197   \
+ __TIME__[0x4] * 10913537   \
+ __TIME__[0x6] * 14346811   \
+ __TIME__[0x7] * 15485863

unsigned HASH_STATE = HASH_SEED;
unsigned HASH() {
    return HASH_STATE = HASH_STATE * HASH_A % HASH_B;
}

使用哈希函数：

template <typename T>
class A
{
public:
    static const unsigned int ID;
};

template <>
const unsigned int A<float>::ID = HASH();

template <>
const unsigned int A<double>::ID = HASH();

template <>
const unsigned int A<int>::ID = HASH();

template <>
const unsigned int A<short>::ID = HASH();

#include <iostream>

int main() {
    std::cout << A<float>::ID << std::endl;
    std::cout << A<double>::ID << std::endl;
    std::cout << A<int>::ID << std::endl;
    std::cout << A<short>::ID << std::endl;
}

Answer 12

几个月前我遇到过类似的问题。我正在寻找一种技术来定义每次执行时相同的标识符如果这是一项要求，here是另一个可以探讨或多或少相同问题的问题（当然，它附带了很好的答案）。
无论如何，我没有使用建议的解决方案。它遵循我当时所做的事情的描述。

您可以定义constexpr函数，如下所示：

static constexpr uint32_t offset = 2166136261u;
static constexpr uint32_t prime = 16777619u;

constexpr uint32_t fnv(uint32_t partial, const char *str) {
    return str[0] == 0 ? partial : fnv((partial^str[0])*prime, str+1);
}

inline uint32_t fnv(const char *str) {
    return fnv(offset, str);
}

然后像这样继承的类：

template<typename T>
struct B {
    static const uint32_t id() {
        static uint32_t val = fnv(T::identifier);
        return val;
    }
};

其余的CRTP习惯用法例如，您可以按照以下方式定义派生类：

struct C: B<C> {
    static const char * identifier;
};

const char * C::identifier = "ID(C)";

只要您为不同的类提供不同的标识符，您将拥有可用于区分类型的唯一数字值。

标识符不需要是派生类的一部分。例如，您可以通过特征提供它们：

template<typename> struct trait;
template<> struct trait { static const char * identifier; };

// so on with all the identifiers

template<typename T>
struct B {
    static const uint32_t id() {
        static uint32_t val = fnv(trait<T>::identifier);
        return val;
    }
};

优点：

易于实施。
没有依赖。
每次执行时的数值都相同。
如果需要，类可以共享相同的数字标识符。

缺点：

容易出错：复制粘贴很快就会成为你最大的敌人。

它遵循上面所描述的最小的工作实例我调整了代码，以便能够在ID语句中使用switch成员方法：

#include<type_traits>
#include<cstdint>
#include<cstddef>

static constexpr uint32_t offset = 2166136261u;
static constexpr uint32_t prime = 16777619u;

template<std::size_t I, std::size_t N>
constexpr
std::enable_if_t<(I == N), uint32_t>
fnv(uint32_t partial, const char (&)[N]) {
    return partial;
}

template<std::size_t I, std::size_t N>
constexpr
std::enable_if_t<(I < N), uint32_t>
fnv(uint32_t partial, const char (&str)[N]) {
    return fnv<I+1>((partial^str[I])*prime, str);
}

template<std::size_t N>
constexpr inline uint32_t fnv(const char (&str)[N]) {
    return fnv<0>(offset, str);
}

template<typename T>
struct A {
    static constexpr uint32_t ID() {
        return fnv(T::identifier);
    }
};

struct C: A<C> {
    static constexpr char identifier[] = "foo";
};

struct D: A<D> {
    static constexpr char identifier[] = "bar";
};

int main() {
    constexpr auto val = C::ID();

    switch(val) {
    case C::ID():
        break;
    case D::ID():
        break;
    default:
        break;
    }
}

请注意，如果您想在非常量表达式中使用ID，则必须在identifier处定义以下内容：

constexpr char C::identifier[];
constexpr char D::identifier[];

一旦你做到了，你可以这样做：

int main() {
    constexpr auto val = C::ID();
    // Now, it is well-formed
    auto ident = C::ID();

    // ...
}

Answer 13

这不可能。静态对象的地址是您可以获得唯一ID的最接近的地址，但是为了获取此类对象的地址（甚至是静态const积分），必须在某处定义它们。根据一个定义规则，它们应该在CPP文件中定义，由于它们是模板，因此无法完成。如果在头文件中定义静态，那么每个编译单元将在不同的地址实现它自己的版本。

Answer 14

如果你可以为你想要使用的每个DECLARE_ID(type)写一个额外的行type，这是一个实用的解决方案：

 #include <iostream>

 template<class> struct my_id_helper;
 #define DECLARE_ID(C) template<> struct my_id_helper<C> { enum {value = __COUNTER__ }; }

 // actually declare ids:
 DECLARE_ID(int);
 DECLARE_ID(double);
 // this would result in a compile error: redefinition of struct my_id_helper<int>’
 // DECLARE_ID(int);

 template<class T>
 class A
 {
 public:
     static const unsigned int ID = my_id_helper<T>::value;
 };

 int main()
 {
     switch(A<int>::ID)
     {
     case A<int>::ID:    std::cout << "it's an int!\n"; break;
     case A<double>::ID: std::cout << "it's a double!\n"; break;
     // case A<float>::ID: // error: incomplete type ‘my_id_helper<float>’
     default: std::cout << "it's something else\n"; break;
     }
 }

Answer 15

另一种方法是使用唯一的静态成员字段[0-9]*,[0-9]*来考虑以下类Data：

type

生成输出（template <class T> class Data { public: static const std::type_index type; }; // do [static data member initialization](http://stackoverflow.com/q/11300652/3041008) // by [generating unique type id](http://stackoverflow.com/q/26794944/3041008) template <class T> std::type_index const Data<T>::type = std::type_index(typeid(T));）

MinGWx64-gcc4.8.4 -std=c++11 -O2

它不是一个整数id或可打印的字符串，也不是printf("%s %s\n", Data<int>::type.name(), Data<float>::type.name()) //prints "i f"，但可以是used as an index in (un)ordered associative containers。
如果constexpr标头包含在多个文件中（相同的Data.h值），它似乎也有效。

Answer 16

template<typename T>
static void get_type_id() { void* x; new (x) T(); }
using type_id_t = void(*)();

可以很好地进行优化

Answer 17

如果可以接受非单调值和intptr_t：

template<typename T>
struct TypeID
{
private:
    static char id_ref;
public:
    static const intptr_t ID;
};

template<typename T>
  char TypeID<T>::id_ref;
template<typename T>
  const intptr_t TypeID<T>::ID = (intptr_t)&TypeID<T>::id_ref;

如果你必须有整数，或者必须有单调递增的值，我认为使用静态构造函数是唯一的方法：

// put this in a namespace
extern int counter;

template<typename T>
class Counter {
private:
  Counter() {
    ID_val = counter++;
  }
  static Counter init;
  static int ID_val;
public:
  static const int &ID;
};

template<typename T>
  Counter<T> Counter<T>::init;
template<typename T>
  int Counter<T>::ID_val;
template<typename T>
  const int &Counter<T>::ID = Counter<T>::ID_val;

// in a non-header file somewhere
int counter;

请注意，如果您在共享库和应用程序之间共享它们，这些技术都不安全！

编译时常量id

17 个答案: