C++继承std::tuple的Identifier类引用值丢失问题的原因与解决

问题描述 #

定义了一个继承自std::tuple的Identifier类，当将值类型的Identifier转换为含引用类型的Identifier并存入vector后，vector中的元素以及之前的引用类型Identifier里的字符串引用均变为无效值。相关代码如下：

#include <concepts>
#include <cstdint>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>

template< typename ... Args >
class Identifier: public std::tuple< Args... >
{
public:
   Identifier( Args... args ) requires( sizeof...( Args ) != 0 ) : std::tuple< Args... >( std::move( args )... )
   {}

   Identifier( std::tuple< Args... > tuple ):std::tuple< Args... >( tuple )
   {}

   Identifier()
   {}

   template< typename ... T >
   requires std::convertible_to< std::tuple< Args... >, std::tuple< T... > >
   Identifier( const Identifier< T... >& identifier ): std::tuple< Args... >(static_cast< std::tuple< T... > >(identifier))
   {}
};

int main()
{
   Identifier<std::wstring, std::int64_t>  item(L"id", 10);
   Identifier<const std::wstring&, std::int64_t> item_ref = item;

   std::vector< Identifier< const std::wstring&, std::int64_t > > collection;
   collection.emplace_back( item );
}

问题原因 #

1. 临时对象引发悬空引用：执行collection.emplace_back(item)时，触发模板构造函数将Identifier<std::wstring, std::int64_t>转换为Identifier<const std::wstring&, std::int64_t>。此时std::tuple<const std::wstring&, std::int64_t>会从std::tuple<std::wstring, std::int64_t>构造，这个转换过程会生成一个std::wstring的临时拷贝，引用绑定到该临时对象上。临时对象在构造完成后立即销毁，导致引用悬空，后续访问就会出现无效值。
2. vector扩容的潜在风险：即使临时对象问题解决，vector在扩容时会将元素移动/拷贝到新内存区域，原元素的引用会指向已释放的旧内存，同样会导致引用失效（不过本次问题的核心是前者）。

修复方案 #

方案1：避免存储裸引用（推荐） #

直接使用值类型作为Identifier的模板参数，从根源上消除引用悬空问题：

int main()
{
   Identifier<std::wstring, std::int64_t>  item(L"id", 10);
   // 使用值类型的Identifier，无需引用
   Identifier<std::wstring, std::int64_t> item_copy = item;

   std::vector<Identifier<std::wstring, std::int64_t>> collection;
   collection.emplace_back(item);
}

方案2：调整构造函数，直接绑定原对象引用 #

如果必须使用引用类型的Identifier，修改模板构造函数，直接从原对象的成员构造，避免生成临时对象：

template< typename ... Args >
class Identifier: public std::tuple< Args... >
{
public:
   // 保留原有构造函数...

   template< typename ... T >
   // 调整约束，确保每个参数可转换为对应引用类型
   requires (sizeof...(Args) == sizeof...(T)) && (... && std::convertible_to<const T&, Args>)
   Identifier(const Identifier< T... >& identifier) 
       : std::tuple<Args...>(std::get<0>(identifier), std::get<1>(identifier)) {}
};

这样构造时，引用直接绑定到item中的std::wstring对象，只要item的生命周期长于collection和item_ref，引用就会保持有效。

方案3：使用std::reference_wrapper替代裸引用 #

用std::reference_wrapper存储引用，它支持拷贝操作，不会因tuple转换产生临时对象：

#include <functional> // 引入std::reference_wrapper和std::cref

template< typename ... Args >
class Identifier: public std::tuple< Args... >
{
public:
   // 保留原有构造函数...
};

int main()
{
   Identifier<std::wstring, std::int64_t>  item(L"id", 10);
   // 使用reference_wrapper存储引用
   Identifier<std::reference_wrapper<const std::wstring>, std::int64_t> item_ref(
       std::cref(std::get<0>(item)), std::get<1>(item)
   );

   std::vector<Identifier<std::reference_wrapper<const std::wstring>, std::int64_t>> collection;
   collection.emplace_back(std::cref(std::get<0>(item)), std::get<1>(item));
}

内容的提问来源于stack exchange，提问作者Vladimir Shttl