Call free-like function only if the x.h file was included

Question

I have three *.h files:

A.h:

<some types>
extern sometype1 somevar1;

B.h:

<some types>
extern sometype2 somevar2;

C.h:

<some types>
extern sometype3 somevar3;

And I have the D.c file:

#include "A.h"
#include "B.h"
#include "C.h"

int freethemall()
{
    TheFunctionFromAhFileForFreeingTheSomevar1Resources();
    TheFunctionFromBhFileForFreeingTheSomevar2Resources();
    TheFunctionFromChFileForFreeingTheSomevar3Resources();
}

This project is some kind of framework.

Sometimes I don't need all the modules - A, B or C, for example, I will need only A and B modules. But the structure of my framework initialization is as follows:

#include "A.h"
#include "B.h"
<Frameworkname>Init();

<do some code here>

<Frameworkname>Free();

So, it's very very uncomfortable to call all the Free functions from every module instead of only one ...Free() function:

#include "A.h"
#include "B.h"
<Frameworkname>Init();

<do some code here>

<Frameworkname><modulename1>Free();
<Frameworkname><modulename2>Free();
..
<Frameworkname><modulenameN>Free();

In this case N is only 2, but I have about 20 modules, so It will be not programmer-friendly to count them all.

How can I change freethemall() function to call only destructor of modules that I used and included? Note, that D.h contains that function and there are a lot of modules that include D.h.

P.S. I can include D.h module in every other module if its needed.

As other way to solve it, I need a function that will be called before the module finalization as in last Delphi languages:

Unit ...

Finalization
   Callme;
End.

There is no need to call it from freethemall(), but it's some kind of lead to solve this problem.

Thank you for any advice.

Answer 1

2 ways:

1. the "hack" is to do a #define in each module, or if you don't have access to the code of the modules, do a #define USE_A and and ifdef USE_A to actually include the header. So changing the #define will determine if the header gets included and the function for freeing will check that same define.

2. The correct way is to have a function that "registers" the items you need to free. An array of pointers. so as you create each one, you add it's pointer or a pointer to a function that frees it to the array, then when you need to free, yo just loop through the array and free each one there.

Answer 2

This is the reason they created c++. The overload mechanism would easily solve your problem here. But since you have to do it in C, the only way I know is to use a bitfield

Free(uint32 bitfield){

int i,masklen =32;

for (i=0;i<masklen;i++)
{
  if (bitfield & 1<<i)
    // call free for module i
    // you can have an array of function pointers so that you easily get the right
    // free function each time 
} 
}

Tis will allow you 32 modules if you need more you need a different type for your bitfield

Answer 3

You could create initialization function, that user is required to call during program startup. That function would be passed which modules user would use. Your library would store that information, and on shutdown call appropriate functions.

Example:

/* Header file */

enum SmlModule {
    SML_RASTER = 1,
    SML_EVENT  = 2,
    SML_TIME   = 4
}

int sml_init(int modules);

Then in program:

int main ()
{
    sml_init(SML_RASTER | SML_TIME);
    (...)
    return 0;
}

This approach is used for example by SDL library, see SDL_Init

Answer 4

You could use the Header Guards ^*1 (which are missing anyway) to solve you problem:

Add the Header Guards by modify your headers like this:

A.h:

#ifndef _A_H
#define _A_H

<some types>
extern sometype1 somevar1;

#endif

B.h:

#ifndef _B_H
#define _B_H

<some types>
extern sometype2 somevar2;

#endif

C.h:

#ifndef _C_H
#define _C_H

<some types>
extern sometype3 somevar3;

#endif

And I have the D.c file:

#include "A.h"   /* \                                            */
#include "B.h"   /*  \                                           */
#include "C.h"   /*   + <--- comment in/out here what is needed. */
...              /*  /                                           */
#include "_n_.h" /* /                                            */


int freethemall()
{
    #ifdef _A_H
    TheFunctionFromAhFileForFreeingTheSomevar1Resources();
    #endif

    #ifdef _B_H
    TheFunctionFromBhFileForFreeingTheSomevar2Resources();
    #endif

    #ifdef _C_H
    TheFunctionFromChFileForFreeingTheSomevar3Resources();
    #endif

    ...

    #ifdef __n__H
    TheFunctionFromChFileForFreeingTheSomevar_n_Resources();
    #endif

    return 0;
}

By commenting in/out the #include lines in D.c the defintions of the Header Guards fro the various *.h fiels are used to steer which lines of code in freethemall() are de/activate.

---

^*1 To learn about Header Guard click here and scroll down the answer.

Answer 5

I think what you want is impossible.

In C++, it would be possible because the declaration of objects (whether in header or module) can cause code to be executed, but in C it cannot.

If you do this

main.h:

typedef struct {
    void (*init)(void) ;
    void (*exit)(void) ;
    } MODULE ;

A.h:
extern MODULE A ;

B.h
extern MODULE B ;

main.c:

#include    "main.h"
#include    "A.h"
#include    "B.h"

MODULE modules[] = {
&A,
&B,
0,
} ;

Then during init,exit phases you iterate the modules array, calling the appropriate functions for those phases.

That way you only have to maintain 2 lines. That's the most compact and maintainable way I can think of.