2

So there is third-party library that has a header file you need to include in order to use it. Since the implementation of the library is not object oriented I wrote a Class to encapsulate all usage of the library, so in case it needs to be replaced I can just modify the implementation of that class.

Since other developers will be working in the same code base I want a way to give them an error if they include the library. This is to avoid having references all over the place to the library.

For example if they do something like this:

#include "cool_library.h"

they get an error saying:

do not include directly cool_library.h, instead use the cool_library_wrapper class

is this possible? I'm using GNU GCC

Makako
  • 86
  • 3
  • 2
    I think a cleaner solution would be to add the check to your build-process (makefile or whatever you use). You could add cppcheck or other code sanity checkers while you are at it. The C-preprocessor isn't exactly the right tool for this job. – Patrick Oct 12 '11 at 23:17
  • 3
    `grep 'some_header.h' include/ src/ -R` should do it. And don't forget to fire repeat offenders. This is not a problem to be solved at source code level. – R. Martinho Fernandes Oct 12 '11 at 23:23

5 Answers5

4

Since you're using gcc, you can use the #include_next feature of the preprocessor: Create a header with the same name as the 3rd party's in a directory that will have higher precedence when looking for header files. In your version of the header use something like

#if WRAPPER_HEADER_HAS_BEEN_INCLUDED
#  include_next <cool_library.h>
#else
#  error ...
#endif
Idelic
  • 14,976
  • 5
  • 35
  • 40
3

You could use a #error preprocessor directive within a #ifndef block.

For example in the orginal .h file have this:

#ifndef COOL_LIBRARY_WRAPPER_CLASS_INCLUDED
#error "do not include this file directly
#endif

And in the wrapper class's header file do this:

#define COOL_LIBRARY_WRAPPER_CLASS_INCLUDED
sashang
  • 11,704
  • 6
  • 44
  • 58
  • I forgot to mention that I can't modify the third-party code, this would work fine if I could, but I can't. Thank you – Makako Oct 12 '11 at 23:23
  • 1
    @Makako: Seems you want magic. You want the header to behave differently, without modifying it. – MSalters Oct 13 '11 at 10:36
2

This would only be possible if you're okay with modifying the cool_library.h file. You could do something like:

cool_library.h

#ifndef INCLUDED_FROM_COOL_LIBRARY_WRAPPER
#error do not include directly cool_library.h, instead use the cool_library_wrapper class
#endif

.. remainder of original cool_library.h

cool_library_wrapper.h

#define INCLUDED_FROM_COOL_LIBRARY_WRAPPER
#include "cool_library.h"

... your wrapper

#undef INCLUDED_FROM_COOL_LIBRARY_WRAPPER

Of course, you still can't prevent your coworkers from defining INCLUDED_FROM_COOL_LIBRARY_WRAPPER themselves and including the original header file. This is a social problem that does not have a technical solution.

Greg Hewgill
  • 951,095
  • 183
  • 1,149
  • 1,285
1

If you usually include some project-wide headers you could check for the presence of the include guard from the third-party header, e.g.

// third_party.h
#ifndef THIRD_PARTY_H
#define THIRD_PARTY_H
...

and 

// your_project_wide.h
...
#ifdef THIRD_PARTY_H
#warning "Please include "cool_library.h"
#endif
...

Caveats here: #warning is a gcc extension, and all this relies on the external dependencies being included before your project headers (which you might not want to do).

Community
  • 1
  • 1
Benjamin Bannier
  • 55,163
  • 11
  • 60
  • 80
  • since I can't modify the third-party header, but it is wrapped with the appropriate `#ifndef _X_ #define _X_ #endif`, I could do something like this to warn others. However they need to include the project wide *.h file. Thank you – Makako Oct 12 '11 at 23:31
1

Don't put <cool_library.h> in the normal build include path. You can either use special CFLAGS for your wrapper to give it access or access it with a more explicit path like <vendor/xyz/cool_library.h> from some higher-level include path.

Another path-based approach would be to put a local <cool_library.h> earlier in the include path and use the #ifdef/#error approach above. If the magic define is present then the stub header can use the more explicit path to pick up the real header. (Some compilers have a hack to continue the search path if you include something named exactly the same thing as the header that's being read)

Ben Jackson
  • 90,079
  • 9
  • 98
  • 150