C++ std:：tuple<&燃气轮机；一个std：：共享\u ptr<&燃气轮机；不起作用？

我最近发现，仅对一个元素使用

std:：tuple

有一个问题。我创建了一个用于类型擦除和保留N个引用计数对象的类。但是，如果引用计数对象是

std:：tuple

中的唯一对象，则不会保留该对象

我做错什么了吗

class token {
public:
  template<typename... Types>
  token(Types... types) : _self(std::make_shared<const std::tuple<Types...>>(std::make_tuple(std::move(types)...))) {}

  // Why do I need this special version of the constructor?
  // Uncomment and the code will work!
  //template<typename T>
  //token(T t) : _self(std::make_shared<const T>(std::move(t))) {}
private:
  std::shared_ptr<const void> _self;
};

类令牌{
公众：
模板
令牌（类型…类型）：\u self（std:：make_shared（std:：make_tuple（std:：move（类型））{}
//为什么我需要这个特殊版本的构造函数？
//取消注释，代码就可以工作了！
//模板
//令牌（T T）：_self（std:：make_shared（std:：move（T）））{
私人：
std：：共享的ptr自身；
};

示例（使用Xcode 8.0测试）：

token make_token（）{
std:：shared_ptr shared（新int（），[]（int*i）{
//如果只使用元组构造函数，则立即调用！
});
返回令牌（共享）；
}
token my_token=生成_token（）；//std:：shared_ptr已不存在！

从我的角度来看，您的代码应该可以正常工作，msvc和gcc在这方面似乎与我的观点一致。从T.C.的评论来看，这看起来像是叮当声的真正问题，并在叮当声主干中修复

作为目前的解决办法，我建议采用这种方法（

special\u Decation\t

取自）：

#包括
#包括
#包括
模板
结构展开\u refwrapper
{
使用类型=T；
};
模板
结构展开\u refwrapper
{
使用type=T&；
};
模板
使用特殊的\u decay\u t=typename展开\u refwrapper:：type；
类令牌{
公众：
模板
令牌（类型和类型）：\u self（std:：make_shared（std:：forward（类型）…）{
私人：
std：：共享的ptr自身；
};
token make_token（）{
返回令牌（std:：shared_ptr（new int（），[]（int*i）{
std:：cout在gcc中工作，但在clang@Danh谢谢！那我就不会发疯了。我该向谁报告这件事呢？好像是固定在行李箱上了（）。
token make_token() {
  std::shared_ptr<int> shared(new int(), [](int* i) {
    // Called immediately if using only tuple constructor!
  });
  return token(shared);
}
token my_token = make_token(); // std::shared_ptr<> is already gone!

#include <iostream>
#include <tuple>
#include <memory>

template <class T>
struct unwrap_refwrapper
{
    using type = T;
};

template <class T>
struct unwrap_refwrapper<std::reference_wrapper<T>>
{
    using type = T&;
};

template <class T>
using special_decay_t = typename unwrap_refwrapper<typename std::decay<T>::type>::type;

class token {
public:
  template<typename... Types>
  token(Types&&... types) : _self(std::make_shared<std::tuple<special_decay_t<Types>...>>(std::forward<Types>(types)...)) {}

private:
  std::shared_ptr<void> _self;
};


token make_token() {
  return token(std::shared_ptr<int>(new int(), [](int* i) {
    std::cout << "freed\n";
    delete i;
  }));
}

int main()
{
    token my_token = make_token();
    std::cout << __LINE__ << '\n';
}