C++ 连接多态对象的容器

Question

假设我有一个虚拟基类和一些派生的具体类：

class Base { ... }
class DerivedA : public Base { ... }
class DerivedB : public Base { ... }
class DerivedC : public Base { ... }

在某个地方我有每个派生类的对象向量：

std::vector<DerivedA> my_a;
std::vector<DerivedB> my_b;
std::vector<DerivedC> my_c;

现在，我经常需要遍历所有三个向量中的所有元素并练习基类接口。我可以编写三个 for 循环，每个循环都完全相同。但显然这远非最佳解决方案。

有没有一种聪明的方法可以将向量连接到一个带有基类指针/引用的公共容器中，这样我只需要迭代一次？或者任何其他想法如何优雅地解决这个问题？

Answer 1

在您当前的情况下，不需要多态性。您可以简单地使用 variadic template + higher-order function 来迭代向量。这是一个使用 fold 表达式的 C++17 解决方案：

template <typename F, typename... Vectors>
void for_all_vectors(F&& f, Vectors&&... vs)
{
    (std::for_each(std::forward<Vectors>(vs).begin(), 
                   std::forward<Vectors>(vs).end(), 
                   f), ...);
}

用法：

int main()
{
    std::vector<A> my_a;
    std::vector<B> my_b;
    std::vector<C> my_c;

    for_all_vectors([](const auto& x){ something(x); }, my_a, my_b, my_c);
}

live example on wandbox

---

在 C++11/14 中，您可以将折叠表达式替换为 for_each_argument:

template <typename TF, typename... Ts>
void for_each_argument(TF&& f, Ts&&... xs)
{
    return (void)std::initializer_list<int>{
        (f(std::forward<Ts>(xs)), 0)...};
}

template <typename F, typename... Vectors>
void for_all_vectors(F&& f, Vectors&&... vs)
{
    for_each_argument([&f](auto&& v)
    { 
        std::for_each(v.begin(), v.end(), f);
    }, std::forward<Vectors>(vs)...);
}

live example on wandbox

我解释了这个 sn-p 背后的想法，并在这个 CppCon 2015 演讲中对其进行了扩展："for_each_argument explained and expanded"。

Answer 2

只要有一个指向基类的指针。你不能有一个 base 类型的向量并将派生类放入其中，因为它们的大小、功能可能不同等。

所以我要做的是创建一个向量或类型 base*，然后您可以连接派生类的指针。

可能看起来像：

vector<base*> v;
v.push_back(&derivedClassVariableA);
v.push_back(&derivedClassVariableB);

那么只要您要使用的函数在基类中是虚拟的并且在派生中定义，那么您应该可以使用

Answer 3

一个简单的解决方案是使用一个模板函数来迭代向量的成员并调用相应的函数：

class Base {
public:
    virtual int getX() = 0;
};

class Derived1 : public Base {
public:
    int x1=1;
    virtual int getX() { return x1; };
};

class Derived2 : public Base {
public:
    int x2=2;
    virtual int getX() { return x2; };
};

template<typename T>
void callPolymorphic(std::vector<T> &v) {
    for (T& a : v) {
        cout << a.getX() << " ";
    }
}

int main() {

    std::vector<Derived1> my_1(5);
    std::vector<Derived2> my_2(5);

    callPolymorphic(my_1);
    callPolymorphic(my_2);

    return 0;
}

Answer 4

我会创建一个函数模板或一个通用 lambda 并调用它 3 次：

auto my_loop = [](auto& vec){
  for (auto& base : vec) {
      // do something with base...
  }
};
my_loop(my_a);
my_loop(my_b);
my_loop(my_c);

Answer 5

另一方面，您可以制造自己的自制视图适配器：

#include <iostream>
#include <vector>
#include <functional>
#include <iterator>

struct Base {
    virtual int f() const = 0;
    virtual ~Base() {}
};

struct D1: Base {
    int f() const { return 42; }
};

struct D2: Base {
    int f() const { return 314; }
};

template<typename T, typename... Left, typename... Right>
inline std::vector<T, Left...> operator+(std::vector<T, Left...> &&left, std::vector<T, Right...> &&right) {
    std::vector<T, Left...> retVal(std::move(left));
    using mi = std::move_iterator<typename std::vector<T, Right...>::iterator>;
    retVal.insert(retVal.end(), mi(right.begin()), mi(right.end()));
    return retVal;
}

int main() {
    std::vector<D1> v1(3);
    std::vector<D2> v2(4);
    using View = std::vector<std::reference_wrapper<const Base>>;
    View b(View(v1.cbegin(), v1.cend()) + View(v2.cbegin(), v2.cend()));
    for(Base const &item: b) std::cout << item.f() << std::endl;
}

（请注意，底层查看的容器可以是任何容器，vectors 可以，但它们的元素类型应该是一致的。）