仅从一个模板参数中查找特定模板。有可能吗？

Question

假设我有这样的东西：

template <typename T, typename ...args>
static std::map<T, std::tuple<args...>> MyMaps;

每种类型在编译时都是已知的。因此，对于添加到映射中的每个类型配置，都会创建一个新的映射。

是否有一种方法可以在所有匹配T参数的映射实例中仅搜索关键字（和关键字类型）？

编辑：对不起，我的问题太简单了。我害怕把它做得太大，最后它错过了我的意图。但我想，正如@Quimby所解释的那样，我试图实现的目标是不可能实现的。

我真正想做的是一个debug助手（实际上是虚幻的），来跟踪对象值，比如一个可包含的. h（Debbughelper. h）：

#include <tuple>
#include <vector>
#include <type_traits>

#define WATCHMYOBJECT(object, ...) //TO DO
#define RESCANMYOBJECT(object) //TO DO

template <typename ...T>
void Expand(T...args)
{
    return;
}

template <typename T, typename ...args>
class MyWatcherClass
{
public:
    static void WatchMyObject(T &object, args& ...b);
    static void RescanMyObject(T& MyObject);
    static std::vector<MyWatcherClass*> Instaces;

private:
    std::tuple<args...> MyTuple = std::tuple<args...>();
    std::vector<void*> VoidPointerStorage;
    T* MyObjectPointer;

private:
    MyWatcherClass();
    ~MyWatcherClass();
};

template <typename T, typename ...args>
void MyWatcherClass<T, args...>::WatchMyObject(T &MyObject, args& ...b)
{
    MyWatcherClass<T, args...>* MyClassPointer = new MyWatcherClass;
    InstacedObjects.push_back(MyClassPointer);
    MyObjectPointer = &MyObject;
    int helpint = 0;
    MyClassPointer->MyTuple = std::make_tuple(b...);
    Expand((MyClassPointer->PointerStorage.push_back((void*)&b),1)...);
}

template <typename T, typename ...args>
void MyWatcherClass<T, args...>::RescanMyObject(T &MyObject)
{
    // I have yet to implement, but impossible to call this
    // Compare Instaces[i].MyObjectPointer with &MyObject to find the matching one
    // cast all the void pointers in std::vector<void*> VoidPointerStorage back to typed pointers using the tuple types
    // Get the values derefing the pointers and update on the screen, log, etc
}

然后，在一些宏观魔法的帮助下，有人可以做到:

// #include <"debbughelper.h">
class MyNormalClass
{
public:
    MyNormalClass(int _MyInt, float _MyFloat, std::string _MyString);
    int MyInt;
    float MyFloat;
    std::string MyString;
};

MyNormalClass::MyNormalClass(int _MyInt, float _MyFloat, std::string _MyString) : MyInt(_MyInt), MyFloat(_MyFloat), MyString(_MyString)
{
}

int main()
{
   MyNormalClass MyObject = MyNormalClass(1, 5.2f, std::string("hello"));
   WATCHMYOBJECT(MyObject, MyObject.MyInt, MyObject.MyFloat, MyObject.MyString);

// do other stuff

   RESCANMYOBJECT(MyObject); //easy, without the need to retype all the members
}

但如果没有成员的类型，就无法调用RescanMyObject。

Answer 1

取决于您所说的搜索是什么意思。您可以将它们收集到容器中，然后执行您喜欢的任何类型的处理：

#include <any>
#include <iostream>
#include <map>
#include <typeindex>
#include <vector>

std::map<std::type_index,       // key type
         std::vector<std::any>  // pointers to the maps with this key type
         >
    key_to_map;

template <typename T, typename... args>
auto& MyMap() {
  static std::map<T, std::tuple<args...>> map = [] {
    key_to_map[std::type_index(typeid(T))].push_back(&map);
    return decltype(map){};
  }();

  return map;
}

int main() {
  MyMap<int, char, double>();
  MyMap<char, int, double>();
  MyMap<int, short, long>();

  std::cout << "Number of maps with `int` as the key is "
            << key_to_map[std::type_index(typeid(int))].size() << '\n';
}

Answer 2

不。

要解决的根本问题是确定模板变量是否已实例化。否则，在无数可能的实例中寻找乐趣。

C 语言没有提供回答此类问题的工具，因为实现几乎是不可能的。主要是由于分离的编译和链接过程。博士;将是翻译单元 （TU） 尚未包含足够的信息，并且链接器为时已晚，因为代码已经生成。

每个翻译单元都单独编译到一个对象文件中。每个 TU 都看到了（希望是相同的）模板定义，从中实例化了此 TU 中使用的所有变量。但它不知道也不能知道其他 TU 中的任何实例化变量。

链接器的工作是收集所有这些目标文件，解析导出的和缺失的符号，包括< code >内联定义的重复数据删除，并最终创建可执行文件/库。

只有在最后一步之前，这个问题才能得到回答。但此时，代码已经生成，无法更改。即使编译器可能再次创建新代码，如果新代码生成更多的实例化，链接器是否应该再次尝试？这接近于运行时反射。