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 *")
    };
            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 *") {/* do something*/}

    }
}

说明：
我想迭代指向A的指针数组,它指向从A派生的类的指针,并根据变量Var的类型,执行一些if()语句.
问题是我无法访问Var,导致它不是基类的成员.但是,可以通过例如重载函数返回void来输出这些值.我可以在返回模板类型的类中编写函数吗？喜欢：

class A
{
    <class T> GetVar()
}

此外,我觉得我以完全不正当的方式处理这个问题.我可以混合模板和继承吗？如果没有,应该如何设计？

解决方法:

你有几个选择.我先解释一下我的首选解决方案.

1.使用动态调度

如果你有一个基类类型的数组,为什么你甚至想用Var做一些东西？该变量特定于子类.如果你在某个地方有A,你甚至不应该关心B在那个地方有什么或没有.

对类型变量的操作应该封装在基类的虚函数中.如果你想做条件和东西,也许你可以将该条件封装到一个返回布尔值的虚函数中.

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.删除基类并使用泛型函数

完全删除基类,并模拟对其执行操作的函数.您可以将所有函数移动到接口或许多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.使用访客

您可以创建一个分派到正确类型的访问者.

这个解决方案与您的解决方案非常接近,但是非常简洁,并且在添加案例时可以轻松破解.

像这样的东西：

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 : Visitor, T {
        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()
};

我个人不喜欢这个解决方案,因为它很容易破坏,根本不是通用的.在这种情况下我甚至不会使用多态.