C++11中如何返回只读std::map且不修改原映射或创建副本？

不能直接返回const std::map<std::string, const std::shared_ptr<Object const>>类型的引用或指针，因为原映射的value类型是std::shared_ptr<Object>，与目标类型的valuestd::shared_ptr<const Object>不兼容，无法直接进行类型转换或绑定。

要实现你的需求（映射结构只读、shared_ptr本身不可修改、底层Object不可修改），且不修改原映射定义或创建副本，最安全的方式是实现一个只读视图类，包装原映射的const引用，并对外暴露受限的访问接口：

1. 定义只读视图类 #

这个类会持有原映射的const引用，对外提供迭代器、查找、大小查询等方法，且迭代器返回的value会被转换为std::shared_ptr<const Object>，确保底层Object无法被修改：

#include <map>
#include <memory>
#include <string>

class Object; // 你的Object类前向声明

class ReadOnlyObjectMapView {
private:
    // 持有原映射的const引用，避免复制
    const std::map<std::string, std::shared_ptr<Object>>& m_underlying;

public:
    // 构造函数，接收原映射的const引用
    explicit ReadOnlyObjectMapView(const std::map<std::string, std::shared_ptr<Object>>& map)
        : m_underlying(map) {}

    // 自定义迭代器，包装原映射的const_iterator
    class Iterator {
    private:
        using UnderlyingIter = std::map<std::string, std::shared_ptr<Object>>::const_iterator;
        UnderlyingIter m_iter;

    public:
        explicit Iterator(UnderlyingIter iter) : m_iter(iter) {}

        // 解引用返回键的const引用，以及指向const Object的shared_ptr
        std::pair<const std::string&, std::shared_ptr<const Object>> operator*() const {
            return {m_iter->first, m_iter->second};
        }

        // 箭头运算符，支持->first和->second访问
        struct ArrowProxy {
            const std::string& first;
            std::shared_ptr<const Object> second;
            ArrowProxy(const std::pair<const std::string&, std::shared_ptr<const Object>>& p)
                : first(p.first), second(p.second) {}
            const ArrowProxy* operator->() const { return this; }
        };

        ArrowProxy operator->() const {
            return ArrowProxy(**this);
        }

        // 迭代器自增
        Iterator& operator++() {
            ++m_iter;
            return *this;
        }

        // 迭代器比较
        bool operator!=(const Iterator& other) const {
            return m_iter != other.m_iter;
        }
    };

    // 开始迭代器
    Iterator begin() const { return Iterator(m_underlying.begin()); }
    // 结束迭代器
    Iterator end() const { return Iterator(m_underlying.end()); }

    // 查找指定键
    Iterator find(const std::string& key) const {
        return Iterator(m_underlying.find(key));
    }

    // 获取映射大小
    size_t size() const { return m_underlying.size(); }
};

2. 在你的类中实现返回视图的方法 #

在持有原映射的类中，添加一个const成员函数返回这个视图：

class MyClass {
private:
    std::map<std::string, std::shared_ptr<Object>> m_map;

public:
    // 返回只读视图，确保外部无法修改映射结构、shared_ptr本身及底层Object
    ReadOnlyObjectMapView getReadOnlyMap() const {
        return ReadOnlyObjectMapView(m_map);
    }
};

3. 使用示例 #

外部代码调用getReadOnlyMap()后，只能进行只读操作：

void useMap(const MyClass& obj) {
    auto readOnlyView = obj.getReadOnlyMap();

    // 遍历视图，只能读取键和const Object
    for (const auto& pair : readOnlyView) {
        const std::string& key = pair.first;
        std::shared_ptr<const Object> objPtr = pair.second;
        // objPtr->modify(); // 编译错误，因为Object是const的
    }

    // 查找操作
    auto it = readOnlyView.find("test");
    if (it != readOnlyView.end()) {
        // 同样只能访问const Object
    }

    // readOnlyView.begin()->second = std::make_shared<Object>(); // 编译错误，无法修改shared_ptr
    // readOnlyView.insert({"new", std::make_shared<Object>()}); // 编译错误，视图没有插入方法
}

为什么不直接返回const映射引用？ #

如果直接返回const std::map<std::string, std::shared_ptr<Object>>&，虽然无法修改映射结构（插入/删除键），也无法重新赋值shared_ptr，但仍然可以通过shared_ptr修改底层的Object（因为std::shared_ptr<Object>允许修改指向的对象），这不符合你要求底层Object也只读的需求。

内容的提问来源于stack exchange，提问作者user23555184