初始化一个引用的shared_ptr ( std::tr1::shared_ptr)

Question

我正在使用一个库，它返回对我的引用。
我需要将此引用用作类属性。
无法直接在构造函数中初始化属性（需要之前初始化lib），我考虑使用shared_ptr进行延迟初始化：

#include <iostream>
#include <string>
#include <tr1/memory>

//This is library, cannot touch
std::string globalString = "TEST";
std::string& getStringReference()
{
    return globalString;
}

//this is my class which uses the library
class Foo
{
public:
    Foo() :
        testString_( std::tr1::shared_ptr< std::string& >() )
    {
        //do some initialization of the library here...
        //now init the shared_ptr
        testString_.reset( getStringReference() );
    }

    std::string getString() const
    {
        return *testString_;
    }

private:
    std::tr1::shared_ptr< std::string& > testString_;
};

//and a main to be compilable and check if the above works...
int main()
{
    Foo foo;
    std::cout << foo.getString() << std::endl;
}

但不幸的是这不起作用。 g++ 给出这样的消息：

error: forming pointer to reference type ‘std::string&’

我尝试了一些其他方法来将引用获取到shared_ptr，但是没有任何效果...也许你可以给我一个提示。

注：
- 在“现实世界”而不是 std::string 中，数据类型是没有默认构造函数的类。
- 对于那些仍然想知道的人：上面只是一个简化的示例代码:)

更新：
- 在尝试应用这些建议时，我发现与示例中使用的 std::string 相反，我的类有一个私有复制构造函数。这意味着我无法将对象复制到新对象中。

Answer 1

如果您仅通过引用提供，则意味着您不负责内存管理，而这又意味着您不能使用自己的内存管理。也就是说，您不应该使用任何类型的智能指针来保存该对象。

虽然您可以使用 & 运算符获取真实对象的地址，但是当您的 shared_ptr 超出范围并尝试释放该对象时，这样做会导致未定义的行为。内存和库本身尝试自行释放内存。

Answer 2

您根本无法获取引用的地址。

不过，您可以使用 shared_ptr 并使用 &getStringReference 对其进行初始化。但这将导致shared_ptr尝试删除该字符串，从而导致它失败，因为它从未使用new分配。要解决此问题，请制作一个副本：

testString_.reset(new std::string(getStringReference()))

更好的是，让您的类直接存储引用。您根本不需要担心内存管理：

class Foo
{
    std::string& _testString;

    // ...
}

Answer 3

您需要了解引用和内存管理的语义。

您可能想要的是类中的原始指针。我假设您不能使用引用，因为在进行函数调用之前您不知道它将引用哪个对象，因此您想要执行类似 ref=getRef(); 的操作；

您无法自动“保护”您的指针免于“悬空”，但您也不认为可以采取任何措施来纠正这种情况。您只需查看有关如何正确使用引用/指针的文档。

Answer 4

您可以考虑使用 Boost.Optional ，支持可选引用 。这样，您就可以延迟初始化引用，而无需像使用 shared_ptr 那样获取引用对象的所有权：

#include <iostream>
#include <string>
#include <boost/optional.hpp>

//This is library, cannot touch
std::string globalString = "TEST";
std::string& getStringReference()
{
    return globalString;
}

//this is my class which uses the library
class Foo
{
public:
    Foo()
    {
        //do some initialization of the library here...
        //now init the optional reference
        testString_.reset( getStringReference() );
    }

    std::string getString() const
    {
        return *testString_;
    }

private:
    boost::optional< std::string& > testString_; //<-- note the use of optional
};

//and a main to be compilable and check if the above works...
int main()
{
    Foo foo;
    std::cout << foo.getString() << std::endl;
}

Answer 5

立即停止使用 shared_ptr。共享不是单方面的决定。

话虽如此，您返回的是对对象的引用，而不是对象本身。您可以做两件事：

• 复制对象，因此决定自己管理副本的生命周期，
• 获取对该对象的引用，并将其交给您调用的库来管理生命周期，在这种情况下，您将需要对此有一些了解，

我肯定会建议复制，除非有理由不这样做，这样更容易做到正确。

如果您要进行复制，请在类中使用 boost::optional，这样您就可以绕过初始化问题。

如果您想使用参考，您仍然可以使用 boost::Optional，它也能工作！按如下方式使用它：boost::optional，但请确保您引用的对象能够存活足够长的时间。

最后，关于初始化问题，你可以使用一个函数来处理初始化并直接返回一个引用，从而在初始化列表中初始化你的类的引用。

Answer 6

您不能将shared_ptr 与引用类型一起使用，因为引用就是对对象的引用。它不是一个真实的物体。

下一个示例只是您尝试执行的操作的简化版本：

int main()
{
  int &* a;
}

Answer 7

使用工厂函数？

class Library
{ 
 public:
  static void Init();
  static LibraryThing & getThing();
};


class Foo
{
  public:
  static shared_ptr<Foo> Create()
  {
   if (!_libInit)
   {
    Library::Init();
    _libInit = true;
   }
   return make_shared(new Foo(Library::getThing()));
  }

 private:
  Foo(LibraryThing & ref) : _ref(ref)
  {
  }

 private:
  LibraryThing & _ref;
  static bool     _libInit;
};