Macro to repeat a single character multiple number of times

Question

I am learning about macros and I want to know that whether it is possible to create a macro that repeats a given character literal a given number of times. For example:

Input :

repeatMacro('a', 5)

should produce(expand to) the output:

Expected Output:

aaaaa

Similarly, repeatMacro('r', 2) should produce:

rr

If possible, repeatMacro('r') should produce(expand to):

r

I have not worked with macros before so I don't know if this is a very basic thing to do.

I also don't know if there is any other way(other than macros) to do the same. If there is any other way(other than macro) to do this, I would prefer that way instead of using macros.

For example, I know that we can do things like the following with macros:

#define x *
int x func()
{
    int*ptr = new int(4);
    return ptr;
}

So I want to do the same with repeatMacro . Something like shown below:

#define repeatMacro(str, n)  // what should come here for the below example to work
int repeatMacro('*',2) func()
{
    int** ptr = new int*[5]();
    return ptr;
}

Answer 1

The preprocessor doesn't have any way to do anything with character literals like 'a' other than output them as is, so I don't think that form is possible. Instead, we'll need to work with identifier preprocessor tokens like a .

Working with numbers in the preprocessor is always tricky, but Boost.Preprocessor has tools to help.

#include <boost/preprocessor/seq/cat.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/facilities/overload.hpp>

#define REPEAT_MACRO_SEQ_ELEM(z, n, data) (data)
#define REPEAT_MACRO_2(c, n) \
    BOOST_PP_SEQ_CAT(BOOST_PP_REPEAT(n, REPEAT_MACRO_SEQ_ELEM, c))
#define REPEAT_MACRO_1(c) c

#define REPEAT_MACRO(...) \
    BOOST_PP_OVERLOAD(REPEAT_MACRO_, __VA_ARGS__)(__VA_ARGS__)

I've renamed your macro REPEAT_MACRO , because it's common practice to use only uppercase for a preprocessor macro name, giving a hint to the code reader that it's a macro.

REPEAT_MACRO_2 uses BOOST_PP_SEQ_CAT to paste together a sequence of preprocessor tokens. It expects input in the form of a "sequence" like (a)(a)(a)(a)(a) , so we pass it the result of BOOST_PP_REPEAT , using REPEAT_MACRO_SEQ_ELEM as the operator to add the parentheses around the input token.

To take care of allowing REPEAT_MACRO(r) producing just r , there's BOOST_PP_OVERLOAD . It will paste the number of arguments onto the end of the given macro prefix REPEAT_MACRO_ , so that REPEAT_MACRO(c) calls REPEAT_MACRO_1(c) and REPEAT_MACRO(c,n) calls REPEAT_MACRO_2(c,n) .

This solution doesn't really require that the input identifier is just one character, and I'm not sure there's any way to require that. So you also get that REPEAT_MACRO(xyz, 3) gives xyzxyzxyz .

For the case from comments of repeating a * as in function type int repeatMacro(*, 2) func() , you would not want to concatenate the preprocessor tokens, since there's no such token as ** . To get that behavior instead of the identifier-pasting would be instead:

#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/facilities/overload.hpp>

#define REPEAT_MACRO_ID_OP
#define REPEAT_MACRO_2(c, n) BOOST_PP_REPEAT(n, REPEAT_MACRO_ID_OP, c)
#define REPEAT_MACRO_1(c) c

#define REPEAT_MACRO(...) \
    BOOST_PP_OVERLOAD(REPEAT_MACRO_, __VA_ARGS__)(__VA_ARGS__)

I doubt there's any way to get a single macro doing the paste for identifiers and just repetition for punctuation.