c++: Is it possible to #include inside a function body?

Question

I want to include a header file only if a certain function body is called?

Is this possible or recommended in C++?

Answer 1

Possible, yes; recommended no, not usually.

#include is process and an early stage of parsing so works in many places with no regard for the language context at the point of the include.

Note that the include will happen regardless of whether the function is called so it probably isn't going to solve the problem that you are trying to solve. The file included will be placed directly inside the function body so the include file would have to be designed to be included at such a point in the source file.

Answer 2

No.

You've got it a bit wrong; #include is not processed at run-time, at all. It's not possible to #include a file based on a program's execution characteristics; once the program executes its source is fixed (since it's already compiled).

Answer 3

You can #include inside a function body, but this does not mean that the header file is only included when the function body is called.

The content of the header file will be included by the preprocessor at compile time, and thus the code will always be present in the function.

Obviously, the code is only executed when the function is called.

Answer 4

While you can put a #include inside a function body, it is not what you want to do. There is no way to include a header file only if a certain function is called because the include happens before compile time, but the function call happens at runtime.

Answer 5

You can put an #include directive inside a function body, but this will not do what you expect. The file will be included at that point, just as if you had copied it there. Take into account that preprocessor directives (such as #include) are not evaluated at runtime. I was about to write "are evaluated at compile time", but even that is not true; they are evaluated even before the compiler has a chance to look at the code.

Answer 6

You're obviously biased by higher-level languages, such as Python, in which is possible to do things like:

if ( a ):
  from whatever import whatever_I_need
else:
  from whatever_else import whatever_I_need

However, in C++ this is evaluated at compile time (well, actually, #include is a preprocessor directive and it is even evaluated before compile time). Putting that inside a block of an if-else construction will only lead to compilation errors. Just take into account that #include is just a way to dump the contents of a file (normally a header (interface) file) into another one that needs its declarations. Very low level. It will be included anyway.

Answer 7

Okay, the question was a little off the track, but the actual matter is important.

If for a portion of your methods you actually need to depend on a library that most users won't care about, it's perfectly reasonable to be willing to spare them this unneeded dependency.

You can do this by manipulating preprocessor tokens.

/// myClass.h
/// In order to use BigDep, you need to:
/// - define `MYPROJECT_BIGDEP_USE` before included this header
/// - have `<bigdep-install-path>/include` in your include path
/// - link with `libbigdep.so`

class MyClass
{
public:

  void foo() const;

#ifdef MYPROJECT_BIGDEP_USE

  void bigDep() const;

#endif // MYPROJECT_BIGDEP_USE

};

/// myClass.cpp

#include "blah.h"
#include "bar.h"

#ifdef MYPROJECT_BIGDEP_USE
#include <bigdep.h>
#endif // MYPROJECT_BIGDEP_USE

void MyClass::foo() const { /**/ }

#ifdef MYPROJECT_BIGDEP_USE

void MyClass::bigdep() { /**/ }

#endif // MYPROJECT_BIGDEP_USE

This way, you have to compile mode, depending on whether the symbol MYPROJECT_BIGDEP_USE is defined or not.

On gcc, you can define symbol on the command line using -D like in -DMYPROJECT_BIGDEP_USE. On Visual Studio it's with /D like in /DMYPROJECT_BIGDEP_USE.

Another option for you user is to wrap your header:

// myProjectMyClass.h
#define MYPROJECT_BIGDEP_USE
#include <myClass.h>

And only ever include "myProjectMyClass.h" and never your header directly.

The use of these preprocessor directives is quite common. For example, when installing the cx_Oracle python module, the installer checked for the version of oracle I used from my environment variables and disabled a number of methods that were not available for it directly at compilation time.