C++ 是否为每个模板实例化生成唯一的类型或id？（示例观察者模式）

是否有一种方法或技术可以在编译时为每个模板实例化生成唯一的类型或ID

例如，此观察者模式：

#include <set>
#include <iostream>

template <typename T>
struct type2type {};    // maybe int2type


template<class T, class T_UNIQUE>
struct OBSERVER_BASE
{
  virtual void notify ( T, type2type< T_UNIQUE > ) = 0;
};

template<class T, class T_UNIQUE>
struct SUBJECT_BASE
{
  // This i like to do without the T_UNIQUE parameter
  typedef T_UNIQUE unique_type;

  std::set< OBSERVER_BASE< T, unique_type >* > my_observer{};

  void do_notify ()
  {
    for ( auto obs : my_observer )
      obs->notify ( T{}, type2type< unique_type >{} );
  }
};


class X {};
class Y {};
                                          // manual unique required?
class Subject_A : public SUBJECT_BASE< X, Subject_A > {};
class Subject_B : public SUBJECT_BASE< X, Subject_B > {};
class Subject_C : public SUBJECT_BASE< Y, Subject_C > {};

// typedef UNIQUE_. only to illustrate the idea 
typedef typename Subject_A::unique_type UNIQUE_A;
typedef typename Subject_B::unique_type UNIQUE_B;
typedef typename Subject_C::unique_type UNIQUE_C;

class Observer :
  public OBSERVER_BASE< X, UNIQUE_A >,
  public OBSERVER_BASE< X, UNIQUE_B >,
  public OBSERVER_BASE< Y, UNIQUE_C >
{
  virtual void notify ( X, type2type< UNIQUE_A > ) override
  {
    std::cout << "x from Subject_A" << std::endl;
  }

  virtual void notify ( X, type2type< UNIQUE_B > ) override
  {
    std::cout << "x from Subject_B" << std::endl;
  }

  virtual void notify ( Y, type2type< UNIQUE_C > ) override
  {
    std::cout << "y from Subject_C" << std::endl;
  }
};

int main ( int argc, char **argv )
{
  Subject_A sub_a {};
  Subject_B sub_b {};
  Subject_C sub_c {};

  Observer obs {};

  sub_a.my_observer.insert( &obs );
  sub_b.my_observer.insert( &obs );
  sub_c.my_observer.insert( &obs );

  sub_a.do_notify();
  sub_b.do_notify();
  sub_c.do_notify();
}

#包括
#包括
模板
结构类型2类型{}；//也许是int2type
模板
结构观察者库
{
虚拟无效通知（T，type2type）=0；
};
模板
结构主题库
{
//我喜欢不使用T_UNIQUE参数
typedef T_UNIQUE_type；
std:：set*>my\u OBSERVER{}；
无效通知（）
{
用于（自动obs：我的观察者）
obs->notify（T{}，type2type{}）；
}
};
类X{}；
类Y{}；
//需要手动操作吗？
类主题：公共主题库{}；
类主题：公共主题库{}；
类主题C：公共主题库{}；
//typedef唯一性。只是为了说明这个想法
typedef typename Subject_A:：unique_type unique_A；
typedef typename Subject_B:：unique_type unique_B；
typedef typename Subject_C:：unique_type unique_C；
班级观察员：
公共观察者基地，
公共观察者基础
{
虚拟无效通知（X，type2type）覆盖
{
std:：cout我不认为有办法实现您的要求，但有可能实现您似乎想要的。此实现不需要手动
独特的类型
：

template<class T>
class Subject
{
  std::vector<std::function<void(T)>> observers;

public:
  void do_notify () {
    for ( auto& obs : observers )
      obs( T{} );
  }

  void add_listener(std::function<void(T)> l) {
      observers.emplace_back(std::move(l));
  }
};

class X {};
class Y {};

int main ()
{
  Subject<X> sub_a {};
  Subject<X> sub_b {};
  Subject<Y> sub_c {};

  sub_a.add_listener([](X){std::cout << "x from Subject_A" << std::endl;});
  sub_b.add_listener([](X){std::cout << "x from Subject_B" << std::endl;});
  sub_c.add_listener([](Y){std::cout << "y from Subject_C" << std::endl;});

  sub_a.do_notify();
  sub_b.do_notify();
  sub_c.do_notify();
}

模板
班级科目
{
向量观测器；
公众：
无效通知（）{
用于（自动和obs：观察员）
obs（T{}）；
}
void add_侦听器（std:：function l）{
观察者：向后安置（标准：：移动（l））；
}
};
类X{}；
类Y{}；
int main（）
{
主题分组{}；
主题sub_b{}；
科目分组{}；
sub_a.add_listener（[]（X）{std:：cout您可以使用
typeid（T）吗
，或
std:：type_index
？@KerrekSB:似乎目标是
Subject_A
和
Subject_B
具有唯一的基类，尽管两者都使用
Subject_base
是唯一的类型。@Cory Nelson:但我想使用
T_unique
来重载notify方法
notify（T，type2type）
这是观察者模式的一个很好的解决方案。我们不需要观察者基类，也不需要虚拟方法。（基于Casey->带有观察者类的版本）coliru链接已过期；太糟糕了，我本想看到它。
template<class T>
class Subject
{
  std::vector<std::function<void(T)>> observers;

public:
  void do_notify () {
    for ( auto& obs : observers )
      obs( T{} );
  }

  void add_listener(std::function<void(T)> l) {
      observers.emplace_back(std::move(l));
  }
};

class X {};
class Y {};

int main ()
{
  Subject<X> sub_a {};
  Subject<X> sub_b {};
  Subject<Y> sub_c {};

  sub_a.add_listener([](X){std::cout << "x from Subject_A" << std::endl;});
  sub_b.add_listener([](X){std::cout << "x from Subject_B" << std::endl;});
  sub_c.add_listener([](Y){std::cout << "y from Subject_C" << std::endl;});

  sub_a.do_notify();
  sub_b.do_notify();
  sub_c.do_notify();
}