Is it possible to make the execution of a program skip fprintf-statements/How to create my own fprintf-function?

Question

In my C++-code there are several fprintf-statements, which I have used for debugging. Since I might need them again, I would prefer not to comment them out for the moment. However, I need the execution of the program to be fast, so I would like to avoid them being printed out, as they are for the moment (I redirected stderr to a file).

Preferably this would be determined by the user passing an argument to the program, which I would extract like this:

main (int argc, char *argv[])
{
int isPrint=0;
if (argc > 1 ) {
       isPrint = atoi ( argv[2]);
}

}

I thought of renaming fprintf to another name, and then from that function do a fprintf-call using the same parameters, based on the value of isPrint; however, then I realized that fprintf can have so many different kind of arguments and a various number of arguments; and that I don't know any generic way of declaring my own function with those requirements.

So I wonder how to create a function,which works exactly like fprintf, but which takes the extra parameter isPrint; or how to solve the above problem in another way.

Complementary information after first post: One solution would be to add this before each fprintf-statement:

if (isPrint == true )

Your bigger problem is that it appears that your whole program is actually composed of C, from what I can tell. — Puppy, Apr 19 '12 at 12:55

unwind · Answer 1 · 2012-04-19T13:37:06.800

5

The typical approach is to use the preprocessor to compile away the calls to fprintf().

You would do something like this:

#if defined DEBUG
#define LOG(a) fprintf a
#else
#define LOG(a)
#endif

And in the code you would do:

LOG(("The value is %f", some_variable));

Note the double parenthesis, that's just to make the syntax work. You can do it nicer, but this is simpler to explain.

Now, you would either just edit the code to #define or #undef the DEBUG preprocessor symbol at the top of the file, or pass suitable options to the compiler (-D for GCC).

edited Apr 19 '12 at 13:37

answered Apr 19 '12 at 12:56

unwind

391,730
64
469
606

The double-parentheses wouldn't work. This would result in `fprintf(("The value is %f", some_variable))`, which is an application of the comma operator and would discard the first value. – interjay Apr 19 '12 at 12:59
The answer you linked didn't put the parentheses after the `printf`. – interjay Apr 19 '12 at 13:07
@interjay Doh, failed to read my own code properly. Of course those `()`s shouldn't be there, fixed and thanks! – unwind Apr 19 '12 at 13:37

score 1 · Answer 2 · answered Apr 19 '12 at 12:57

For debugging purpose you can use the variable argument macro:

#ifdef DEBUG
#define FPRINTF(...) fprintf(__VA_ARGS__)
#else
#define FPRINTF(...)
#endif

Be attentive that, if you use fprintf directly instead of FPRINTF then since you are defining a library function, it should appear after #include<> of that function.

WildCrustacean · Accepted Answer · 2012-04-19T13:15:17.643

First note that if this is just for debugging, I'd agree that the typical way is to use macros or preprocessor defines to tell the compiler to include logging or not.

However, if you don't want it removed entirely by the compiler (so that you can turn the printing on or off with an argument), you could write your own log function that takes isPrint and some string, and then use snprintf() to format the string before you call it.

Something along these lines:

void myLog(int isPrint, char *message)
{
    if(isPrint == 1)
    {
        fprintf(logFile, "%s", message);
    }
}

char msg[64];
snprintf(msg, 64, "Test Message %d", 10);
myLog(isPrint, msg);

It may also be possible to wrap fprintf() in your own varags function, but that would be more complicated.

score 0 · Answer 4 · edited May 23 '17 at 12:29

It depends how much flexibilty you've got in changing the code and whether you want to be able to switch this off at runtime or just compile time.

I'd suggest you wrap it in your own variadic function (for tips look here) and then you've encapsulated the functionality.

Your function will essentially be just a thin wrapper round fprintf() but at this point you can then either use the preprocessor to ensure that your logging function does nothing if you compile it out, or you can do an integer comparison with, say, a logging level at runtime so that the underlying fprintf() only gets called if your debugging level is high enough.

Is it possible to make the execution of a program skip fprintf-statements/How to create my own fprintf-function?

4 Answers4