Is there any practical use for a function that does nothing?-CodePudding

Would there be any use for a function that does nothing when ran, I.E:

void Nothing() {}

Note, I am not talking about a function that waits for a certain amount of time, like sleep(), just something that takes as much time as the compiler / interpreter gives it.

CodePudding user response：

Such a function could be necessary as a callback function.

Supposed you had a function that looked like this:

void do_something(int param1, char *param2, void (*callback)(void))
{
    // do something with param1 and param2
    callback();
}

This function receives a pointer to a function which it subsequently calls. If you don't particularly need to use this callback for anything, you would pass a function that does nothing:

do_something(3, "test", Nothing);

CodePudding user response：

Yes. Quite a lot of things want to be given a function to notify about a certain thing happening (callbacks). A function that does nothing is a good way to say "I don't care about this."

I am not aware of any examples in the standard library, but many libraries built on top have function pointers for events.

For an example, glib defines a callback "GLib.LogFunc(log_domain, log_level, message, *user_data)" for providing the logger. An empty function would be the callback you provide when logging is disabled.

CodePudding user response：

When I've created tables that contain function pointers, I do use empty functions.

For example:

typedef int(*EventHandler_Proc_t)(int a, int b); // A function-pointer to be called to handle an event
struct 
{
   Event_t             event_id;
   EventHandler_Proc_t proc;
}  EventTable[] = {    // An array of Events, and Functions to be called when the event occurs
    {  EventInitialize, InitializeFunction },
    {  EventIncrement,  IncrementFunction  },
    {  EventNOP,        NothingFunction    },  // Empty function is used here.
};

In this example table, I could put NULL in place of the NothingFunction, and check if the .proc is NULL before calling it. But I think it keeps the code simpler to put a do-nothing function in the table.

CodePudding user response：

A function that takes arguments and does nothing with them can be used as a pair with a function that does something useful, such that the arguments are still evaluated even when the no-op function is used. This can be useful in logging scenarios, where the arguments must still be evaluated to verify the expressions are legal and to ensure any important side-effects occur, but the logging itself isn't necessary. The no-op function might be selected by the preprocessor when the compile-time logging level was set at a level that doesn't want output for that particular log statement.