Qt GUI and Business Logic modules

Question

I want to separate this project Qt Calculator Example into the GUI module and the Business Logic module. What is the best way to do so and is it better to write the logic module in only C++, so that I can use it in other IDE's as well?

Answer 1

The best practice or design pattern in your case is GRASP Controller pattern.

In your case - it means you shall separate class Calculator from Qt stuff (like QWidget) completely.

So - if you need to present something from Calculator to Qt widgets - create and use interface like CalculatorPresentationInterface.

To get some callbacks, GUI events to calculator - make callbacks slots, or interface CalculatorConrollerInterface.

So - your calculator will implement CalculatorConrollerInterface to be able to receive events from GUI.

Use dependency injection pattern to inject your Calculator via CalculatorConrollerInterface to your GUI.

Your GUI shall implement (or you can use adapter pattern) CalculatorPresentationInterface and you shall inject your GUI via CalculatorPresentationInterface to your real Calculator class.

In this way both layers Business logic layer (Calculator) and presentation logic (Qt GUI) will be separated from each other and you can easily exchange both layers.

---

An example (each class in separate file).

Interfaces:

 class CalculatorConrollerInterface
 {
 public:
     virtual void onAdd() = 0;
     virtual void onCurrentNumberChange(int number) = 0;
 };
 class CalculatorPresentationInterface
 {
 public:
     virtual void showResult(int result) = 0;
 };

The calculator - shall not have any connection to Qt:

 class Calculator  : public CalculatorConrollerInterface
 {
 public:
      Calculator(CalculatorPresentationInterface& presentation)
        : presentation(presentation)
      {}
     virtual void onAdd() override
     { 
        // no idea this is correct - just example
        previousNumber = previousNumber + currentNumber;
        currentNumber = 0;
        presentation.showResult(previousNumber );
     }

     void onCurrentNumberChange(int number) override
     {
          currentNumber  = number;
     }
private:
      CalculatorPresentationInterface& presentation;
      // all stuff necessary to calculate
      int previousNumber;
      int currentNumber;
 };

Qt presentation for calculator:

 class QtCalculatorPresentation : public CalculatorPresentationInterface
 {
 public:
     void setController(CalculatorConrollerInterface& controller)
     {
        this->controller = &controller;
     }
     void showResult(int result) override;

 private:
    CalculatorConrollerInterface* controller;
    // plus all Qt widgets necessary
    // and they shall forward any event to controller
 };

And your main:

 #include "Calculator.hpp"
 #include "QtCalculatorPresentation .hpp"

 int main()
 {
      // dependency injections
      QtCalculatorPresentation  qtPresentation;
      Calculator calculator(qtPresentation);
      qtPresentation.setController(calculator);

      qtPresentation.exec();
 }