这是如何运作的?(C 名称查找魔术）

我一直在研究谷物和boost ::序列化代码，以了解班级注册的工作方式，但无法理解几点。

这是我的理解会发生什么：

• 我要求明确的static_object<magic<B№>>。
• 在构造函数中有一个呼叫adl_magic，这会导致编译器实例化其所有过载。
• 由于其中一些过载的返回类型是指typename instantiator<inserter<A№, T>>::type，因此编译器制作了一个 instantiator(无需双关语(。
• 现在，我不明白接下来会发生什么。它为什么要实例化static_object<nserter<A№, T>>，即使它是从从未被调用的函数的内部引用的？为什么需要dummy(为什么不同的编译器需要不同的编译器(？而且，如果我用typename instantiator<inserter<A№, T>>::type替换CC_7，为什么它不起作用？

对我来说，其余代码似乎很明显。

template<typename T>
class static_object {
    static void use(T const&) {}
    static T& ref;
    static T& create()
    {
        static T object;
        use(ref);  // why it doesn't work without this line?
        return object;
    }
public:
    static T& instance() { return create(); }
};
template <class T>
T& static_object<T>::ref = static_object<T>::create();

template <void(*)()> struct instantiate_function {};
template<typename T>
struct instantiator {
    static void instantiate() { static_object<T>::instance(); }
#ifdef _MSC_VER
    virtual void dummy() { instantiate(); }
#else
    using dummy = instantiate_function<instantiate>;
#endif
};
#include <string>
#include <vector>
// This gets called when stuff below is instantiated
using list = std::pair<std::string, std::string>;
using list = static_object<std::vector<string_pair>>;
template<typename A, typename B>
struct inserter {
    inserter()
    {
        list::instance().push_back(std::pair{A::name, B::name});
    }
};
// These are just some structs for demonstration.
struct A1 { static const char name[]; }; const char A1::name[] = "A1";
struct A2 { static const char name[]; }; const char A2::name[] = "A2";
struct B1 { static const char name[]; }; const char B1::name[] = "B1";
struct B2 { static const char name[]; }; const char B2::name[] = "B2";
struct B3 { static const char name[]; }; const char B3::name[] = "B3";
// I've omitted an "adl_tag" argument, which is needed to make 
// sure ADL finds all overloads
template<typename T> void adl_magic(T*, int) {}
// each of these would be behind some REGISTER_ARCHIVE(A) macro
template<typename T> typename instantiator<inserter<A1, T>>::type adl_magic(T*, A1*);
template<typename T> typename instantiator<inserter<A2, T>>::type adl_magic(T*, A2*);
template<typename T>
struct magic {
    magic()
    {
        adl_magic(static_cast<T*>(nullptr), 0);
    }
};
// each of these would be behind some REGISTER_CLASS(B) macro
template struct static_object<magic<B1>>;
template struct static_object<magic<B2>>;
template struct static_object<magic<B3>>;
#include <iostream>
int main()
{
    for(auto& p : list::instance())
        std::cout << p.first << ' ' << p.second << 'n';
}

编辑：如果我更改上面的相应声明，它们似乎与所有编译器一起使用。我不明白它们为什么起作用，但我认为它们这样做是因为auto强制static_object<T>的实例化推断类型。

template<typename T>
struct instantiator {
    static auto instantiate() { return static_object<T>::instance(); }
};
template<typename T> decltype(instantiator<inserter<A1, T>>::instantiate()) adl_magic(T*, A1*);
template<typename T> decltype(instantiator<inserter<A2, T>>::instantiate()) adl_magic(T*, A2*);

还有另一种变化，仅适用于GCC，而不是其他编译器：

template<typename T>
struct instantiator {
    static T& ref;
};
template<typename T>
T& instantiator<T>::ref = static_object<T>::instance();
template<typename T> decltype(instantiator<inserter<A1, T>>::ref) adl_magic(T*, A1*);
template<typename T> decltype(instantiator<inserter<A2, T>>::ref) adl_magic(T*, A2*);