How would you implement a strategy pattern using interfaces in C?

Related To: C Programming, Strategy Pattern, Design Patterns, Function Pointers, Structs, Polymorphism

Direct Summary:

In C, implementing the Strategy Pattern requires emulating interfaces using structs of function pointers. This struct defines the contract for an algorithm. You then create concrete strategy functions or structs that provide the actual implementations. A context struct holds a reference (a pointer) to the chosen strategy’s interface, allowing it to delegate the algorithm execution and dynamically switch between strategies at runtime, promoting flexible and maintainable code.

The Strategy Design Pattern is a behavioral design pattern that allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. This pattern lets the algorithm vary independently from clients that use it. In C, while there are no native “interfaces” or “classes” in the object-oriented sense, you can effectively implement this pattern using structs and function pointers to achieve similar levels of flexibility and decoupling as in object-oriented languages.

• Key Components of the Strategy Pattern in C

  • 1. Define the Abstract Strategy Interface (using a Struct of Function Pointers)

    This is the core of the Strategy Pattern in C. You define a typedef struct that contains one or more function pointers. Each function pointer represents a method that different strategies will implement. This struct establishes a contract: any concrete strategy must provide functions matching the signatures of these pointers. For example, in a sorting scenario, this interface struct might contain a pointer to a sort function.

  • 2. Implement Concrete Strategies (Functions or Structs)

    These are the different implementations of the algorithm. Each concrete strategy is typically a set of functions that adhere to the interface defined by the function pointer struct. You might group related functions within their own struct and then instantiate the “interface” struct with pointers to these specific implementations. This approach provides its unique way of achieving the desired outcome. Continuing with the sorting example, you might have separate bubble_sort_impl and quick_sort_impl functions, which are then assigned to the sort function pointer in different instances of your strategy interface struct.

  • 3. Define the Context Struct

    The context struct is the client of the Strategy Pattern. It holds a pointer to an instance of the abstract strategy interface (the struct of function pointers) and delegates the algorithm execution to the function pointer within that struct. This decoupling allows the context to switch between strategies without needing to know the specific implementation details of each algorithm. In our sorting example, a SorterContext struct would hold a pointer to an ISortingStrategy instance and call its sort function pointer.

  • 4. Flexibility and Decoupling

    This is a key benefit of the Strategy Pattern. The context struct interacts with strategies through the generic interface (struct of function pointers), making it easy to swap strategies dynamically at runtime. For instance, you could configure a SorterContext to use a Bubble Sort strategy for smaller datasets and a Quick Sort strategy for larger ones, all without changing the SorterContext‘s core logic. This promotes high cohesion and loose coupling.

• Interview Hints for the Strategy Pattern in C

  • Emphasize Loose Coupling and Maintainability:

    “In a recent project, we needed a flexible way to apply different discount calculations. Hardcoding various discount types into our order processing logic would have made maintenance a nightmare. Instead, we used the Strategy Pattern in C. We defined an IDiscountStrategy struct with a calculate_discount function pointer. Then, we created concrete strategy functions for each discount type: percentage_discount_impl, fixed_amount_discount_impl, etc. Our OrderProcessorContext struct held a pointer to the chosen IDiscountStrategy instance. This allowed us to easily add new discount types (e.g., a ‘HolidayDiscount’ function) without modifying the OrderProcessorContext‘s core logic. The existing code remained untouched, demonstrating excellent maintainability and extensibility.”

  • Provide Real-world Examples:

    “Imagine an embedded system or a command-line utility with multiple data processing algorithms. Instead of embedding the logic for each method (e.g., encryption algorithms, data compression types, or parsing strategies) directly into the main processing loop, we can use the Strategy Pattern. Each processing method would be a concrete strategy defined by a set of functions implementing an IProcessingStrategy interface (a struct of function pointers). The main processing system (the context) wouldn’t need to know the specifics of each method; it would simply call the appropriate function pointer (e.g., process_data) on the chosen IProcessingStrategy instance. This approach makes adding new processing options significantly easier without impacting the core system flow.”

  • Clearly Articulate the Benefits:

    “The Strategy Pattern offers several key benefits, particularly valuable in C development where explicit design patterns enhance code structure. First, it improves code organization by encapsulating different algorithms into separate, well-defined functions or modules. This makes the codebase cleaner and easier to navigate. Second, it reduces code duplication. Without the Strategy Pattern, you might end up repeating similar code blocks for different algorithms. With the pattern, you define each algorithm once in its concrete strategy. Finally, it significantly enhances testability. Each strategy’s implementation can be tested independently, ensuring the correctness of individual algorithms in isolation. This isolation makes it easier to identify and fix bugs, leading to a more robust and maintainable application. In our discount example, we could easily write unit tests for each discount calculation function independently, verifying their correctness.”

Comprehensive C Code Example: Implementing Sorting Strategies

This example demonstrates how to implement the Strategy Pattern in C using function pointers and structs for different sorting algorithms.

#include <stdio.h> // For printf
#include <stdlib.h> // For general utilities like malloc (though not used in this simple example)

// 1. Define the Abstract Strategy Interface (using a struct of function pointers)
// This struct acts as our "interface contract"
typedef struct ISortingStrategy {
    // A function pointer that concrete strategies must implement
    void (*sort)(int* data, int size);
    // You could add other methods here if needed, e.g., a 'destroy' function
    // void (*destroy)(struct ISortingStrategy* self);
} ISortingStrategy;

// --- Concrete Strategy Implementations ---

// Bubble Sort Strategy
// The actual implementation function for Bubble Sort
void bubble_sort_impl(int* data, int size) {
    printf("Sorting using Bubble Sort\n");
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (data[j] > data[j + 1]) {
                // Swap elements
                int temp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = temp;
            }
        }
    }
}

// Global instance of the Bubble Sort strategy interface
// This acts as our "concrete strategy object"
ISortingStrategy bubble_sort_strategy = {
    .sort = bubble_sort_impl
};

// Quick Sort Strategy
// Helper functions for Quick Sort
void quick_sort_recursive(int* data, int low, int high);
int partition(int* data, int low, int high);

// The actual implementation function for Quick Sort
void quick_sort_impl(int* data, int size) {
    printf("Sorting using Quick Sort\n");
    quick_sort_recursive(data, 0, size - 1);
}

void quick_sort_recursive(int* data, int low, int high) {
    if (low < high) {
        int pi = partition(data, low, high);
        quick_sort_recursive(data, low, pi - 1);
        quick_sort_recursive(data, pi + 1, high);
    }
}

int partition(int* data, int low, int high) {
    int pivot = data[high];
    int i = (low - 1); // Index of smaller element
    for (int j = low; j < high; j++) {
        // If current element is smaller than or equal to pivot
        if (data[j] <= pivot) {
            i++; // Increment index of smaller element
            int temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
    }
    int temp2 = data[i + 1];
    data[i + 1] = data[high];
    data[high] = temp2;
    return i + 1;
}

// Global instance of the Quick Sort strategy interface
ISortingStrategy quick_sort_strategy = {
    .sort = quick_sort_impl
};

// 3. Define the Context Struct
// This struct holds a pointer to the chosen strategy interface
typedef struct SorterContext {
    ISortingStrategy* strategy; // Pointer to the current sorting strategy
} SorterContext;

// Functions to manage the SorterContext
void sorter_context_init(SorterContext* context, ISortingStrategy* initial_strategy) {
    context->strategy = initial_strategy;
}

void sorter_context_set_strategy(SorterContext* context, ISortingStrategy* new_strategy) {
    context->strategy = new_strategy;
}

void sorter_context_execute_strategy(SorterContext* context, int* data, int size) {
    // Check if a strategy is set and if its sort method is valid
    if (context->strategy && context->strategy->sort) {
        context->strategy->sort(data, size);
    } else {
        printf("Error: No sorting strategy set or invalid strategy.\n");
    }
}

// Helper function to print an array (for demonstration)
void print_array(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// Example Usage in a main function (uncomment to run):
/*
int main() {
    int numbers1[] = {5, 2, 8, 1, 9, 4};
    int size1 = sizeof(numbers1) / sizeof(numbers1[0]);

    SorterContext context;

    // --- Using Bubble Sort ---
    printf("--- Using Bubble Sort ---\n");
    sorter_context_init(&context, &bubble_sort_strategy); // Initialize with Bubble Sort
    printf("Original array: ");
    print_array(numbers1, size1);
    sorter_context_execute_strategy(&context, numbers1, size1); // Execute Bubble Sort
    printf("Sorted array: ");
    print_array(numbers1, size1);

    printf("\n");

    // --- Switching to Quick Sort ---
    int numbers2[] = {10, 3, 7, 6, 1, 9, 2, 8, 4, 5}; // Reset list for clarity
    int size2 = sizeof(numbers2) / sizeof(numbers2[0]);

    printf("--- Switching to Quick Sort ---\n");
    sorter_context_set_strategy(&context, &quick_sort_strategy); // Change strategy to Quick Sort
    printf("Original array: ");
    print_array(numbers2, size2);
    sorter_context_execute_strategy(&context, numbers2, size2); // Execute Quick Sort
    printf("Sorted array: ");
    print_array(numbers2, size2);

    return 0;
}
*/