Konwersja kontenera STL <T *> do pojemnika <T const *>

Question

szukam sposób sformułować klasa posiadająca:

• interfejs użyciu kontenerów STL wskaźników z maksymalną „constness”
• ale które wewnętrznie mutuje szpiczaste -to obiektów
• bez dodatkowego okresie czasu w porównaniu do górnego const analogu

w idealnym rozwiązaniem byłoby, aby opracować nie wew kod ra w porównaniu do wersji niestałej, ponieważ const/non-const-ness jest tutaj po prostu pomocą dla programistów.

Oto, co starałem dotąd:

#include <list> 
#include <algorithm> 

using namespace std; 
typedef int T; 

class C 
{ 
public: 
    // Elements pointed to are mutable, list is not, 'this' is not - compiles OK 
    list<T *> const & get_t_list() const { return t_list_; } 

    // Neither elements nor list nor' this' are mutable - doesn't compile 
    list<T const *> const & get_t_list2() const { return t_list_; } 

    // Sanity check: T const * is the problem - doesn't compile 
    list<T const *> & get_t_list3() { return t_list_; } 

    // Elements pointed to are immutable, 'this' and this->t_list_ are 
    // also immutable - Compiles OK, but actually burns some CPU cycles 
    list<T const *> get_t_list4() const { 
     return list<T const *>(t_list_.begin() , t_list_.end()); 
    } 

private: 
    list<T *> t_list_; 
}; 

Jeśli nie ma rozwiązania do konwersji typu, chciałbym alternatywne propozycje dotyczące sposobu formułowania klasy posiadające właściwości opisane.

Answer 1

Załóżmy, że przez chwilę można przekonwertować list<T*>& na list<T const *>&. Teraz rozważmy następujący kod:

list<char*> a; 
list<char const*>& b = a; 

b.push_back("foo"); 

a.front()[0] = 'x'; // oops mutating const data 

To ten sam problem z koncepcyjnego konwersji T** do T const**.

Jeśli chcesz udostępnić dane tylko do odczytu, musisz podać niestandardowy widok, najlepiej używając niestandardowych iteratorów.

Coś jak poniżej.

template <typename It> 
class const_const_iterator { 
private: 
    using underlying_value_type = typename std::iterator_traits<It>::value_type; 

    static_assert(std::is_pointer<underlying_value_type>(), 
        "must be an iterator to a pointer"); 

    using pointerless_value_type = typename std::remove_pointer<underlying_value_type>::type; 

public: 
    const_const_iterator(It it) : it(it) {} 

    using value_type = pointerless_value_type const*; 

    value_type operator*() const { 
     return *it; // *it is a T*, but we return a T const*, 
        // converted implicitly 
        // also note that it is not assignable 
    } 

    // rest of iterator implementation here 
    // boost::iterator_facade may be of help 

private: 
    It it; 
}; 

template <typename Container> 
class const_const_view { 
private: 
    using container_iterator = typename Container::iterator; 

public: 
    using const_iterator = const_const_iterator<container_iterator>; 
    using iterator = const_iterator; 

    const_const_view(Container const& container) : container(&container) {} 

    const_iterator begin() const { return iterator(container->begin()); } 
    const_iterator end() const { return iterator(container->end()); } 

private: 
    Container const* container; 
} 

Answer 2

Nie zwracaj pojemników. Zwróć iteratory.