class A
{
friend void foo();
virtual void print_Var() const{};
};// does not contain variable Var;
template<class T>
class B : public A
{
T Var;
public:
B(T x):Var(x){}
void print_Var() const override
{
std::cout<<Var<<std::endl;
}
};
void foo()
{
std::array<std::unique_ptr<A>, 3> Arr = {
std::make_unique<B<int>>(100),
std::make_unique<B<int>>(20),
std::make_unique<B<std::string>>("Hello Stackoverflow")
};
std::shuffle(Arr.begin(), Arr.end(), std::mt19937(std::random_device()())); // 3rd parameter generated by Clang-Tidy
for (auto &i: Arr)
{
i->print_Var(); // OK
// auto z = i->Var // no member named Var in A
// obviously base class does not contain such variable
// if (i->Var==20) {/* do something*/}
// if (i->Var=="Hello Stackoverflow") {/* do something*/}
}
}
说明:
我想遍历指向A的指针数组，该数组充满了从A派生的类的指针，并根据变量Var的类型，执行一些if()语句。
问题是我无法访问Var，导致其不是基类的成员。但是，可以通过例如重载函数返回void来排除这些值。我可以在返回模板类型的类中编写函数吗？喜欢:
class A
{
<class T> GetVar()
}
此外，我觉得我正在以完全不正确的方式处理这个问题。我可以这样混合模板和继承吗？如果没有，应该如何设计？
最佳答案
您有几种选择。我将首先解释我的首选解决方案。
1.使用动态调度
如果您有一个基类类型的数组，为什么还要用Var做东西呢？该变量特定于子类。如果您在某个地方有一个A，那么您甚至不必在乎那个地方的B。
对类型变量的操作应封装在基类的虚函数中。如果要执行条件和填充，则可以将该条件封装到一个返回 bool(boolean) 值的虚函数中。
2a。删除基类并使用变体
有时，您事先知道将要进入该列表的类型数量。使用变体并删除基类是一个适用于您的案例的好解决方案。
假设您只有int，double和std::string:
using poly = std::variant<B<int>, B<double>, B<std::string>>;
std::array<poly, 3> arr;
arr[0] = B<int>{};
arr[1] = B<double>{};
arr[2] = B<std::string>{};
// arr[2] = B<widget>{}; // error, not in the variant type
std::visit(
[](auto& b) {
using T = std::decay_t<decltype(b)>;
if constexpr (std::is_same_v<B<int>, T>) {
b.Var = 2; // yay!
}
},
arr[0]
);
2b。删除基类并使用泛型函数
完全删除基类，并模板化对它们进行操作的函数。您可以将所有函数移至一个接口(interface)或许多
std::function中。代替该功能直接操作。这是我的意思的示例:
template<typename T>
void useA(T const& a) {
a.Var = 34; // Yay, direct access!
}
struct B {
std::function<void()> useA;
};
void createBWithInt() {
A<int> a;
B b;
b.useA = [a]{
useA(a);
};
};
这对于您只有很少的操作的情况很好。但是，如果您执行大量操作或拥有许多类型的
std::function，它可能会迅速导致代码膨胀。3.使用访客
您可以创建一个分派(dispatch)给正确类型的访客。
该解决方案与您所需要的解决方案非常接近，但是非常麻烦，并且在添加案例时很容易中断。
像这样:
struct B_Details {
protected:
struct Visitor {
virtual accept(int) = 0;
virtual void accept(double) = 0;
virtual void accept(std::string) = 0;
virtual void accept(some_type) = 0;
};
template<typename T>
struct VisitorImpl : T, Visitor {
void accept(int value) override {
T::operator()(value);
}
void accept(double) override {
T::operator()(value);
}
void accept(std::string) override {
T::operator()(value);
}
void accept(some_type) override {
T::operator()(value);
}
};
};
template<typename T>
struct B : private B_Details {
template<typename F>
void visit(F f) {
dispatch_visitor(VisitorImpl<F>{f});
}
private:
virtual void dispatch_visitor(Visitor const&) = 0;
};
// later
B* b = ...;
b->visit([](auto const& Var) {
// Var is the right type here
});
然后，当然，您必须为每个子类实现
dispatch_visitor。4.使用
std::any这实际上是返回带有类型擦除的变量。您不能对它进行任何操作而不将其回退:
class A {
std::any GetVar()
};
我个人不喜欢这种解决方案，因为它很容易损坏并且根本不是通用的。在那种情况下，我什至不使用多态。
关于c++ - 混合具有多态性的模板，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/55830885/