How can I print to standard error in C with 'printf'?

Some examples of formatted output to stdout and stderr:

printf("%s", "Hello world\n");              // "Hello world" on stdout (using printf)
fprintf(stdout, "%s", "Hello world\n");     // "Hello world" on stdout (using fprintf)
fprintf(stderr, "%s", "Stack overflow!\n"); // Error message on stderr (using fprintf)

#include<stdio.h>

int main ( ) {
    printf( "hello " );
    fprintf( stderr, "HELP!" );
    printf( " world\n" );
    return 0;
}

$ ./a.exe
HELP!hello  world
$ ./a.exe 2> tmp1
hello  world
$ ./a.exe 1> tmp1
HELP!$

1. stderr is usually unbuffered and stdout usually is. This can lead to odd looking output like this, which suggests code is executing in the wrong order. It isn't, it's just that the stdout buffer has yet to be flushed. Redirected or piped streams would of course not see this interleave as they would normally only see the output of stdout only or stderr only.

2. Although initially both stdout and stderr come to the console, both are separate and can be individually redirected.

If you don't want to modify current code and just for debug usage.

Add this macro:

#define printf(args...) fprintf(stderr, ##args)
// Under GCC

#define printf(args...) fprintf(stderr, __VA_ARGS__)
// Under MSVC

Change stderr to stdout if you want to roll back.

It's helpful for debug, but it's not a good practice.

According to the GCC online manual, you can define a variadic eprintf macro:

#define eprintf(...) fprintf (stderr, __VA_ARGS__)

__VA_ARGS__ is a macro which expands to the variadic arguments passed to the macro, so the below code snippet

eprintf("Error message: %s", errorMessage);

will be expanded to the following.

fprintf(stderr, "Error message: %s", errorMessage);

The parameters for the function will be the same as printf.

While this approach does not employ the fprintf or the perror, using the system call write and fd (1) for stdout or fd (2) for stderr, same results can be achieved.

#include <stdio.h>
#include <unistd.h>

/*buff_size can vary depending on the buffer you want to write*/

int main(void){
    var[] = "Customized Error String\n";
    buff_size = 1024;

    write(1,var, buff_size);
    return (1);
}

You may know sprintf. It's basically the same thing with fprintf. The first argument is the destination (the file in the case of fprintf i.e. stderr), the second argument is the format string, and the rest are the arguments as usual.

I also recommend this printf (and family) reference.

I don't know what your desired scenario would be to use fprintf. In case it is to process errors, the suggested way to print errors in C is by using the perror function.

This function will print your error to stderr coupled with the interpreted errno returned from the previous function. This error is thread-local, i.e., every thread has its private value. For instance, if you try to write to a file inside of a protected directory, like in this function:

int main() {
    FILE *file = fopen("/some_write_protected_dir/file.txt", "w");
    if (file == NULL) {
        perror("Error creating file");
    } else {
        fclose(file);
    }
    return 0;
}

It will print Error creating file: Permission denied. Notice that it added the interpreted text for errno 13. Also, make sure not to have any call to other syscalls as the errno value will be overwritten.

The fprintf(stderr, ...) function on the other hand can be used to print your custom error messages.

This is nonstandard but in some C implementations like Newlib, there's eprintf(), which is the same thing as fprintf(stderr, ...).

eprintf("ERROR: You have caused an error!");

By the way, if you are using stderr for debugging, you can use the __LINE__ macro:

#define printfError(str, ...) eprintf("ERROR at line " #__LINE__ ": " str, __VA_ARGS__)

printfError("Division by zero"); // "ERROR at line 2: Division by zero