覆盖映射迭代器以返回 dynamic_casted 值

问题描述

编辑：我现在有一个可行的解决方案，https://wandbox.org/permlink/joS14MzfmmayNRd3，只是想知道它是否可以改进。

我有一个地图 map<int,unique_ptr<Base>>，其值也可以是 unique_ptr<Derived> 类型。我有包装类 A 和 B，它们分别在地图中存储 Base 和 Derived（所有 Base 或所有 Derived 实例）。

我想介绍 A 和 B 的映射语义（引用绑定），其工作方式如下：

// a is of type A,all values in map are of type Base
for (auto& [k,v] : a) {
  // v should be of type Base&
} 

// b is of type B,all values in map are type Derived
for (auto& [k,v] : b) { 
  // v should be of type Derived&
  // can call functions that are in Derived but not in Base
} 

我发现 boost 的 transform_iterator 和 iterator_adaptor 可能很有用（如果有没有 boost 的方法就更好了），但我似乎没有正确使用它们。这样做的正确方法是什么？

#include <memory>
#include <boost/iterator/transform_iterator.hpp>
#include <vector>
#include <unordered_map>
#include <iostream>

using namespace std;

class Base {
    public:
        Base(int k) : i(k) {}
        virtual ~Base() {}
        
        virtual int getV() {
            return i;
        }
        
        int i = 0;
};

class Derived : public Base {
    public:
        Derived(int k) : Base(k) {}
        
        int getV() override {
            return j - i;
        }

        void setV(int p) {
            i = p;
        }
        
        int j = 0;
};

typedef unordered_map<int,unique_ptr<Base>> BaseMap;

class A {
    public:
        A(vector<int> keys) {
            for (auto& k : keys) {
                m.emplace(k,make_unique<Base>(k));
            }
        }
        
        class Converter {
            public:
                explicit Converter() {}

                pair<BaseMap::key_type,reference_wrapper<Base>> operator()(BaseMap::value_type& p) const {
                    return {p.first,*p.second};
                }
        };

        using MyIterator = boost::transform_iterator<Converter,typename BaseMap::iterator>;

        MyIterator begin() {
            return MyIterator(m.begin());
        }
        
        MyIterator end() {
            return MyIterator(m.end());
        }
       
        protected:
            BaseMap m;
};

class B : public A {
    public:
        B(vector<int> keys) : A(keys) {
            m.clear(); // demo only,since we have to init A
            for (auto& k : keys) {
                m.emplace(k,make_unique<Derived>(k));
            }
        }

        class Converter {
            public:
                explicit Converter() {}

                pair<BaseMap::key_type,reference_wrapper<Derived>> operator()(BaseMap::value_type& p) const {
                    return {p.first,dynamic_cast<Derived&>(*p.second)};
                }
        };
        
        using MyIterator = boost::transform_iterator<Converter,typename BaseMap::iterator>;
        
        MyIterator begin() {
            return MyIterator(m.begin());
        }
        
        MyIterator end() {
            return MyIterator(m.end());
        }
};

int main ()
{
    A a({1,2,3,4});
    B b({1,4});
    
    for (auto [k,v] : a) {
        cout << v.get().getV() << " ";
    }
    cout << endl;
    
    for (auto [k,v] : b) {
        cout << v.get().getV() << " ";
        v.get().setV(42);
    }
    
    cout << endl << "after setV:\n";
    
    for (auto [k,v] : b) {
        cout << v.get().getV() << " ";
    }
    
    return 0;
}

解决方法

这里有几个问题：

1. 您正在按价值获取 p，也就是说，您正在制作副本。但 std::unique_ptr 不可复制。
2. BaseMap::value_type 已经是 std::pair<const Key,Value>。
3. std::make_pair() 衰减参数，您需要使用 std::reference_wrapper 将参数包装到 std::ref() 中以传递引用。

class Converter {
public:
    std::pair<BaseMap::key_type,Derived&> operator()(BaseMap::value_type& p) const {
        return std::make_pair(p.first,std::ref(dynamic_cast<Derived&>(*p.second)));
    }
};

之后，基于范围的 for 应如下所示：

for (auto [k,v] : b) {
    std::cout << v.get();
}

请注意，decltype(v) 是 Derived&、not Derived。

（此答案是在编辑问题中的代码之前编写的。）