Question

我们目前像这样存储几个不同的数据模型集合：

std::map<std::string, std::map<int64_t, std::shared_ptr<DataObject>>> models;

该字符串映射到一个已知的类型列表，所有这些都由序列化处理。嵌套映射包含“对象ID”和关联的（反序列化的）std :: shared_ptr

的集合

DataObject是一个基类，我们有几种派生自此的类型。

我们有一种获取给定类型的所有DataObject的方法：

static std::map<int64_t, std::shared_ptr<DataObject>> *getAll(std::string type);

这只是通过给定的“类型”键返回指向地图的指针。

今天，我遇到了一个代码审查，添加了以下内容，我相信这些内容可以调用UB，但似乎可以正常运行。这让我有些紧张，正在寻找有效的解决方案：

template <typename M>
static std::map<int64_t, std::shared_ptr<M>> *getAll(const std::string &type) {
    auto castObjectMap = reinterpret_cast<std::map<int64_t, std::shared_ptr<M>>*>(getAll(type));
    return castObjectMap;
}

这样进行转换的好处是它不涉及循环或复制（据我所知），这是一个简单的指针转换。这太妙了。但是我不认为它是便携式的还是安全的，尽管我不知道最好的便携式和安全的替代品是什么。

我下面是这个问题的玩具版本的简化版本，它实际上确实按预期吐出了正确的输出：

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

using namespace std;

struct Base {
    Base(){}
    virtual ~Base(){}

    Base(int u):x(u){}

    int x = 0;
};

struct Derived : public Base {
    Derived(){}
    Derived(int u, int v):Base(u),y(v){}
    int y = 0;
};

int main() {
    map<int, shared_ptr<Base>> test {
        {0, make_shared<Derived>(2, 3)},
        {1, make_shared<Derived>(4, 5)},
        {2, make_shared<Derived>(6, 7)}
    };

    map<int, shared_ptr<Derived>> *castVersion = reinterpret_cast<map<int, shared_ptr<Derived>>*>(&test);

    for(auto&&kv : *castVersion){
        cout << kv.first << ": " << kv.second->x << ", " << kv.second->y << std::endl;
    }
    return 0;
}

我的问题是，是否有一个很好的方法来进行大量复制，或者至少有一种干净的方法来进行复制。我们目前正在使用C ++ 17。

Answer 1

它不会提供完全相同的界面，但是想到的一个类似但更安全的想法是使用boost::transform_iterator创建迭代器，该迭代器透明地处理转换地图中的shared_ptr指针。

#include <memory>
#include <utility>
#include <type_traits>
#include <boost/iterator/transform_iterator.hpp>

template <class Derived, class Iterator>
class downcast_pair_iterator
    : public boost::transform_iterator<
        std::pair<
            typename std::iterator_traits<Iterator>::value_type::first_type,
            const std::shared_ptr<Derived>
        > (*)(Iterator),
        Iterator>
{
public:
    using base_value_type = typename std::iterator_traits<Iterator>::value_type;
    using key_type = const typename base_value_type::first_type;
    using base_mapped_type = typename base_value_type::second_type;
    using mapped_type = const std::shared_ptr<Derived>;
    using value_type = std::pair<key_type, mapped_type>;

private:
    template <typename T>
    static T* shared_to_raw(const std::shared_ptr<T>&); // undefined
    static_assert(std::is_base_of_v<
        std::remove_pointer_t<
            decltype(shared_to_raw(std::declval<base_mapped_type&>()))>,
        Derived>);

    static value_type convert(const base_value_type& pair_in)
    {
        return value_type(pair_in.first,
            std::static_pointer_cast<Derived>(pair_in.second));
    }
public:
    explicit downcast_pair_iterator(Iterator iter)
        : transform_iterator(iter, &convert) {}
};

template <class Derived, class Iterator>
auto make_downcast_pair_iter(Iterator iter)
{
    return downcast_pair_iterator<Derived, Iterator>(iter);
}

template <class Derived, class Range>
class downcast_pair_range
{
public:
    explicit downcast_pair_range(Range& c)
        : source_ref(c) {}

    auto begin() const {
        using std::begin;
        return make_downcast_pair_iter<Derived>(begin(source_ref));
    }
    auto end() const {
        using std::end;
        return make_downcast_pair_iter<Derived>(end(source_ref));
    }

private:
    Range& source_ref;
};

template <class Derived, class Range>
auto make_downcast_pair_range(Range& r)
{
    return downcast_pair_range<Derived, Range>(r);
}
template <class Derived, class Range>
auto make_downcast_pair_range(const Range &r)
{
    return downcast_pair_range<Derived, const Range>(r);
}

那么您的示例main可能变为：

int main() {
    std::map<int, std::shared_ptr<Base>> test {
        {0, std::make_shared<Derived>(2, 3)},
        {1, std::make_shared<Derived>(4, 5)},
        {2, std::make_shared<Derived>(6, 7)}
    };

    for (auto&& kv : make_downcast_pair_range<Derived>(test)){
        std::cout << kv.first << ": "
                  << kv.second->x << ", " << kv.second->y << std::endl;
    }
    return 0;
}

这避免了创建任何第二个容器对象，并且在正确使用时不涉及未定义的行为。使用转换迭代器将导致与不安全的转换相同的机器代码，除了取消引用确实会创建新的shared_ptr<Derived>对象外，这将涉及少量的引用计数开销。 See the full working program on coliru.

除了如上面基于范围的make_downcast_pair_range<Derived>(some_map)中所示使用for之外，make_downcast_pair_iterator<Derived>还可以直接用于获取转换迭代器用于其他目的，例如，根据a的结果地图的find(k)。有了转换的迭代器，您可以使用iter.base()返回到真实地图的迭代器，例如传递给地图的erase(iter)。

当然，如果指针实际上没有指向Derived对象，则使用std::static_pointer_cast的结果仍然是未定义的行为。如果有人担心有人在获取对象时可能会使用错误的“派生”模板参数，或者地图可能最终以某种方式包含指向错误派生对象类型的指针，则可以将downcast_pair_iterator<D, I>::convert私有函数更改为使用{{ 1}}，如果结果为空指针，则抛出或中止。

Answer 2

您不能直接使用带有一对迭代器的std :: map构造函数，因为该转换正尝试从Base强制转换为Derived，这无法隐式完成，但是您可以安全地运行std :: transform。这确实涉及复制，但是具有 not 是未定义行为的优点。

template <typename M>
static std::map<int64_t, std::shared_ptr<M>> getAll(const std::string &type) {
    auto* source = getAll(type);
    std::map<int64_t, std::shared_ptr<M>> castMap;
    std::transform(source->begin(), source->end(), std::inserter(castMap, castMap.end()), [](auto& kv) {
        return std::pair<const int, std::shared_ptr<M>>(kv.first, std::static_pointer_cast<M>(kv.second));
    });
    return castMap;
}

Answer 3

好吧，您不能像这样随意散布。 std::map<int64_t, std::shared_ptr<M>>和std::map<int64_t, std::shared_ptr<DataObject>>是完全不同的类型。在不触发UB的情况下，无法将指针指向不相关的类。您必须以某种方式进行复制。

如果要从派生类的指针转换为基类的指针，则可以直接执行以下操作：

std::map<int64_t, std::shared_ptr<M>> new_map{old_map.begin(), old_map.end()};

这利用了shared_ptr在需要时进行转换的事实。如果您正相反，则可以依靠隐式转换，因此请使用static_pointer_cast。

将std :: map <int，std :: shared_ptr <Base >>转换为std :: map <int，std :: shared_ptr <Derived >>的最有效的安全方法

3 个答案: