C++ 对派生类型 vector 的引用

Question

我有许多对象实现了一个名为 ExposesCommands 的接口(interface).

class ExposesCommands
{
    virtual bool get_command_results(std::string command, std::vector<std::string> &results) = 0;
};
typedef std::unique_ptr<ExposesCommands> ExposesCommands_ptr;

命令通过模板类公开:

template <typename T>
class ExposedCommands : public ExposesCommands
{
private:
    static std::map<const char*, std::string T::*, cmp_str> exposed_cmds;

public:
    virtual bool get_command_results(std::string command, std::vector<std::string> &results);
}

现在，我正在尝试添加子命令。子命令将链接到实现命令的子对象。我想添加它们的方式是这样的:

template <typename T>
class ExposedCommands : public ExposesCommands
{
private:
    static std::map<const char*, std::string T::*, cmp_str> exposed_cmds;
    static std::map<const char*, std::vector<ExposesCommands_ptr> T::*, cmp_str> exposed_sub_cmds;

public:
    virtual bool get_command_results(std::string command, std::vector<std::string> &results) {
        auto &it = exposed_cmds.find(command.c_str());
        if (it != exposed_cmds.cend()) {
            auto x = std::bind(it->second, std::placeholders::_1);
            std::string data = x(*((T*)this));
            if (data != "") {
                results.push_back(data);
            }
            return true;
        }
        // else check if in exposed_sub_cmds.
            // if so, iterate through vector, call get_command_results
            // on remainder of command name for each sub object, adding
            // its result to the vector of results.
            // return true
        //
        return false;
    }
}

我有这样的对象来实现接口(interface)(此处未显示 map 的构建):

class ObjectA : public ExposesCommands<ObjectA>
{
public:
    std::string cmd_x;  // command X
    std::string cmd_y;  // command Y
}
typedef std::unique_ptr<ObjectA> ObjectA_ptr;

class ObjectB
{
public:
    std::string cmd_z;  // command Z
    std::vector<ObjectA_ptr> my_as;  // 'ObjectA' sub commands
}

不幸的是，这不起作用，因为我无法分配 &std::vector<ObjectA_ptr>到 std::vector<ExposesCommands_ptr> T::* .

有什么办法可以解决这个问题吗？或者有更好的方法来解决这个问题？

Answer 1

总结一下你的问题:你有一个基类和一些派生类

class Base {
public:
    virtual ~Base();
};
class Derived1 : public Base;
class Derived2 : public Base;

您需要将一组指针(为了所有权管理，您选择使用 std::unique_ptr ，这似乎是明智的)存储到 Derived1 对象，这样它可以被不知道 Derived1 存在的代码使用，并且只想使用 Base 的属性，但也不想丢失 Base 对象的这个特定集合实际上仅包含 Derived1 对象的属性。这是一种类型删除，因为集合的运行时行为不应该取决于它存储的是 Base 、 Derived1 还是 Derived2 对象(或者甚至是它们的混合，以便属性被删除)，但是在编译时，您不想编写所有那些丑陋的向下转换(并且您希望编译器验证您只从您静态知道它只包含 Derived1 个对象的容器中向下转换对象)。请注意，如果您要在 Derived1 中存储指向 std::unique_ptr<Base> 的指针，则 Base 具有虚拟析构函数是绝对必要的。

我不知道这个副手有任何现成的解决方案(它也找不到标记为 Container 的 Boost 库的内容)，但我可以向您展示如何自己实现该目标。您需要一个模板，以获得不同的编译时类型(就像 std::vector 是一个模板)，它在内部以固定类型存储数据。所以像这样:

typedef std::unique_ptr<Base> Base_ptr;
template <typename T>
class BaseVector {
public:
    const std::vector<Base_ptr> &
        as_baseclass_vector() const
    {
        return backing_;
    }
private:
    std::vector<Base_ptr> backing_;
};

请注意，as_baseclass_vector 确实会返回对原始 vector 的 const 引用，因为不得使用结果将错误类型的对象(例如，指向 Derived2 对象的指针)插入为 CommandVector 实例化的 Derived1 .这只是完成的一半，另一半令人遗憾地是在此 vector 包装器上重新实现标准库容器概念，如下所示:

template<typename T>
void CommandVector::push_back(std::unique_ptr<T> obj)
{
    backing_.push_back(std::move(obj));
}

或者，更重要和有趣的是:

template<typename T>
const T* BaseVector::operator[](size_t index) const
{
    return static_cast<T*>(backing_[index]);
}

请注意，此 operator[] 不会返回对 unique_ptr 的引用，因为它只能返回对 unique_ptr<Base> 的引用，因为这是存储在支持 vector 中的内容。如果它创建了一个临时的 unique_ptr 到 T ，它就必须从 vector 中删除所有权——你绝对不希望这样!结果已声明为 const，因为它返回一个拷贝而不是通常的引用，并且修改返回值(现在被禁止)不会修改 vector 中的对象，这与用户期望的相反.如果您选择走这条路，您将不得不自己重新实现所有其他方法(迭代器会变得非常有趣，但可能基于 boost::transform_iterator )。