C++ 虚拟变量的替代方案

我有两个类，

Base

和

Derived

<代码>派生的继承自

基

，另外还包括几个函数和变量——因此需要有两个单独的类。但是，它们确实共享一个功能，

run

在下面的示例中，为了执行

read

，我必须将一个参数传递给

run

——这个参数取决于对象引用的类。是否可以编写

read

的通用版本，以便程序根据对象调用

run

自动使用

vars\u Base

或

vars\u-Derived

#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;
}

#包括
#包括
#包括
#包括
阶级基础
{
受保护的：
无效读取（标准：：向量）；
公众：
void run（std:：vector vars）{read（vars）；}
std：：向量变量库；
};
void Base:：read（std:：vector int_vars）
{
用于（自动输入变量：输入变量）
{
这就是你想要得到的结果吗

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;
}

类基
{
受保护的：
使用vars_type=std:：vector；
私人：
vars_型vars_底座；
受保护的：
虚拟变量类型&获取变量（）{
返回vars_基地；
}
公众：
void push_back（常量std:：string和str）{
获取变量（）；
}
无效运行（）
{
for（auto-int\u-vars\u-it:get\u-vars（））{
这就是你想要得到的结果吗

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;
}

类基
{
受保护的：
使用vars_type=std:：vector；
私人：
vars_型vars_底座；
受保护的：
虚拟变量类型&获取变量（）{
返回vars_基地；
}
公众：
void push_back（常量std:：string和str）{
获取变量（）；
}
无效运行（）
{
for（auto-int\u-vars\u-it:get\u-vars（））{
std：：cout您可以使用虚拟函数来解决问题，而不必使用泛型

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

#包括
#包括
#包括
#包括
阶级基础
{
受保护的：
无效读取（标准：：向量）；
公众：
虚拟空运行（）{read（vars_Base）；}
std：：向量变量库；
};
void Base:：read（std:：vector int_vars）
{
用于（自动输入变量：输入变量）
{
std：：cout您可以使用虚拟函数来解决问题，而不必使用泛型

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

#包括
#包括
#包括
#包括
阶级基础
{
受保护的：
无效读取（标准：：向量）；
公众：
虚拟空运行（）{read（vars_Base）；}
std：：向量变量库；
};
void Base:：read（std:：vector int_vars）
{
用于（自动输入变量：输入变量）
{
std:：cout为什么要传递成员变量的副本作为参数？为什么成员函数不直接使用成员变量？一个返回（对的引用）的受保护虚拟函数如何要使用的向量？或使
运行
虚拟并在派生类中重写它？为什么要传递成员变量的副本作为参数？为什么成员函数不直接使用成员变量？如何使用返回（对的引用）的受保护虚拟函数要使用的向量？或使
运行
并在派生类中重写它？要改进封装，最好将vars_Base放在基类的私有部分要改进封装，最好将vars_Base放在基类的私有部分