Executing certain code for every method call in C++

I have a C++ class I want to inspect. So, I would like to all methods print their parameters and the return, just before getting out.

The latter looks somewhat easy. If I do return() for everything, a macro

#define return(a) cout << (a) << endl; return (a)

would do it (might be wrong) if I padronize all returns to parenthesized (or whatever this may be called). If 开发者_如何学GoI want to take this out, just comment out the define.

However, printing inputs seems more difficult. Is there a way I can do it, using C++ structures or with a workaroud hack?

A few options come to mind:

• Use a debugger.
• Use the decorator pattern, as Space_C0wb0y suggested. However, this could be a lot of manual typing, since you'd have to duplicate all of the methods in the decorated class and add logging yourself. Maybe you could automate the creation of the decorator object by running doxygen on your class and then parsing its output...
• Use aspect-oriented programming. (Logging, which is what you're wanting to do, is a common application of AOP.) Wikipedia lists a few AOP implementations for C++: AspectC++, XWeaver, and FeatureC++.

However, printing inputs seems more difficult. Is there a way I can do it, using C++ structures or with a workaroud hack?

No.

Update: I'm going to lose some terseness in my answer by suggesting that you can probably achieve what you need by applying Design by Contract.

It sounds like you want to use a debugging utility to me. That will allow you to see all of the parameters that you want.

If you don't mind inserting some code by hand, you can create a class that:

1. logs entry to the method in the constructor
2. provides a method to dump arbitrary parameters
3. provides a method to record status
4. logs exit with recorded status in the destructor

The usage would look something like:

unsigned long long
factorial(unsigned long long n) {
    Inspector inspect("factorial", __FILE__, __LINE__);
    inspect.parameter("n", n);
    if (n < 2) {
        return inspect.result(1);
    }
    return inspect.result(n * fact(n-1));
}

Of course, you can write macros to declare the inspector and inspect the parameters. If you are working with a compiler that supports variable argument list macros, then you can get the result to look like:

unsigned long long
factorial(unsigned long long n) {
    INJECT_INSPECTOR(n);
    if (n < 2) {
        return INSPECT_RETURN(1);
    }
    return INSPECT_RETURN(n * fact(n-1));
}

I'm not sure if you can get a cleaner solution without going to something like an AOP environment or some custom code generation tool.

If your methods are all virtual, you could use the decorator-pattern to achieve that in a very elegant way.

EDIT: From your comment above (you want the output for statistics) I conclude that you should definitely use the decorator-pattern. It is intended for this kind of stuff.

I would just use a logging library (or some macros) and insert manual logging calls. Unless your class has an inordinate number of methods, it's probably faster to get going with than developing and debugging more sophisticated solution.