C++ Command Pattern Interactive Calculator

An interactive tool to understand the Command behavioral design pattern, including Undo/Redo functionality.

Command Pattern Simulator

Primary Result

0

---

Intermediate Values & Command Log

Initial Value: 0

Command History:

What is a Calculator Using Command Pattern C++?

A calculator using command pattern c++ is not a physical device, but a software application designed to illustrate a powerful behavioral design pattern. The Command Pattern turns a request into a stand-alone object that contains all information about the request. For a calculator, this means encapsulating each operation (like ‘add 5’ or ‘multiply by 2’) into its own object. This decouples the part of your code that issues commands (e.g., a button press) from the part that knows how to perform the action (the calculation logic). This approach is fundamental to implementing features like undo/redo, command logging, and creating complex sequences of operations.

Command Pattern C++ Formula and Explanation

The “formula” for the Command Pattern involves five key participants. These components work together to abstract an action and its parameters. The core idea is to separate the Invoker (what triggers the command) from the Receiver (what does the work).

// 1. Command Interface
class Command {
public:
    virtual ~Command() {}
    virtual void execute() = 0;
    virtual void undo() = 0;
};

// 2. Receiver
class Calculator {
public:
    void performAction(char op, double value); // Does the math
    double getCurrentValue() const;
private:
    double currentValue = 0;
};

// 3. Concrete Command
class CalculatorCommand : public Command {
public:
    CalculatorCommand(Calculator* calc, char op, double operand);
    void execute() override;
    void undo() override;
private:
    //... state for undo ...
};

// 4. Invoker
class CommandHistory {
public:
    void executeCommand(Command* cmd);
    void undo();
};

// 5. Client
// Sets up the Receiver, Invoker, and creates Commands.
int main() {
    Calculator* calculator = new Calculator();
    CommandHistory* history = new CommandHistory();
    // ...
}

Command Pattern Participants

Variable (Participant)	Meaning	Unit (Concept)	Typical Range
Command	An interface with `execute()` and `undo()` methods.	Abstract Action	N/A (Interface)
ConcreteCommand	Implements the Command interface, linking a Receiver and an action.	Specific Action	Add, Subtract, Multiply, etc.
Receiver	The object that performs the actual work when `execute()` is called.	Business Logic	Our `Calculator` class.
Invoker	Holds a command and requests its execution. It doesn’t know what the command does.	Trigger / History	A button, a menu item, or our `CommandHistory` class.
Client	Creates the ConcreteCommand and sets its Receiver. Orchestrates the setup.	Application Core	The `main()` function or startup class.

Practical Examples

Example 1: Basic Operation Sequence

Imagine you start with a value of 100 and want to perform two operations.

• Input 1: Select ‘Add’, Operand ’50’. Execute.
• Input 2: Select ‘Multiply’, Operand ‘2’. Execute.
• Result: The final value is (100 + 50) * 2 = 300. The command history stores an `AddCommand` and a `MultiplyCommand`.

Example 2: Using Undo Functionality

Starting from the result of Example 1 (value = 300), we decide the multiplication was a mistake.

• Input: Click the ‘Undo’ button.
• Result: The calculator reverts the `MultiplyCommand`. The value returns to 150. Clicking ‘Undo’ again would revert the `AddCommand`, returning the value to the initial 100. You can find more about this in our article on undo/redo implementation c++.

How to Use This Calculator Using Command Pattern C++

This interactive tool helps visualize how the Command Pattern works in real-time.

1. Set the Operand: Enter a numeric value in the “Operand” field. This is the number that will be used in the next operation.
2. Choose an Operation: Use the dropdown to select Add, Subtract, Multiply, or Divide.
3. Execute Command: Click this button. The JavaScript behind the scenes will create a “ConcreteCommand” object, execute it, and add it to a history list. You will see the Primary Result update.
4. Review the Log: The “Command Log” shows a textual representation of the command that was just executed.
5. Undo/Redo: Use the “Undo” button to reverse the last operation. The command isn’t destroyed; it’s moved to a “redo stack.” Clicking “Redo” will move it back and re-execute it.
6. Watch the Chart: The chart visualizes the change in the primary result over time, giving a clear picture of your command history.

Key Factors That Affect Command Pattern Implementation

• State Management: For `undo()` to work, the command object must store enough state to reverse its `execute()` action. For an “add” command, this is simple (just subtract), but for more complex actions, it might require storing a snapshot of the Receiver’s state (see the Memento pattern).
• Memory Usage: Keeping a long history of command objects can consume significant memory, especially if the commands store a lot of state for the undo operation.
• Decoupling Level: The pattern’s main benefit is decoupling in c++. The Invoker should have no knowledge of the ConcreteCommand or Receiver, communicating only through the abstract Command interface.
• Asynchronous Execution: Commands can be placed in a queue to be executed by a worker thread, which is useful for long-running tasks in a GUI application to prevent freezing.
• Macro Commands: You can create a command that holds a list of other commands. Executing this “macro” command executes all the sub-commands in sequence, a powerful concept for scripting. For more, see our guide on c++ design patterns.
• Command Granularity: Deciding what constitutes a single “command” is a key design choice. Is changing a character in a text editor one command, or is typing a whole word? This affects the user’s undo/redo experience.

Frequently Asked Questions (FAQ)

What is the main benefit of using a calculator using command pattern c++?

The primary benefit is decoupling the object that invokes an operation from the one that knows how to perform it. This flexibility is what enables features like undo/redo, logging, and transactional behavior.

Are the values here unitless?

Yes, for this abstract calculator, the values are unitless numbers. The focus is on the pattern’s structure, not a specific domain like finance or physics.

How does ‘undo’ work in the command pattern?

Each `ConcreteCommand` object must implement an `undo()` method. This method contains the logic to reverse the `execute()` operation. For example, the `undo()` for an `AddCommand(5)` would be to subtract 5 from the receiver.

What happens if I execute a new command after undoing?

Typically, in a simple implementation like this one, executing a new command after one or more ‘undo’ actions will clear the redo history. This prevents a complex, branching history tree.

Is this pattern only for calculators?

Not at all. It’s used everywhere from text editors (undo/redo typing), drawing applications (undo drawing a line), to game development (unit orders) and installing software (rollback on failure). Check out our article on behavioral design patterns for more examples.

Why use C++ for this?

C++’s object-oriented features, including abstract base classes and virtual functions, make it a natural fit for implementing classic design patterns like the Command Pattern.

Can the Command Pattern improve my C++ software architecture?

Absolutely. It promotes loose coupling, making your system more modular, easier to test, and more maintainable. Good C++ software architecture often relies on such established patterns.

Where can I learn about other similar patterns?

The Command pattern is a behavioral pattern. You might also be interested in the Strategy and Observer patterns. A great place to start is our overview of the command pattern example and other patterns.

Related Tools and Internal Resources

Explore more concepts in software design and C++ development with these related articles from our blog:

• Undo/Redo Implementation in C++: A deep dive into the most common use case for the Command Pattern.
• Command Pattern Example: More examples and variations of the command pattern.
• C++ Design Patterns: An overview of the most important creational, structural, and behavioral patterns.
• Behavioral Design Patterns: Understand the category of patterns that the Command pattern belongs to.
• Decoupling in C++: Learn more techniques for creating modular and maintainable code.
• C++ Software Architecture: High-level concepts for building robust and scalable systems.