0

我遇到了一种情况，我需要使用虚拟 get 和 set 函数来访问派生类的成员。但是，正如该主题的答案中所指出的（顺便说一句，这与我的问题非常相似），这是一种不好的做法，可能意味着我的课程需要重新设计。问题是......我一般是 C++ 和 OOP 的新手，所以我不确定如何以不同的方式编写我的代码。

如果你有耐心，我会解释一下我的情况：我正在编写一个可以解决两种不同类型问题（比如 ProblemX 和 ProblemY）的代码。根据用户输入，您可以仅解决问题X、仅解决问题Y，或同时解决两者。如果只想解决 ProblemX，则只需要一个名为“memberX”的变量。如果你只想解决问题Y，你只需要“memberY”。如果你想同时解决这两个问题，你将需要“memberX”和“memberY”，但是问题会相互依赖，所以你不能单独解决每个问题。简而言之，代码将是这样的：

#include <vector>

class Problem
{
public:
    double memberX;
    double memberY;
};

class MainProblem
{
public:
    std::vector<Problem*> problems;
};

int main()
{
    bool solveProblemX = true; // This variable will depend on user input
    bool solveProblemY = true; // This variable will depend on user input
    
    MainProblem * mainProblem = new MainProblem();
    for (int i = 0; i < 10000; i++)
    {
        Problem * problem = new Problem();
        mainProblem->problems.push_back(*problem);
    }
    
    if (solveProblemX && solveProblemY)
    {
        // Solve interconnected problem, using "mainProblem->problem[i]->memberX" and "mainProblem->problem[i]->memberY";
    }
    else if (solveProblemX)
    {
        // Solve individual problem, using only "mainProblem->problem[i]->memberX";
    }   
    else if (solveProblemY)
    {
        // Solve individual problem, using only "mainProblem->problem[i]->memberY";
    }
    else
    {
        // throw some exception
    }
}

到目前为止一切都很好......真正的问题是：虽然我只给出了一小部分代码示例，但我的真实程序实际上非常耗费内存（我实际上有一大组Problems，每个都包含一大组成员）。所以，为了减少内存使用，我不得不做一些修改。例如：如果用户选择只解决问题X，变量memberY将只是一个自重，因为程序不需要它。反之亦然。

因此，我想为ProblemX和ProblemY单独制作派生类，每个类都包含各自的数据成员。这样，我可以只为问题向量分配一个包含我需要的数据的次要类。如果两者都需要，我会使用另一个名为 的派生类ProblemXandY，它同时包含memberX和memberY。这是我想的代码：

#include <vector>

class Problem
{
public:
    virtual double getMemberX(){ // Throw some exception};
    virtual double getMemberY(){ // Throw some exception};
};

class ProblemX : public Problem
{
private:
    double memberX;
public:
    double getMemberX(){ return memberX; };
};

class ProblemY : public Problem
{
private:
    double memberY;
public:
    double getMemberY(){ return memberY; };
};

class ProblemXandY : public ProblemX, public ProblemY
{};

class MainProblem
{
public:
    std::vector<Problem*> problems;
};

int main()
{
    bool solveProblemX = true; // This variable will depend on user input
    bool solveProblemY = true; // This variable will depend on user input
    
    MainProblem * mainProblem = new MainProblem();
    for (int i = 0; i < 10000; i++)
    {
        Problem * problem;
        
        if (solveProblemX && solveProblemY)
            problem = new ProblemXandY();
        else if (solveProblemX)
            problem = new ProblemX();
        else if (solveProblemY)
            problem = new ProblemY();
        else
            // throw some exception
        
        mainProblem->problems.push_back(*problem);
    }
    
    if (solveProblemX && solveProblemY)
    {
        for (int i = 0; i < 10000; i++)
        {
            double memberX = mainProblem->problems[i]->getMemberX();
            double memberY = mainProblem->problems[i]->getMemberY();
            // Solve interconnected problem, using "memberX" and "memberY"
        }
    }
    else if (solveProblemX)
    {
        for (int i = 0; i < 10000; i++)
        {
            double memberX = mainProblem->problems[i]->getMemberX();
            // Solve individual problem, using only "memberX";
        }
    }   
    else if (solveProblemY)
    {
        for (int i = 0; i < 10000; i++)
        {
            double memberY = mainProblem->problems[i]->getMemberY();
            // Solve individual problem, using only "memberY";
        }
    }
    else
    {
        // throw some exception
    }
}

我的问题是关于类上的虚拟获取功能Problem。我同意，这感觉很奇怪，因为变量memberXandmemberY不属于 class Problem。但是，如果没有它，我将无法调用mainProblem->problems[i]->getMemberX()，因为mainProblem->problems[i]它是基类的对象Problem，而不是派生类。正如我所说，我的程序内存很昂贵。Problem这就是为什么我选择在 class中有一个 s 向量MainProblem，而不是多个向量，每个派生类一个向量。我这里的结构有问题吗？我真的应该重新设计吗？如果是这样，你能想出一个替代方案吗？

4

0 回答 0