Posso usare boost :: make_shared con un costruttore privato?

Question

Si consideri il seguente:

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>(); 
    }; 
}; 

Sembra DirectoryIterator dovrebbe essere in grado di chiamare boost::make_shared<DirectoryIteratorImpl>, perché è un amico di DirectoryIteratorImpl. Tuttavia, questo codice non riesce a compilare perché il costruttore di DirectoryIteratorImpl è privato.

Poiché questa classe è un dettaglio di implementazione interna che i client di DirectoryIterator non devono mai toccare, sarebbe bello se potessi mantenere privato il costruttore.

È questo il mio malinteso fondamentale attorno allo make_shared o devo contrassegnare una sorta di elemento di potenziamento come friend in modo che la chiamata possa essere compilata?

Answer 1

Avrete infatti bisogno di fare alcuni pezzi boost amico per questo. Fondamentalmente lo make_shared chiama il costruttore e il fatto che ciò avvenga all'interno di una funzione friend non ha importanza per il compilatore.

La buona notizia è che lo make_shared chiama il costruttore, non un altro pezzo. Quindi, solo facendo make_shared amico avrebbe funzionato ... Tuttavia ciò significa che chiunque potrebbe quindi creare un shared_ptr<DirectoryIteratorImpl> ...

Answer 2

C'è un buon motivo per non utilizzare il buon vecchio shared_ptr costruttore? (Se c'è una, si potrebbe desiderare di dare un'occhiata al make_shared implementazione e farlo)

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

In questo modo la chiamata al costruttore è fatto dalla classe DirectoryIterator che è già amico di DirectoryIteratorImpl senza apertura la porta per tutti gli altri codici.

Answer 3

È possibile suddividere la classe in parte di interfaccia e parte di implementazione. La parte dell'interfaccia è resa pubblica e la parte di implementazione può avere costruttori pubblici. Tuttavia, ciò significa che è necessario utilizzare l'ereditarietà virtuale.