如何将指向指针列表的私有指针作为const返回？

Question

我有一个指向指针列表的指针，作为私有变量。我还有一个 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>>> 和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 声明为shared_ptr<list<shared_ptr<const typeB>>> 也不是想要的解决方案。

编辑：不再有“int”。

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

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

Answer 1

您可以从原始列表中创建 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());
}

如果您想阻止人们对返回的列表进行更改，请将其设为 const：

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&（其中 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";
    }
}

Answer 2

当你将一个指向非常量的指针转换为一个指向常数的指针时，你有两个指针。此外，指向非常数的指针列表与指向常量的指针列表是完全不同的类型。

因此，如果你想返回一个指向常量指针列表的指针，你必须拥有一个常量指针列表。但你没有这样的清单。您有一个指向非常量的指针列表，并且这些列表类型不可相互转换。

当然，您可以将指向非常数的指针转换为指向常数的指针列表，但您必须了解它是一个单独的列表。指向前一种类型的指针不能指向后者。

所以，这里是一个转换列表的例子（我没有测试，可能包含错别字或错误）：

list<shared_ptr<const int>> const_copy_of_list;
std::transform(l->begin(), l->end(), std::back_inserter(const_copy_of_list),
               [](auto& ptr) {
    return static_pointer_cast<const int>(ptr);
});
// or more simply as shown by Ted:
list<shared_ptr<const int>> const_copy_of_list(l->begin(), l->end());

由于我们创建了一个全新的列表，l 无法指向该列表，因此返回指针毫无意义。让我们返回列表本身。如果需要，调用者可以将列表包装在共享所有权中，但在违背他们的需要时不必这样做：

 list<shared_ptr<const int>> getConstCopyList() {
      // ... the transorm above
      return const_copy_of_list;
 }

请注意，虽然列表是分开的，但里面的指针仍然指向相同的整数。

---

作为旁注，请考虑int 对象的共享所有权是否对您的程序有意义 - 我假设这是对示例的简化。

还要重新考虑“引用而不是指针不是一个选项”是否是一个明智的要求。

Answer 3

你的问题出在

但我不想混合引用和指针。只有指针更容易更简洁。

您在这里发现的是该语句错误。 list<TypeB> 可以绑定 const list<TypeB> & 引用，并且列表的任何成员都不允许对 TypeB 对象进行任何修改。

class typeA {
    std::vector<typeB> l;
public:
    const std::vector<typeB> & getList() const { return l; };
};

如果你真的必须有const typeB，你可以改为返回一个l的投影，它添加了const，但这不会是一个Container，而是一个Range（使用ranges库投票进入C++20，另见its standalone implementation）

std::shared_ptr<const typeB> add_const(std::shared_ptr<typeB> ptr)
{
    return { ptr, ptr.get() };
}

class typeA {
    std::vector<std::shared_ptr<typeB>> l;
public:
    auto getList() const { return l | std::ranges::transform(add_const); };
};

另一种选择是您可以将std::shared_ptrs 包装在std::experimental::propagate_const 之类的东西中，然后直接返回它们。

Answer 4

这里有一个非常复杂的结构：

shared_ptr<list<shared_ptr<typeB>>> l;

这是三个间接级别，其中两个具有引用计数生命周期管理，第三个是容器（并且不是内存连续的）。

自然，鉴于这种复杂的结构，将其转换为另一种类型并不容易：

shared_ptr<list<shared_ptr<const typeB>>>

请注意，std::list<A> 和 std::list<const A> 在标准库的设计中是两种不同的类型。当您想将非修改句柄传递给您的容器时，您通常应该使用const_iterators。
在您的情况下，shared_ptr 在list 之上，因此如果您想要引用计数行为，则不能使用迭代器。

这时问题来了：你真的想要这种行为吗？

• 您是否预计您的 typeA 实例已被销毁，但您仍有一些其他 typeA 实例使用相同的容器？
• 您是否期望共享该容器的所有 typeA 实例都被销毁，但您在运行时的其他位置仍有对该容器的一些引用？
• 您是否预计容器本身已被破坏，但您仍然对某些元素有一些引用？
• 您是否有任何理由使用std::list 而不是更传统的容器来存储共享指针？

如果您对所有要点的回答都是“是”，那么为了实现您的目标，您可能必须设计一个新类，该类将充当您的 shared_ptr<list<shared_ptr<typeB>>> 的持有者，同时仅提供 const 对元素的访问权限.

但是，如果您在其中一个要点上的答案是否定的，请考虑重新设计 l 类型。我建议从std::vector<typeB> 开始，然后只逐一添加必要的修改。

Answer 5

模板的问题在于任何

template <typename T>
class C { };

任何两对C<TypeA> 和C<TypeB> 都是完全不相关的类——即使TypeA 和TypeB 仅在const-ness 上不同时也是如此。

所以你真正想要的东西在技术上是不可能的。我暂时不会提出新的解决方法，因为已经有 ，但请尝试进一步了解：如 cmets 中所述，您可能面对 XY问题。

问题是：用户会对这样的列表做什么？她/他可能正在迭代它——或者访问单个元素。那么为什么不让你的整个班级看起来/表现得像一个列表呢？

class typeA
{
    // wondering pretty much why you need a shared pointer here at all!
    // (instead of directly aggregating the list)
    shared_ptr<list<shared_ptr<typeB>>> l;
public:
    shared_ptr<list<shared_ptr<typeB>>>::const_iterator begin() { return l->begin(); }
    shared_ptr<list<shared_ptr<typeB>>>::const_iterator end() { return l->end(); }
};

如果你使用向量而不是列表，我会提供一个索引运算符：

shared_ptr<typeB /* const or not? */> operator[](size_t index);

目前还有一个问题尚未解决：返回的两个const_iterators 有一个不可变的共享指针，但指针仍然是可变的！

这有点麻烦 - 您现在需要实现自己的迭代器类：

class TypeA
{
public:
    class iterator
    {
        std::list<std::shared_ptr<int>>::iterator i;         
        public:
        // implementation as needed: operators, type traits, etc.
    };
};

查看std::iterator 以获得完整示例 - 但请注意，std::iterator 已被弃用，因此您需要自己实现类型特征。

如果您在内部使用 std::vector，则要使用的迭代器标记将是 std::bidirectional_iterator_tag 或 random_access_iterator_tag（contiguous_iterator_tag 与 C++20）。

现在重要的是如何实现两个必需的运算符：

std::shared_ptr<int const> TypeA::iterator::operator*()
{
    return std::shared_ptr<int const>(*i);
}

std::shared_ptr<int const> TypeA::iterator::operator->()
{
    return *this;
}

其他运算符只会将操作转发给内部迭代器（递增、递减（如果可用）、比较等）。

我并不是说这是圣杯，是你在任何情况下都需要遵循的道路。但这是一个有价值的选择，至少值得考虑......