Question

我正在编写两个程序，比方说计算器和国际象棋游戏。他们共享了很多代码（界面管理，文件打开/保存），我试图找出避免重复代码的最佳实践。

我的想法是创建一个父类，让我们称之为Generic_Program，它具有所有常用功能，并派生子类。

我遇到的问题是如何调用派生类的函数而不是父函数。保存配置和退出的完整示例：

class Generic_Program {
    void SaveConfig() {
        // Write general parameters to a file
    }
    void Exit() {
        SaveConfig(); //First save configuration
        // Configuration saved, do exit routines, like make window invisible, etc.
    }
}

class Calculator : Generic_Program {
    void SaveConfig() {
        Generic_Program::SaveConfig(); //Write generic parameters
        // Write calculator-specific data, like calculation results, etc.
    }
}

class Chess : Generic_Program {
    void SaveConfig() {
        Generic_Program::SaveConfig(); //Write generic parameters
        // Write chess-specific data, like player scores, etc.
    }
}

现在，我希望能够从两个程序中调用Exit()。期望的行为是他们都保存了他们的通用和特定数据，然后退出。

如果我使用上面的代码，它将调用父类'SaveConfig（），因此将只保存通用程序数据。

我当然可以为子类编写特定的Exit()例程，但重点是只编写一次共享代码。

是否有方法从父类调用子级的SaveConfig()？或者在这种情况下避免重复代码的最佳做法是什么？

Answer 1

通常你会调用子对象的退出例程，而退出例程会调用基本的出口例程。

public class Circle implements Shape {

    private int S;

    public Circle(int n)
    {
        S = n;
    }
    public double getPerimeter (){

        double p = 2*3.14*S;
        return p;
    }

    @Override
    public String toString(){

        return "Circle{radius=" + S + "} has a perimeter: " + getPerimeter();
    }

    @Override
    public boolean equals(Object o)
    {
        if (this == o)
            return true;

        if (o == null)
            return false;

        if (getClass() != o.getClass())
            return false;


        return false;
    }

    @Override
    public int hashCode()
    {

        return 0;
    }

}

如果要调用基础对象的Exit例程并让它调用子对象的Exit。在基础对象中声明一个虚拟的ExitSub例程。

Calculator::exit() {
    GenericProgram::exit(); 
    std::cout << "do Chess configs" << std::endl;
    // if needed can call parent routine again, GenericProgram::finish_configs();   
}

并在调用基础对象但未实例化子对象的情况下声明/定义默认版本。

virtual void GenericProgram::ExitSub();

并声明/定义每个子对象的版本，例如：

Generic_Program::ExitSub() { // do nothing };

在Generic_Program中声明/定义一个调用子对象ExitSub例程的Exit例程。（这是多态性）。

Chess::ExitSub() {
    std::cout << "do chess configs" << std::cout;
}

然后从基础对象

调用退出例程

Generic_Program::Exit() {
    SaveConfig();  // First save configuration
    ExitSub();  // invoke sub object configuration
}

避免使用C ++派生类重复代码

1 个答案: