#include <iostream>
#include <string>

template<typename OutputPolicy, typename LanguagePolicy>
class HelloWorld: private OutputPolicy, private LanguagePolicy {
	using OutputPolicy::print;
	using LanguagePolicy::message;

public:
// Behaviour method
	void run() const {
// Two policy methods
		print(message());
	}
};

class OutputPolicyWriteToCout {
protected:
	template<typename MessageType>
	void print(MessageType const &message) const {
		std::cout << message << std::endl;
	}
};

class LanguagePolicyEnglish {
protected:
	std::string message() const {
		return "Hello, World!";
	}
};

class LanguagePolicyGerman {
protected:
	std::string message() const {
		return "Hallo Welt!";
	}
};

int main() {
	/* Example 1 */
	typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyEnglish> HelloWorldEnglish;

	HelloWorldEnglish hello_world;
	hello_world.run(); // prints "Hello, World!"

	/* Example 2
	 * Does the same, but uses another language policy */
	typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyGerman> HelloWorldGerman;

	HelloWorldGerman hello_world2;
	hello_world2.run(); // prints "Hallo Welt!"
}

import ...
public aspect TraceAspect {
        private Logger logger = Logger.getLogger(TraceAspect.class);
        
        pointcut inDomainType()
                                         : within(ajia.domain..*);
        pointcut inControllerType()
                                         : within(ajia.web..*);
        pointcut inRepositoryType()
                                         : within(ajia.repository..*);
        pointcut inTracedType()
                                         : inDomainType() || inControllerType() || inRepositoryType();
        pointcut traced()
                                         : (execution(* *(..)) || execution(new(..))) && inTracedType();
                                       
        ... advice to traced() ...
}

Dynamic crosscutting in AspectJ modifies the behavior of the modules and consists of both pointcut and advice constructs. The advice constructs provide a way to express actions at before, after, or around the desired join points. With context-collecting pointcuts, advice can support static typing that is natural to a Java programmer. The reflection support in AspectJ provides access to the join point’s static and dynamic information through a small number of interfaces. You can use this context to tailor the advice based on the actual values (method parameters or return value) being used at runtime. Alternatively, you can use this information in tracing aspects to gain more insight into the system’s inner workings. The dynamic and static information together can produce an enriched log output with a simple tracing aspect. Although dynamic crosscutting forms a major part of support for crosscutting functionality, elegant solutions need to modify the static structure of the system.

"int C::%(…)"
Сопоставимо любому методу класса C, который возвращает значение типа int
"%List"
Сопоставимо любой структуре, классу, объединению или перечислению, чьё имя 
заканчивается на "List"
"% printf ( const char*, ... )"
Сопоставимо функции printf (в глобальной области видимости), первый параметр 
которой имеет тип const char* и возвращающей значение любого типа
"const %& …::%(…)"
Сопоставимо всем функциям, которые возвращают ссылку на константный объект

"%List" && !derived ("Queue" ) 
Описывает набор классов с именами, заканчивающимися на “List”, и не наследуемых от 
класса Queue
call ( "void draw ( )" ) && within ( "Shape" )
Описывает набор вызовов функции draw, находящихся внутри методов класса Shape

pointcut new_user (const char* name) =
 execution ("void login (…)") && args (name);
 advice new_user (name) : before (const char* name) {
 cout << "User " << name << " is logging in." << endl;
 }

aspect Counter {
 static int m_count;
 Counting () : m_count (0) {}
 pointcut counted () = "Circle" || "Polygon";
 advice counted () : class Helper {
 Helper () { Counter::m_count++; }
 } m_counter;
 advice execution ("% main (…)") : after () {
 cout << "Final count: " << m_count << " objects" << endl;
 }
 };

aspect Counter {
 static int m_count;
 Counter () : m_count (0) { }
 pointcut virtual counted () = 0;
 …
 };

aspect MyCounter : public Counter {
 pointcut counted () = derived ("Shape");

aspect Trace {
 pointcut virtual methods () = 0;
 
 advice execution (methods () ) : around {
 cout << "before " << JoinPoint::signature () << "(";
 for (unsigned i = 0; i < JoinPoint::args (); i++)
 printvalue (tjp->arg (i), JoinPoint::argtype (i));
 cout << ")" << endl;
 tjp->proceed ();
 cout << "after" << endl;
 }
 };

class Bus {
 void out (unsigned char);
 unsigned char in ();
 };

aspect BusIntSync {
 pointcut critical () = execution ("% Bus::%(…)");
 advice critical () && !cflow (execution ("% os::int_handler ()")) :
 around () {
 os::disable_ints ();
 tjp->proceed ();
 os::enable_ints ();
 }
 };

aspect Logger {
 pointcut calls () = 
 call ("void transmit ()") && within ("Transmitter");
 
 advice calls () : around () {
 cout << "transmitting …" << flush;
 tjp->proceed ();
 cout << "finished." << endl;
 }
 };

aspect Debug {
 pointcut fct () = "% MemPool::dealloc (void*)";
 pointcut exec () = execution (fct ());
 pointcut calls () = call (fct ());
 
 advice exec () && args (ptr) : before (void *ptr) {
 assert (ptr && "argument is NULL");
 }
 advice calls () : before () {
 assert (tjp->target () && "’this’ is NULL");
 }
 };