Preprocessor array generation

Question

I'm trying to create a macro to replace a function definition. This macro should register the name of the function in some array so that some other macro can do something with the elements of the array.

I'd like to do this to have a list of functions that can be used in a console without having to edit the list whenever I add a new function (it's actually multiple lists).

After reading up a bit I've taken a look at the boost preprocessor. Unfortunately it appears there is no way to 'save' the new array. What I'd like to do is something like this:

#define SOME_ARRAY (0, ())
#define CONSOLE_COMMAND(a) \
  #redefine SOME_ARRAY BOOST_PP_ARRAY_PUSH_BACK(SOME_ARRAY, #a) \
  void a(some_arguments)

Unfortunately, to my knowledge, redefine doesn't exist and #define can't be used in a macro (please correct me if I'm wrong).

I took a look at boost's precompiler's SLOTs but I don't think I can change the variable in it once set either.

Is there any way to do this other than writing my own preprocessor? Is not, what would be a good start in learning how to write one? (Using MinGW with Code::Blocks).

I'm sure there are easily maintainable ways to solve your problem without the use of preprocessor. Why don't you describe the problem? — jrok
– jrok, Commented Sep 4, 2012 at 10:29

Some programmer dude · Accepted Answer · 2012-09-04 10:47:55Z

A common way of doing similar things is to have the functions declared in a header file using a special macro. This macro will be defined differently depending on which source file it is included in. Normally it will just define a standard function prototype, but when included in a special source file it will be defined to add entries in a table.

Something like this:

// functions.h
#ifndef FUNCTION_H_
#define FUNCTION_H_

#ifndef FUNCTION
# define FUNCTION(name) \
    void name(const std::vector<std::string> &);
#endif

FUNCTION(foo)
FUNCTION(bar)

#endif

// functions.cpp
// File that defines the function table

#include <functional>

using function_type = std::function<void(const std::vector<std::string> &)>;

#define FUNCTION(name) \
    { #name, name },

std::map<std::string, function_type> functions = {
#include "functions.h
};

Now you have a std::map containing pointers to the functions, indexed by the function name.

Yes you still have to maintain a "list" of your functions, namely the prototype list in functions.h, but when you add (or remove) functions it's very easy to "modify" this list.

ecatmur · Accepted Answer · 2012-09-04 15:38:10Z

0

The preprocessor isn't designed to be able to redefine symbols, so you can't use it to accumulate a value in a pass through the file.

One possible solution would be to use a redefinition and self-reinclude as an X-Macros technique:

#define CONSOLE_COMMAND(a,body) \
    void a(some_arguments) body

CONSOLE_COMMAND(my_command, { ... })

const char *array[] = {
#undef CONSOLE_COMMAND
#define CONSOLE_COMMAND(a,body) #a ,
#include __FILE__
};

A more idiomatic C++ solution would be to have your commands as file-scope objects whose constructors register them at program startup time.

edited Sep 4, 2012 at 15:38

answered Sep 4, 2012 at 10:43

ecatmur

158k28 gold badges311 silver badges387 bronze badges

2 Comments

DrBearhands Over a year ago

So if I understand correctly it's the same concept as Joachim Pileborg's solution: change the definition and reinclude in the array so it now becomes the desired entries. I don't really understand what COMMAND_NAME and COMMAND_DEFINITION are for though.

ecatmur Over a year ago

@DrBearhands oops, ignore those.

Collectives™ on Stack Overflow

Preprocessor array generation

2 Answers 2

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related