I would like to add that besides
IOCCC tricks,
#include can be handy in evading some of the
C++'s flaws. For example, the default
preprocessor does not allow double-
evaluating things or iterate stuff; however, if you #include something, that'll help. Allow me to
demonstrate:
I wanted to make a system for autogeneration of classes, so that class creator tells me what are his variables and then I can automatically construct a class that has get- and set- functions for those variables, plus init() (NOT creator-function, this was special init()), save(), load() and such functions that can do some interesting stuff for those variables. Now, because C++ doesn't allow the _code_ to examine the _types_ and _names_ of variables defined, I needed to work around this... this is how I made it:
First, class creator writes three files:
Now, this template.hh header... first, it defines the class by classname #defined earlier. Then, it needs to make the member variable-, get- and set-function definitions. Because the preprocessor does not have any sort of iteration (and thus is not programming language)... it #defines CLASSVAR (see, the macro "called" in VAR file) to INBODY, a predefined macro that is defined about like this:
#define INBODY(type,name) type it##name;\
const type& get##name() const { return it##name; }\
void set##name(const type& _t) { it##name=_t; }
This produces the desired code. In similar fashion, all the places that need to "iterate" through variable list (such as, in this case, init() -function which fills in an entry in array with information about this variable, its address inside the class and type), will just need to #define their own CLASSVAR and #include VAR!
Yay, I know it sounds terribly clumsy, but AFAIK this is the only way to do this. If you can make up a better one, let me know. Anyhow, this demonstrates the magic of #include.