c-preprocessor

When I select the "Debug" configuration, the DEBUG constant is active. When I select the "Release" configuration, the DEBUG constant is inactive. How can I create my own configurations so that they include my own defined constants. Basically, I want it so that if I select the configuration "FOOBAR" that there is a constant FOO and BAR in my project active. I'm basically trying to avoid putting in a bunch of #define FOO in my projects, then commenting/uncommenting them out when I need/don't need them. GôTô According to this article you can define compilation constants in the build tab of your

All across our C code base, I see every macro defined the following way: #ifndef BEEPTRIM_PITCH_RATE_DEGPS #define BEEPTRIM_PITCH_RATE_DEGPS 0.2f #endif #ifndef BEEPTRIM_ROLL_RATE_DEGPS #define BEEPTRIM_ROLL_RATE_DEGPS 0.2f #endif #ifndef FORCETRIMRELEASE_HOLD_TIME_MS #define FORCETRIMRELEASE_HOLD_TIME_MS 1000.0f #endif #ifndef TRIMSYSTEM_SHEARPIN_BREAKINGFORCE_LBS #define TRIMSYSTEM_SHEARPIN_BREAKINGFORCE_LBS 50.0f #endif What is the rationale of doing these define checks instead of just defining the macros? #define BEEPTRIM_PITCH_RATE_DEGPS 0.2f #define BEEPTRIM_ROLL_RATE_DEGPS 0.2f #define

e.g. a mapping for Mac OS 10.6.3 aka Snow Leopard => __APPLE__ && __LP64__ ? Windows 7, Windows XP => __WIN32__ Linux => __LINUX__ Here you go: http://predef.sourceforge.net/ 来源： https://stackoverflow.com/questions/2990172/is-there-a-list-of-preprocessor-defines-for-various-operating-systems-and-versi

The Google C++ Style Guide guide advises that macros must not be defined in a .h (header) file. What are the cons of doing it? The preprocessor concatenates all included source files together in order. If you don't undefine a macro, it can apply to any source following where it was first defined. Since headers are often the public API of a library, any macros you define in your headers could end up in someone else's code, doing unexpected things. Since unexpected things are the antithesis of good software, you should either: Not use macros (idiomatic C++ really shouldn't) Define them in a

Is there a way to make a conditional include with the c preprocessor? I have a "library" of tools (Tools.c, Tools.h), shared by different teams. This library depends on a second one, providing XML-capabilities. Lets call that one XML.h Now one team uses a plain version of the second library (XML.h), while another team uses an extended version (XMLEx.h) in their project. The second team doesn't want to include the XML.h because they already have XMLEx.h included, providing all functions of XML.h. Is there a mechanism to implement something like: #ifdef XML_EX #include "XMLEx.h" #else #include

I was looking for a macro that will resemble the with-construct. The usage should be something like: with (lock(&x), unlock(&x)) { ... } It might be useful for some other purposes. I came up with this macro: #define __with(_onenter, _onexit, v) \ for (int __with_uniq##v=1; __with_uniq##v > 0; )\ for (_onenter; __with_uniq##v > 0; _onexit) \ while (__with_uniq##v-- > 0) #define _with(x, y, z) __with(x, y, z) #define with(_onenter, _onexit) _with(_onenter, _onexit, __COUNTER__) It has 3 nested loops because it should: Initialize loop counter (C99 only, of course) Possibly initialize variable

What is a##b & #a ? #define f(a,b) a##b #define g(a) #a #define h(a) g(a) main() { printf("%s\n",h(f(1,2))); //how should I interpret this?? [line 1] printf("%s\n",g(f(1,2))); //and this? [line 2] } How does this program work? The output is 12 f(1, 2) now I understand how a##b & #a work. But why is the result different in the two cases (line 1 and line 2)? The ## concatenates two tokens together. It can only be used in the preprocessor. f(1,2) becomes 1 ## 2 becomes 12 . The # operator by itself stringifies tokens: #a becomes "a" . Therefore, g(f(1,2)) becomes "f(1,2)" when the preprocessor is