在 2 个模板函数之间共享模板类型的数据

所以有几个部分。 首先，根据类型查找运行时数据。 std::type_index与typeid操作员一起为您解决了这个问题。

第二部分是存储未知类型的数据。 std::experimental::any这样做。

第三部分是把它包起来，这样你就不必考虑它了。

struct poly_storage {
  std::unordered_map< std::type_index, std::experimental::any > data;
  template<class T, class...Args> void store( Args&&... args ) {
    auto it = data.find(typeid(T));
    if (it == data.end()) {
      data.emplace(
        std::make_pair( typeid(T), T{std::forward<Args>(args)...} )
      );
    } else {
      data[typeid(T)] = T{ std::forward<Args>(args)... };
    }
  }
  template<class T>
  T* get() {
    auto it = data.find(typeid(T));
    if (it == data.end()) return nullptr;
    return std::any_cast<T>(&(it->second));
  }
  template<class T>
  T const* get() const {
    auto it = data.find(typeid(T));
    if (it == data.end()) return nullptr;
    return std::any_cast<T>(&(it->second));
  }
};

poly_storage.store<T>( blah ) blah以T作为T的钥匙存储。

poly_storage.get<T>()返回一个T*，如果获取失败，该nullptr。 它还支持const访问。

any基本上是一个类型安全的void*。

与 R.Sahu 的答案类似，但使用 std::tuple(需要 C++14，但可以在 C++11 中完成(

template<typename ... Args>
class Container
{
public:
    template<class T> void Set(const T& value)
    {
        std::get<T>(data) = value;
    }
    template<class T> const T& Get() const
    {
       return std::get<T>(data);
    }
private:
    std::tuple<Args...> data;
};
int main()
{
   Container<int, float, double> c;
   c.Set(10);
   c.Set(20.125f);
   c.Set(30.7890);
   std::cout << c.Get<int>() << std::endl;
   std::cout << c.Get<float>() << std::endl;
   std::cout << c.Get<double>() << std::endl;
}

现场示例

如果您只想能够调用c.Get()并让它返回最后存储的任何内容，那是不可能的。

也许我高估了C++的元编程能力

不要高估，你把他们混淆了，他们不是。

模板(和函数的返回类型(是静态的编译时属性。最后存储在对象中的内容是动态属性。

Get的返回类型必须在编译时知道，这将要求编译器静态分析程序的其余部分，以确定上次调用Set是什么以及它存储了什么类型。这在一般情况下是不可能的，对Set的调用可能位于编译器不可见的其他翻译单元中，或者您可以执行以下操作：

Container c;
int i = 1;
std::string s = "two";
if (rand() % 2)
  c.Set(&i);
else
  c.Set(&s);
auto res = c.Get();  // What is the type here?

如果使容器成为模板不是一个选项，则需要自己编写代码来动态存储任何类型(查看"类型擦除"(，然后

• Get返回"非类型化"的内容，如void*或std::experimental::any或boost::any，并要求用户转换回原始类型;或
• 要求用户调用Get<int>()以便他们指定类型并让容器执行强制转换。

例如，使用 std::experimental::any 执行类型擦除和强制转换如下所示：

class Container
{
    std::experimental::any m_data;
public:
    template<class T> void Set(T* data)
    {
        m_data = std::experimental::any(data);
    }
    template<class T> T* Get()
    {
        return std::experimental::any_cast<T*>(m_data)
    }
};
Container c;
int i = 1;
c.Set(&i);
int* pi = c.Get<int>();
std::string s = "two";
c.Set(&s);
std::string* ps = c.Get<std::string*>();
// this will return a null pointer:
pi = c.Get<int*>();

(注意：与直接使用any相比，这并没有给您带来任何优势，但也许您想添加其他功能，以便Container类型有意义。

不是你要找的，但希望下面的代码能给你一些想法。

#include <iostream>
class Container
{
   public:
    template<class T> void Set(T data)
    {
       static_cast<Datum<T>&>(data_).datum = data;
    }
    template<class T> T Get() const
    {
       return static_cast<Datum<T> const&>(data_).datum;
    }
   private:
    template <typename T>
    struct Datum
    {
       T datum;
    };
    struct Data : Datum<int>,
                  Datum<float>,
                  Datum<double>
   {
   };
    Data data_;
};
int main()
{
   Container c;
   c.Set(10);
   c.Set(20.125f);
   c.Set(30.7890);
   std::cout << c.Get<int>() << std::endl;
   std::cout << c.Get<float>() << std::endl;
   std::cout << c.Get<double>() << std::endl;
   return 0;
}