Introduction to Aspect-Oriented Programming

Aspect-Oriented Programming (AOP) serves as a valuable supplement to Object-Oriented Programming (OOP) by addressing cross-cutting concerns. While OOP effectively models vertical, hierarchical relationships through inheritance, it struggles to encapsulate horizontal, shared behaviors that span across unrelated modules—such as logging, authentication, or transaction management. AOP isolates these secondary concerns from the core business logic, allowing developers to focus on the primary functionality. This separation not only declutters the core logic but also promotes the reuse of peripheral components, eliminating code duplication across the system.

Dynamic Weaving via Proxy Pattern

AOP techniques generally fall into two categories: static weaving and dynamic weaving. Static weaving requires specialized syntax and compilers (like AspectC++) to inject aspect code at compile time, which adds complexity. Dynamic weaving intercepts methods at runtime, often utilizing the proxy pattern.

Below is a basic example demonstrating method interception using a traditional proxy:

#include <iostream>
#include <memory>

class IProcessor {
public:
    virtual ~IProcessor() = default;
    virtual void Execute(int value) = 0;
};

class CoreProcessor : public IProcessor {
public:
    void Execute(int value) override {
        std::cout << "Executing core logic with value: " << value << std::endl;
    }
};

class ProcessorProxy : public IProcessor {
    IProcessor* realSubject;
public:
    ProcessorProxy(IProcessor* subj) : realSubject(subj) {}
    ~ProcessorProxy() { delete realSubject; }

    void Execute(int value) final {
        std::cout << "[Pre-Execution] Validation step" << std::endl;
        realSubject->Execute(value);
        std::cout << "[Post-Execution] Logging step" << std::endl;
    }
};

void RunProxyDemo() {
    std::unique_ptr<IProcessor> proxy(new ProcessorProxy(new CoreProcessor()));
    proxy->Execute(100);
}

Although functional, the proxy pattern has limitations: it restricts the flexible composition of multiple aspects and introduces strong coupling, as every proxy must derive from the subject's base interface.

C++11 Mechanisms for Loose Coupling and Flexibility

To build a dynamic AOP framework that supports arbitrary aspect combinations without tight coupling, we leverage C++11 variadic templates and SFINAE (Substitution Failure Is Not An Error).

By parameterizing aspects via variadic templates, we can chain 1 to N aspects around a core function. To eliminate inheritance constraints, an aspect only needs to optionally provide PreProcess(Args...) or PostProcess(Args...) methods matching the core function's signature. We employ compile-time type detection to verify if an aspect possesses these methods, esnuring that missing hooks do not cause compilation errors.

Detecting Member Functions at Compile Time

We define a macro utilizing SFINAE and decltype to check for the existence of specific member functions, even handling overloaded variants through variadic template parameters:

#define DEFINE_METHOD_CHECKER(Member) \
template<typename T, typename... Args> \
struct has_##Member { \
private: \
    template<typename U> static auto Test(int) -> decltype(std::declval<U>().Member(std::declval<Args>()...), std::true_type()); \
    template<typename U> static std::false_type Test(...); \
public: \
    static constexpr bool value = std::is_same<decltype(Test<T>(0)), std::true_type>::value; \
};

DEFINE_METHOD_CHECKER(PreProcess)
DEFINE_METHOD_CHECKER(PostProcess)

This trait checks if a type T can call Member with a specific argument list. If the substitution succeeds, it returns true; otherwise, it safely falls back to false.

Complete AOP Framework Implementation

Combining the compile-time checker with std::enable_if, we construct an AspectWrapper that conditionally invokes aspect hooks and recursively chains multiple aspects:

class NonCopyable {
protected:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

template<typename Func>
class AspectWrapper : NonCopyable {
    Func coreFunc;
public:
    AspectWrapper(Func&& f) : coreFunc(std::forward<Func>(f)) {}

    // Both PreProcess and PostProcess exist
    template<typename... Args, typename Aspect>
    typename std::enable_if<has_PreProcess<Aspect, Args...>::value && has_PostProcess<Aspect, Args...>::value>::type
    Invoke(Args&&... args, Aspect&& aspect) {
        aspect.PreProcess(std::forward<Args>(args)...);
        coreFunc(std::forward<Args>(args)...);
        aspect.PostProcess(std::forward<Args>(args)...);
    }

    // Only PreProcess exists
    template<typename... Args, typename Aspect>
    typename std::enable_if<has_PreProcess<Aspect, Args...>::value && !has_PostProcess<Aspect, Args...>::value>::type
    Invoke(Args&&... args, Aspect&& aspect) {
        aspect.PreProcess(std::forward<Args>(args)...);
        coreFunc(std::forward<Args>(args)...);
    }

    // Only PostProcess exists
    template<typename... Args, typename Aspect>
    typename std::enable_if<!has_PreProcess<Aspect, Args...>::value && has_PostProcess<Aspect, Args...>::value>::type
    Invoke(Args&&... args, Aspect&& aspect) {
        coreFunc(std::forward<Args>(args)...);
        aspect.PostProcess(std::forward<Args>(args)...);
    }

    // Recursive call for multiple aspects
    template<typename... Args, typename FirstAspect, typename... RemainingAspects>
    void Invoke(Args&&... args, FirstAspect&& first, RemainingAspects&&... remaining) {
        first.PreProcess(std::forward<Args>(args)...);
        Invoke(std::forward<Args>(args)..., std::forward<RemainingAspects>(remaining)...);
        first.PostProcess(std::forward<Args>(args)...);
    }
};

// Type identity helper to resolve variadic template deduction issues on certain compilers (e.g., MSVC 2013)
template<typename T>
using TypeIdentity = T;

template<typename... Aspects, typename Func, typename... Args>
void ExecuteWithAspects(Func&& f, Args&&... args) {
    AspectWrapper<Func> wrapper(std::forward<Func>(f));
    wrapper.Invoke(std::forward<Args>(args)..., TypeIdentity<Aspects>()...);
}

The framework stores the target function and executes aspects in sequence. std::enable_if guarantees that only existing methods are called, providing maximum flexibility. Note that aspect hook parameters must exactly match the target function's parameters; mismatched signatures will trigger a compile-time error, serving as an early validation mechanism.

Usage Example: Logging and Timing Aspects

The following example demonstrates applying a timing aspect and an auditing aspect to a core function. The aspects track execution duration and log entry/exit points:

#include <ctime>

struct DurationAspect {
    clock_t startTime;
    void PreProcess(int val) {
        startTime = clock();
    }
    void PostProcess(int val) {
        std::cout << "Execution duration: " << (clock() - startTime) << " ticks" << std::endl;
    }
};

struct AuditAspect {
    void PreProcess(int val) {
        std::cout << "Entering computation with input: " << val << std::endl;
    }
    void PostProcess(int val) {
        std::cout << "Exiting computation" << std::endl;
    }
};

void ComputeValue(int x) {
    std::cout << "Core computation running for: " << x << std::endl;
}

int main() {
    ExecuteWithAspects<DurationAspect, AuditAspect>(&ComputeValue, 42);
    std::cout << "-------------------" << std::endl;
    ExecuteWithAspects<AuditAspect>(&ComputeValue, 100);
    return 0;
}

This lightweight AOP implementation allows arbitrary aspect combinations without forcing inheritance, requiring only that the aspects define matching PreProcess or PostProcess hooks. While it lacks the runtime configuration capabilities found in Java frameworks or AspectC++, it provides a highly efficient, compile-time validated mechanism for separating cross-cutting concerns in C++.