将 STL 容器<T *> 转换为容器<T 常量 *>

Converting STL container<T *> to container<T const *>

本文关键字：gt lt 常量 转换 容器 STL      更新时间：2023-10-16

我正在寻找一种方法来制定一个类具有:

  • 一个使用指针的STL容器的接口，具有最大的'constness'
  • 但是它在内部改变了指向对象
  • 与非const模拟
    • 相比，没有额外的运行时开销

理想情况下，与非const版本相比，该解决方案不会编译出额外的代码，因为const/非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_;
};

如果没有类型转换的解决方案，我想要关于如何制定具有所描述属性的类的其他建议。

暂时假设您可以将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;
}

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

相关文章：