收集有关在程序中实例化哪些模板变体的信息

如果您愿意将额外变量的成本添加到对象中，这似乎可以满足您的需求，尽管这一切都非常复杂，我可能会错过一个案例：

#include <iostream>
static int& gInt() { // Global counter
static int i;
return i;
}
struct Initializer {
Initializer() { ++gInt(); }
};

template <class T>
struct Foo {
Foo() { // This never gets called and we want that
std::cout << "Constructed Foo!" << std::endl; 
}
private:
static Initializer gint_incrementer;
void* p_ = &gint_incrementer; // force existence 
};
template <typename T>
Initializer Foo<T>::gint_incrementer;
void unused() {
Foo<char> c;
Foo<char> c2;
Foo<double> d;
Foo<int> i;
Foo<float> f;
}
int main() {
std::cout << gInt() << std::endl; // prints 4
}

如果我们使用schwartz 反习语的变体，则无需黑客攻击且不需要unused()函数即可实现：

global_counter.hpp

#pragma once
struct GlobalCounter {
int next();
int value() const;
int value_ = 0;
struct init {
init();
~init();
};
};
extern GlobalCounter& globalCounter;
static GlobalCounter::init globalCounterInit;

global_counter.cpp

#include "global_counter.hpp"
#include <memory>
#include <type_traits>
static int globalCounterCount;
static std::aligned_storage_t <sizeof(GlobalCounter), alignof(GlobalCounter)> globalCounterStorage;
GlobalCounter& globalCounter = reinterpret_cast<GlobalCounter&>(globalCounterStorage);
GlobalCounter::init::init() {
if(globalCounterCount++ == 0) new (&globalCounter) GlobalCounter ();
}
GlobalCounter::init::~init() {
if (--globalCounterCount == 0) globalCounter.~GlobalCounter();
}
int GlobalCounter::next() {
return value_++;
}
int GlobalCounter::value() const {
return value_;
}

foo.hpp

#pragma once
#include "global_counter.hpp"
#include <iostream>
template <class T>
struct Foo {
Foo() { // This never gets called and we want that
std::cout << "Constructed Foo!" << std::endl;
}
static int ident;
};
template<class T>
int Foo<T>::ident;
template<class T>
struct EnableFoo
{
EnableFoo()
{
if (counter++ == 0)
Foo<T>::ident = globalCounter.next();
}
static int counter;
};
template<class T> int EnableFoo<T>::counter;

static EnableFoo<char> enableFooChar;
static EnableFoo<int> enableFooInt;
static EnableFoo<double> enableFooDouble;
static EnableFoo<float> enableFooFloat;

主.cpp

#include <iostream>
#include "foo.hpp"
int main() {
std::cout << globalCounter.value() << std::endl; // prints 4
return 0;
}

参见施瓦茨计数器：

https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Nifty_Counter

好的，因为我问题中的解决方案只是部分的，我将分享一个工作代码片段，它实际上显示了我所追求的东西，现在我想通了。

我们不需要任何特定于编译器的黑客，以下内容应该普遍有效：

#include <iostream>
#include <vector>
#include <string>
#include <mutex>
#include <boost/type_index.hpp>
static std::vector<std::string>& getInstantiations() {
static std::vector<std::string> instantiations;
return instantiations;
}
static std::mutex& getMutex() {
static std::mutex mut;
return mut;
}
template <class T>
struct Introspection {
Introspection() { 
std::lock_guard<std::mutex> lock(getMutex());
getInstantiations().push_back(boost::typeindex::type_id<T>().pretty_name());
}
void forceExistence() {}
};

template <class... Ts>
struct Foo {
Foo() { // This never gets called and we want that
std::cout << "Constructed Foo!" << std::endl;
introspection.forceExistence();
}
private:
static Introspection<Foo<Ts...>> introspection;
};
template <class... Ts>
Introspection<Foo<Ts...>> Foo<Ts...>::introspection;
void unused() {
Foo<char> c;
Foo<char> c2;
Foo<double> d;
Foo<int, const int> i;
Foo<float, bool, long> f;
}
int main() {
for (auto& i : getInstantiations()) {
std::cout << i << std::endl;
}
/*
output:
Foo<char>
Foo<double>
Foo<int, int const>
Foo<float, bool, long>
*/
}

它看起来很愚蠢，但考虑一个更大的项目，到处都是Foo<...>声明。是的，也许我可以只使用正则表达式搜索，但这样我实际上可以在检查程序运行时使用收集的信息。回显类型名称只是我们可以用它做什么的最简单示例。