如何调用模板函数的所有实例化函数？编码时未知实例化可行吗？

Alright, let's break down these two questions about C++ template functions—they're pretty common pain points when working with generic code!

C++ doesn't have a built-in language feature to automatically enumerate or call all instantiated versions of a template function. That's because template instantiation happens at compile/link time, and that information isn't exposed to runtime by default. But we can work around this with a manual registration pattern—here's how:

The Core Idea: #

We'll set up a global (or class-scoped) container to store pointers/wrappers for each instantiated template function. Then, we'll use static initialization to automatically register each instance when it's created.

Example Code: #

#include <vector>
#include <functional>
#include <iostream>
#include <typeinfo>

// Our target template function
template<typename T>
void print_value(T val) {
    std::cout << "print_value<" << typeid(T).name() << "> called: " << val << "\n";
}

// Container to hold all registered instances of print_value
std::vector<std::function<void()>> print_instances;

// Helper template to handle registration
template<typename T>
struct PrintRegistrar {
    PrintRegistrar() {
        // Wrap the template instance and add it to our container
        // Adjust the wrapper if you need to pass specific arguments
        print_instances.push_back([](){ print_value(T{}); });
    }
};

// Static registrar object—each template instantiation triggers this
template<typename T>
static PrintRegistrar<T> print_registrar;

// Explicitly instantiate the versions we need (or let implicit calls trigger instantiation)
template void print_value<int>(int);
template void print_value<double>(double);
template void print_value<std::string>(std::string);

int main() {
    // Call all registered instances
    for (auto& func : print_instances) {
        func();
    }
    return 0;
}

How It Works: #

• When we explicitly instantiate print_value<int> (or call it somewhere in code, triggering implicit instantiation), the static PrintRegistrar<T> object gets initialized. Its constructor adds a wrapped version of the template function to our container.
• At runtime, we just iterate over the container and call each stored function.

This depends on what you mean by "unknown at coding time":

• If instances are created in other modules or via implicit calls you don't explicitly write: Yes, you can still use the registration pattern above—just make sure the registrar logic is included wherever the template is instantiated (put the registrar code in a header that all instantiating modules include). As long as each instance triggers the registration, you'll collect all of them in the container.
• If you have no way to know which types will be instantiated at compile time: No, this isn't possible. C++ is a statically typed language—template instantiation must happen at compile time. You can't dynamically generate template instances at runtime, so there's no way to collect instances for types that aren't known during compilation.

In short: You can only call all instantiated versions if those instances are actually created during compilation (either explicitly or implicitly), and you've set up a way to track them.

内容的提问来源于stack exchange，提问作者Darius Duesentrieb