轉換STL容器<T *>集裝箱<T const *>

Question

我正在尋找一種方式來配製具有類：

• 使用最大「常量性」指針
• 但其中的STL容器的接口內部變異的尖-to對象
• 相比於一個非const模擬

理想的情況下沒有額外的運行時開銷，該解決方案將彙編沒有分機ra代碼與非const版本的比較，因爲const/non-const-ness只是幫助程序員在這裏。

這裏是我試過到目前爲止：

#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_; 
}; 

如果沒有解決類型轉換，我想就如何配製具有描述的屬性的類其他建議。

Answer 1

讓我們假設您暫時可以將list<T*>&轉換爲list<T const *>&。現在考慮下面的代碼：

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

b.push_back("foo"); 

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

這是一個與轉換T**到T const**同樣的概念問題。

如果您想要提供對基礎數據的只讀訪問，則需要提供一些自定義視圖，可能使用自定義迭代器。

像下面這樣。

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

不要返回容器。返回迭代器。