¿Puedo usar boost :: make_shared con un constructor privado?

Question

considerar lo siguiente:

class DirectoryIterator; 

namespace detail { 
    class FileDataProxy; 

    class DirectoryIteratorImpl 
    { 
     friend class DirectoryIterator; 
     friend class FileDataProxy; 

     WIN32_FIND_DATAW currentData; 
     HANDLE hFind; 
     std::wstring root; 

     DirectoryIteratorImpl(); 
     explicit DirectoryIteratorImpl(const std::wstring& pathSpec); 
     void increment(); 
     bool equal(const DirectoryIteratorImpl& other) const; 
    public: 
     ~DirectoryIteratorImpl() {}; 
    }; 

    class FileDataProxy //Serves as a proxy to the WIN32_FIND_DATA struture inside the iterator. 
    { 
     friend class DirectoryIterator; 
     boost::shared_ptr<DirectoryIteratorImpl> iteratorSource; 
     FileDataProxy(boost::shared_ptr<DirectoryIteratorImpl> parent) : iteratorSource(parent) {}; 
    public: 
     std::wstring GetFolderPath() const { 
      return iteratorSource->root; 
     } 
    }; 
} 

class DirectoryIterator : public boost::iterator_facade<DirectoryIterator, detail::FileDataProxy, std::input_iterator_tag> 
{ 
    friend class boost::iterator_core_access; 
    boost::shared_ptr<detail::DirectoryIteratorImpl> impl; 
    void increment() { 
     impl->increment(); 
    }; 
    bool equal(const DirectoryIterator& other) const { 
     return impl->equal(*other.impl); 
    }; 
    detail::FileDataProxy dereference() const { 
     return detail::FileDataProxy(impl); 
    }; 
public: 
    DirectoryIterator() { 
     impl = boost::make_shared<detail::DirectoryIteratorImpl>(); 
    }; 
}; 

Parece que DirectoryIterator debe ser capaz de llamar a boost::make_shared<DirectoryIteratorImpl>, porque es un amigo de DirectoryIteratorImpl. Sin embargo, este código no se puede compilar porque el constructor de DirectoryIteratorImpl es privado.

Dado que esta clase es un detalle de implementación interna que los clientes de DirectoryIterator nunca deberían tocar, sería bueno si pudiera mantener el constructor privado.

¿Este es mi malentendido fundamental alrededor de make_shared o necesito marcar algún tipo de pieza de refuerzo como friend para que la llamada compile?

Answer 1

Necesitarás hacer algunas piezas de impulso amigo para esto. Básicamente, make_shared está llamando al constructor y el hecho de que esto se hace desde una función de amigo no tiene importancia para el compilador.

La buena noticia es que make_shared llama al constructor, no a ninguna otra pieza. Por lo que sólo haciendo make_shared amigo funcionaría ... Sin embargo esto significa que cualquier persona podría entonces crear un shared_ptr<DirectoryIteratorImpl> ...

Answer 2

¿Hay una buena razón para no usar el viejo shared_ptr constructor? (Si hay una, es posible que desee echar un vistazo a la implementación make_shared y lo hace)

DirectoryIterator() 
    : impl(new detail::DirectoryIteratorImpl()) 
{} 

De esta manera la llamada al constructor se hace de la clase DirectoryIterator que ya es un amigo de DirectoryIteratorImpl sin abrir la puerta para el resto del código.

Answer 3

Puede dividir su clase en parte de la interfaz y parte de implementación. La parte de interfaz se hace pública, y la parte de implementación puede tener constructores públicos. Sin embargo, eso significa que debe usar herencia virtual.