Как использовать ссылки, избегать раздувания заголовков и инициализации задержки?

Question

Я просматривал альтернативу использованию так много shared_ptrs, и нашел отличный ответ в разделе комментариев:

ли вам действительно нужно совместное владение? Если вы остановитесь и задумаетесь за несколько минут, я уверен, что вы можете определить одного из владельца объекта и количество его , которые будут использовать только при жизни владельца. Таким образом, просто сделайте его локальным/членом объекта владельцев и передайте ссылки на тем, кому это необходимо.

Я хотел бы сделать это, но проблема в том, что определение объекта-владельца теперь требует, чтобы объект, который был полностью определен, был полностью определен. Так, например, сказать, что я следующий в FooManager.h:

class Foo; 
class FooManager 
{ 
    shared_ptr<Foo> foo; 
    shared_ptr<Foo> getFoo() { return foo; } 
}; 

Теперь, принимая советы выше, FooManager.h становится:

#include "Foo.h" 
class FooManager 
{ 
    Foo foo; 
    Foo& getFoo() { return foo; } 
}; 

У меня есть две проблемы с этим. Во-первых, FooManager.h больше не легкий. Каждый файл cpp, который включает его, теперь также должен компилировать Foo.h. Во-вторых, мне больше не нужно выбирать, когда инициализируется foo. Это должно быть инициализировано одновременно с FooManager. Как мне обойти эти проблемы?

Answer 1

Вы можете использовать shared_ptr (или любой умный указатель, или даже немой указатель), но не иметь совместного использования.

E.g.

class Foo; 
class FooManager 
{ 
    private: 
    shared_ptr<Foo> foo; 
    public: 
    Foo& getFoo() { return *foo; } 
}; 

(Это только эскиз - вы по-прежнему нужен setFoo(), и, возможно, getFoo() должен возвращать Foo * Но дело в том, что вы вернулись, чтобы быть легким, и вы можете контролировать. когда создается foo.)

Answer 2

Если вам не нужна семантика совместного использования shared_ptr, рассмотрите возможность использования другого контейнера интеллектуальных указателей.

На примере, который вы даете (один объект имеет право собственности и не имеет права собственности), boost::scoped_ptr был бы хорошим выбором.

Если вы не хотите использовать Boost, scoped_ptr очень прост в реализации - это хорошо описано в документации Boost, и ее реализация (в boost/shared_ptr.hpp) проста.

Answer 3

Используйте идиому pimpl и прекратите встраивать так много.

FooManager.h:

class Foo; 

class FooManager 
{ 
    struct Impl; 
    Impl *m_impl; 
public: 
    Foo& getFoo(); 

    FooManager(); 
    ~FooManager(); 
}; 

FooManager.cpp

#include "Foo.h" 
#include "FooManager.h" 

struct FooManager::Impl 
{ 
    Foo* m_foo; 
    int m_someothermember; 
    FooManager::Impl() : m_foo(NULL), m_someothermember(0) {} 
}; 

FooManager::FooManager() : m_impl(new FooManager::Impl()) 
{} 

Foo& FooManager::getFoo() 
{ 
    // Lazy initialization 
    if(!m_impl->m_foo) { 
     m_impl->m_foo = new Foo; 
    } 
    return *m_impl->m_foo; 
} 

FooManager::~FooManager() 
{ 
    delete m_impl->m_foo; 
    delete m_impl; 
} 

Поскольку вы уже используете импульс, я бы порекомендовал вам использовать scoped_ptr реализовать это в реальном коде вместо того, чтобы вручную управлять как я это сделал в этом примере. Важная вещь, которую следует иметь в виду, - это декларирование вперед, так же как и для ссылок, как и для указателей (что является частью причины, по которой она работала для shared_ptr).