Hello

I am trying to store a Preprocessor Constant's value then 'overwrite' it.

My Problem: The code below attempts to store a preprocessor constant's value in variable 'A' then the code undefines that variable then redefines it so it has a new value. The problem is that variable 'A' has the newly defined value and not the old one, if that makes sense. Can I store a Preprocessor Constants value and not its reference(Which is what seems like is happening)?


#ifdef CUSTOM_EVENT_CALLBACK_DEFINED
#define SUB_CUSTOM_EVENT_CALLBACK_DEFINED CUSTOM_EVENT_CALLBACK_DEFINED
#undef CUSTOM_EVENT_CALLBACK_DEFINED
#endif
#define CUSTOM_EVENT_CALLBACK_DEFINED "def"

int main()
{
printf(CUSTOM_EVENT_CALLBACK_DEFINED); // prints out "def".
printf("\n");
printf(SUB_CUSTOM_EVENT_CALLBACK_DEFINED); // prints out "def". I was hoping this would be "abc"
printf("\n");

system("PAUSE");
return 0;
}
// Usage: where the function def is a callback function for a window in a civil engineering program that runs ontop of windows
int def(int id, int cmd, int type)
{
#ifdef SUB_CUSTOM_EVENT_CALLBACK_DEFINED
SUB_CUSTOM_EVENT_CALLBACK_DEFINED(id, cmd, type);
#endif

// perform my custom code here
}


Ewwww, scary.

Not sure why you're trying to do this, but:

Nested macros themselves are replaced, and since CUSTOM_EVENT_CALLBACK_DEFINED is redefined before main is compiled, SUB_CUSTOM_EVENT_CALLBACK_DEFINED is swapped with CUSTOM_EVENT_CALLBACK_DEFINED, which is redefined as "def".

The following would work, but again, not sure why you'd ever do this.
[source lang="cpp"]
int main()
{
printf(CUSTOM_EVENT_CALLBACK_DEFINED); // prints out "def".
printf("\n");
#undef CUSTOM_EVENT_CALLBACK_DEFINED
#define CUSTOM_EVENT_CALLBACK_DEFINED "abc"
printf(SUB_CUSTOM_EVENT_CALLBACK_DEFINED); // prints out "def". I was h...
}[/source]

Its usage is to achieve a form of virtual/polymorphic functions. I am coding in 4dm which is very similar to C except I have no structs and CANNOT have code that is outside main or other functions and obviously has no classes aswell.

The idea is to allow users to continually redefine a custom function but still call the base custom function, ie, add some custom functionality to a function then call the base version of the function - I think thats polymorphism.

Its usage is to achieve a form of virtual/polymorphic functions. I am coding in 4dm which is very similar to C except I have no structs and CANNOT have code that is outside main or other functions and obviously has no classes aswell.

I hope they're paying you well. Sounds like a nightmare. :-/

With no functions other than main, you're probably going to need to use a bunch of goto statements and other conditional/unconditional jumps to create your own version of functions, followed by jump tables to handle your custom functions and base functions.

Oh, we have functions, sorry I might have not explained it properly.

We have functions and main. But you cant have global variables or any code outside of a function. Its C lite I guess, no structs, no pointers, 3 primatives(Text: a C++ string so no dealing with char arrays which is good, Integer and Real), then higher level variables like Super, Polygon, Segments, etc.

But not having structs is a pain in the butt. But its alot of fun to code for 12d Model aswell. Its very geometric; working with arcs, spirals, polygons etc. to assist in producing civil projects (roads, dams, etc.).

At the end of the day I'm trying to find an elegant method where I can redefine a custom library function but still call that previous function within the newly defined function(if that makes sense) so I guess I am trying to push the language to have virtualisation when it never was designed that way, but I'm impatient and persistant so I keep trying