Question

我有两个班级，Base和Derived。 Derived继承自Base并且还包括几个函数和变量 - 因此需要有两个单独的类。但是，它们共享一个函数run。

在下面的示例中，我必须将参数传递给run才能执行read - 此参数取决于对象所引用的类。是否可以编写read的通用版本，以便程序自动使用vars_Base或vars_Derived，具体取决于调用run的对象？

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

class Base
{
  protected:
    void read(std::vector<std::string>);

  public:
    void run(std::vector<std::string> vars) { read(vars); }
    std::vector<std::string> vars_Base;
};

void Base::read(std::vector<std::string> int_vars)
{
    for (auto int_vars_it : int_vars)
    {
        std::cout << int_vars_it << "\n";
    }
}

class Derived : public Base
{
  protected:
  public:
    std::vector<std::string> vars_Derived;
    ///Here are other functions only known to Derived, not Base
};

int main()
{
    Base b;
    b.vars_Base.push_back("aB");
    b.vars_Base.push_back("bB");
    b.vars_Base.push_back("cB");
    b.run(b.vars_Base);

    Derived d;
    d.vars_Derived.push_back("aD");
    d.vars_Derived.push_back("bD");
    d.vars_Derived.push_back("cD");
    d.run(d.vars_Derived);

    return 0;
}

Answer 1

这是你想要得到的结果吗？

class Base
{
protected:
    using vars_type = std::vector<std::string>;

private:
    vars_type vars_Base;

protected:
    virtual vars_type& get_vars() {
        return vars_Base;
    }

public:
    void push_back(const std::string& str) {
        get_vars().push_back(str);
    }

    void run()
    {
        for (auto int_vars_it : get_vars()) {
            std::cout << int_vars_it << " ";
        }
    }
};

class Derived : public Base
{
private:
    vars_type vars_Derived;

protected:
    vars_type& get_vars() override {
        return vars_Derived;
    }

public:
    ///Here are other functions only known to Derived, not Base
};

int main(int argc, char* argv[])
{
    Base b;
    b.push_back("aB");
    b.push_back("bB");
    b.push_back("cB");
    b.run();    // prints aB bB cB

    std::cout << std::endl;

    Derived d;
    d.push_back("aD");
    d.push_back("bD");
    d.push_back("cD");
    d.run();    // prints aD bD cD

    return 0;
}

如果是这样，接下来就是解释：没有＆＃34;虚拟变量＆＃34;，但是有虚函数。您可以将虚拟功能用作＆＃34;内部访问器＆＃34;为您的成员变量。虽然Derived类包含vars_Base和vars_Derived，但get_vars()允许您覆盖对适当的vars实例的访问。

希望你能发现它有用。

Answer 2

您可以使用虚拟函数来解决问题，而无需使用泛型。

这是一个使用虚函数的解决方案（应用于您的示例代码）：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

class Base
{
  protected:
    void read(std::vector<std::string>);

  public:
    virtual void run() { read(vars_Base); }
    std::vector<std::string> vars_Base;
};

void Base::read(std::vector<std::string> int_vars)
{
    for (auto int_vars_it : int_vars)
    {
        std::cout << int_vars_it << "\n";
    }
}

class Derived : public Base
{
  protected:
  public:
    void run() override { read(vars_Derived); } 
    std::vector<std::string> vars_Derived;
    ///Here are other functions only known to Derived, not Base
};

int main()
{
    Base b;
    b.vars_Base.push_back("aB");
    b.vars_Base.push_back("bB");
    b.vars_Base.push_back("cB");
    b.run();

    Derived d;
    d.vars_Derived.push_back("aD");
    d.vars_Derived.push_back("bD");
    d.vars_Derived.push_back("cD");
    d.run();

    return 0;
}

此解决方案允许在类中封装vars_Base和vars_Derived。

希望这有帮助。

替代虚拟变量

2 个答案: