如何以 const 形式返回指向指针列表的私有指针？

我有一个指向指针列表的指针，作为私有变量。我还有一个 getter，它返回指向列表的指针。我需要保护它免受更改。

我找不到如何使用reinterpret_cast 或const_cast 对此。

class typeA{
    shared_ptr<list<shared_ptr<typeB>>> l;
public:
   shared_ptr<list<shared_ptr<const typeB>>> getList(){return (l);};
};

编译器返回：

   error: could not convert ‘((typeA*)this)->typeA::x’ from ‘std::shared_ptr<std::__cxx11::list<std::shared_ptr<typeB> > >’ to ‘std::shared_ptr<std::__cxx11::list<std::shared_ptr<const typeB> > >’|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

看起来就像const shared_ptr<list<shared_ptr<typeB>>> and shared_ptr<const list<shared_ptr<typeB>>>工作正常。

可以退货吗l作为一个完整的常量，例如：

const shared_ptr<const list<shared_ptr<const typeB>>>

或者至少喜欢：

shared_ptr<list<shared_ptr<const typeB>>> 

?

用引用代替指针不是一个选择。声明l as shared_ptr<list<shared_ptr<const typeB>>>也不是一个想要的解决方案。

编辑：不再有“int”了。

看来这不可能完全符合我的要求，但建议的解决方案很好。是的，复制指针是可以接受的。

我的错是我没有立即放入 typeB。我知道引用相对于指针的一些优点，但我希望有一些类似的解决方案。

您可以创建一个新列表const int来自您的原始列表并返回：

std::shared_ptr<std::list<std::shared_ptr<const int>>> getList(){
    return std::make_shared<std::list<std::shared_ptr<const int>>>(l->begin(), l->end());
}

如果你想阻止人们对返回的列表进行更改，也可以将其设置为常量：

std::shared_ptr<const std::list<std::shared_ptr<const T>>> getList(){
    return std::make_shared<const std::list<std::shared_ptr<const T>>>(l->cbegin(), l->cend());
}

该函数返回的共享指针并不指向原始列表，而是指向新创建的列表。

另一种选择可能是提供迭代器，当取消引用时，该迭代器返回const T& (where T是您实际存储的类型）。这样，您就无需在每次查看时都复制整个列表。例子：

#include <iostream>
#include <list>
#include <memory>

struct example {
    int data;
    example(int x) : data(x) {}
};

template <class T>
class typeA {
    std::shared_ptr<std::list<std::shared_ptr<T>>> l = std::make_shared<std::list<std::shared_ptr<T>>>();
public:
    template< class... Args >
    void add( Args&&... args ) {
        l->emplace_back(std::make_shared<T>(std::forward<Args>(args)...));
    }

    // a very basic iterator that can be extended as needed   
    struct const_iterator {
        using uiterator = typename std::list<std::shared_ptr<T>>::const_iterator;
        uiterator lit;
        const_iterator(uiterator init) : lit(init) {}
        const_iterator& operator++() { ++lit; return *this; }
        const T& operator*() const { return *(*lit).get(); }
        bool operator!=(const const_iterator& rhs) const { return lit != rhs.lit; }
    };

    const_iterator cbegin() const noexcept { return const_iterator(l->cbegin()); }
    const_iterator cend() const noexcept { return const_iterator(l->cend()); }
    auto begin() const noexcept { return cbegin(); }
    auto end() const noexcept { return cend(); }
};

int main() {
    typeA<example> apa;
    apa.add(10);
    apa.add(20);
    apa.add(30);
    for(auto& a : apa) {
        // a.data = 5; // error: assignment of member ‘example::data’ in read-only object
        std::cout << a.data << "\n";
    }
}