I am making a low level library that requires initialization to work properly which I implemented with a init function. I am wondering if there is a way to make the init call be called once the user calls a library function ideally without:

1. Any overhead
2. No repeated calls
3. No exposed global variables. (my current solution does this, which I don't quite like)

my current solution as per comment request:

bool isinit = 0;

void init()
{
  isinit = 1;
  // init code
}

void lib_function()
{
  if(!isinit) init();
  // function code
}

The compiler seems to be smart enough (using -0fast on gcc) to not make that comparison each time a lib_function is called, but this still exposes a global variable which I don't like.

CodePudding user response：

Best way to abstract away an init function?

Surely your library has some state. Typically, a library exposes functions that work on a specific structure. Do not use global variables - do not write spaghetti code. Expose the structure that holds the state of your library, and make all functions of your library take a pointer to the structure as an argument. Use a namespace - prepend all exported symbols with a prefix. An init function is just like int lib_init(struct lib_the_struct *t); - it will be self-understandable that users need to initialize the structure with that function before use. For example: fopen(), pthread_create.

Write an init function in your library. Write clear documentation stating, that the user of your library has to call the function once before calling any other function. For example: https://curl.se/libcurl/c/curl_global_init.html .

CodePudding user response：

If you're happy with a solution that is a common extension rather than part of the C standard, you can mark your init function with the constructor attribute, which ensures it will be called automatically during program initialization (or during shared library load if you eventually end up using that).

CodePudding user response：

I would fix this with assert so that the if will dissappear in release build and if you forget to call the init_function somewhere you get the error while developing.

Also turn isinit into a static so every library can have its own variable with the same name.

    #include <assert.h>
    
#ifndef NDEBUG
    static int isinit = 0;
#endif

    void lib_function()
    {
      assert(isinit && "library: init not called");
    }

CodePudding user response：

There will be overhead if you run if(!isinit) init(); each time you call a function. At least an extra branch.

As for removing global variables, do in your example but static bool isinit = 0;. This reduces the scope of the variable to the local translation unit (.c file and all .h files it includes). It's no longer "global". Note that this isn't ideal in multi-threaded scenarios - you will have to protect the variable with a mutex then.

Overall though, what you are trying to do isn't a good idea. It is very common convention for C libraries to have an init function and the user of the library is expected to call it before calling anything else or they are to blame, not your library. Naturally you have to make this clear to them with source code documentation. It is common to have a list of prerequisites in source code comments together with every function declaration placed in the header file of the library.