In C++, we can use #define to define a macro like #define PI 3.14 and then use PI all throughout the code to represent 3.14.
My question is : Can we #define multiple macros in one line so that I don't need to write n lines to define n macros.
I actually want to do this to represent array elements by alternate names (letters actually) as evident by the code snippet below.
#include <cstdlib>
#include <math.h>
#include <time.h>
#define R dig[0]
#define E dig[1]
#define D dig[2]
#define B dig[3]
#define L dig[4]
#define U dig[5]
#define Y dig[6]
#define O dig[7]
#define W dig[8]
using namespace std;
int main() {
int dig[9]={1,2,3,4,5,6,7,8,9}; // R,E,D,B,L,U,Y,O,W
return 0;
}
Is there a method to #define all those macros in one line so that I don't have to write multiple lines like in the above code snippet? Thanks.
Defining one macro is bad enough.
In your comments, you wonder about an alternative method. There is one in C++ :
auto &R = dig[0], &E = dig[1], &D = dig[2] // etc ...
This isn't just one line but even one statement. Slightly more verbose, you could do
auto &R = dig[0]; auto &E = dig[1]; auto &D = dig[2] // etc ...
and it's now multiple statements on one line. (see the semicolons?)
AFAIK the end of #define statement is the end of the line. So no, you can't write a few separate ones in one line. As someone mentioned, use enum here instead.
No, this is not possible in either C or C++.
Have you considered writing a program to generate repetitive code at build time? That's an under-appreciated technique.
Related
I have a project where there are two different preprocessor macros with the same name, defined in two different include files (from two different libraries), and I have to check if they have the same value at build time.
So far I could make this check at run time, assigning the macro values to different variables in different implementation files, each including only one of the headers involved.
How can I do it at build time?
This is what I tried so far (where Macro1.h and Macro2.h are third-party files I cannot modify):
Header files:
TestMultiMacros.h:
#ifndef TEST_MULTI_MACROS_H
#define TEST_MULTI_MACROS_H
struct Values
{
static const unsigned int val1, val2;
static const unsigned int c1 = 123, c2 = 123;
};
#endif // TEST_MULTI_MACROS_H
Macro1.h:
#ifndef MACRO1_H
#define MACRO1_H
#define MY_MACRO 123
#endif // MACRO1_H
Macro2.h:
#ifndef MACRO2_H
#define MACRO2_H
#define MY_MACRO 123
#endif // MACRO2_H
Implementation files:
TestMultiMacros1.cpp:
#include "TestMultiMacros.h"
#include "Macro1.h"
const unsigned int Values::val1 = MY_MACRO;
TestMultiMacros2.cpp:
#include "TestMultiMacros.h"
#include "Macro2.h"
const unsigned int Values::val2 = MY_MACRO;
entrypoint.cpp:
#include "TestMultiMacros.h"
using namespace std;
static_assert(Values::val1 == Values::val2, "OK"); // error: expression did not evaluate to a constant
static_assert(Values::c1 == Values::c2, "OK");
int main()
{
}
I would be interested in a solution using both C++11 and C++17.
Include the first header. Then save the value of the macro to a constexpr variable:
constexpr auto foo = MY_MACRO;
Then include the second header. It should silently override MY_MACRO. If your compiler starts complaining, do #undef MY_MACRO first.
Then compare the new value of the macro with the variable using a static_assert:
static_assert(foo == MY_MACRO, "whatever");
Here's a very simple C++17 test which works with arbitrary (non-function) macros by comparing the text of the macro expansion. For c++11, which lacks the constexpr comparison in std::string_view, you can write it yourself in a couple of lines, as shown in this answer.
#include <string_view>
#define STRINGIFY(x) STRINGIFY_(x)
#define STRINGIFY_(x) #x
#include "macro1.h"
//#define MY_MACRO A night to remember
constexpr const char* a = STRINGIFY(MY_MACRO);
#undef MY_MACRO
#include "macro2.h"
//#define MY_MACRO A knight to remember
constexpr const char* b = STRINGIFY(MY_MACRO);
static_assert(std::string_view(a) == b, "Macros differ");
int main() { }
(Godbolt: https://godbolt.org/z/nH5qVo)
Of course, this depends on what exactly you mean by equality of macros. This version will report failure if one header file has
#define MY_MACRO (2+2)
and the other has
#define MY_MACRO 4
Also worth noting that stringification normalises whitespace but it does not normalise the presence of whitespace other than trimming the ends. So (2 + 2) and (2 + 2) will compare as equal, but not (2+2) and ( 2 + 2 )
I need to use #define and using = ; as much as I can to replace possibly everything in C++ with emojis 😝😜😫😻😋.
Is it possible to #define preprocessors like #define 😎 #define or at least #define 😖 if, #define 🍉 ==, etc.? Maybe with 'using'?
I'd like to replace operators, core language instructions... Is it possible anyhow?
I know the aboves doesn't work, but maybe there is a way?... Please help me make something funny! :D
Yes, you can. You may need to think about the syntax. Easiest would be to use one emoji per keyword. However you may still need to write function- and variable names in clear text.
As per Romens comment I tried it and you can also replace method names with emojis.
Just as a proof of concept, the following code compiles in visual studio 2019 with platform toolset v142.
#include <iostream>
#define 😎 int
😎 🍉() {
std::cout << "I'm 🍉!";
return 1;
}
😎 main() {
🍉();
}
Or even more to include some of the comments:
#include <iostream>
#define 🙈 using
#define 🤷🏻 cout
#define 😎 int
namespace 🍏 = std;
🙈 🍏::🤷🏻;
😎 🍉() {
🤷🏻 << "I'm";
🍏::cout << "🍉!";
return 1;
}
😎 main() {
🍉();
}
Also using is something else than #define. You will only need the latter.
Is it possible to #define preprocessors like #define 😎 #define
No, it is not possible to define macros to replace preprocessor directives. (Also, macros cannot expand into directives either).
or at least #define 😖 if
This is potentially possible. It depends on the compiler what input character encoding it supports. Emojis are not listed in the basic source character set specified by the language standard, so they might not exist in the character encoding used by the compiler.
Maybe with 'using'?
Emojis are equally allowed for using as they are for macros.
Note that any identifier could be an emoji (assuming they are supported in the first place) including functions, types and variables. Example:
struct 🍏🍏 {};
struct 🍊🍊 {};
int main() {
🍏🍏{} == 🍊🍊{};
}
I'm writing a bunch of related preprocessor macros, one of which generates labels which the other one jumps to. I use them in this fashion:
MAKE_FUNNY_JUMPING_LOOP(
MAKE_LABEL();
MAKE_LABEL();
)
I need some way to generate unique labels, one for each inner MAKE_LABEL call, with the preprocessor. I've tried using __LINE__, but since I call MAKE_LABEL inside another macro, they all have the same line and the labels collide.
What I'd like this to expand to is something like:
MAKE_FUNNY_JUMPING_LOOP(
my_cool_label_1: // from first inner macro
...
my_cool_label_2: // from second inner macro
...
)
Is there a way to generate hashes or auto-incrementing integers with the preprocessor?
If you're using GCC or MSVC, there is __COUNTER__.
Other than that, you could do something vomit-worthy, like:
#ifndef USED_1
#define USED_1
1
#else
#ifndef USED_2
#define USED_2
2
/* many many more */
#endif
#endif
I use this:
#define MERGE_(a,b) a##b
#define LABEL_(a) MERGE_(unique_name_, a)
#define UNIQUE_NAME LABEL_(__LINE__)
int main()
{
int UNIQUE_NAME = 1;
return 0;
}
... and get the following:
int main()
{
int unique_name_8 = 1;
return 0;
}
As others noted, __COUNTER__ is the easy but nonstandard way of doing this.
If you need extra portability, or for other cool preprocessor tricks, the Boost Preprocessor library (which works for C as well as C++) will work. For example, the following header file will output a unique label wherever it's included.
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/slot/slot.hpp>
#if !defined(UNIQUE_LABEL)
#define UNIQUE_LABEL
#define BOOST_PP_VALUE 1
#include BOOST_PP_ASSIGN_SLOT(1)
#undef BOOST_PP_VALUE
#else
#define BOOST_PP_VALUE BOOST_PP_INC(BOOST_PP_SLOT(1))
#include BOOST_PP_ASSIGN_SLOT(1)
#undef BOOST_PP_VALUE
#endif
BOOST_PP_CAT(my_cool_label_, BOOST_PP_SLOT(1)):
Sample:
int main(int argc, char *argv[]) {
#include "unique_label.h"
printf("%x\n", 1234);
#include "unique_label.h"
printf("%x\n", 1234);
#include "unique_label.h"
return 0;
}
preprocesses to
int main(int argc, char *argv[]) {
my_cool_label_1:
printf("%x\n", 1234);
my_cool_label_2:
printf("%x\n", 1234);
my_cool_label_3:
return 0;
}
I can't think of a way to automatically generate them but you could pass a parameter to MAKE_LABEL:
#define MAKE_LABEL(n) my_cool_label_##n:
Then...
MAKE_FUNNY_JUMPING_LOOP(
MAKE_LABEL(0);
MAKE_LABEL(1);
)
You could do this:
#define MAKE_LABEL() \
do { \
my_cool_label: \
/* some stuff */; \
goto my_cool_label; \
/* other stuff */; \
} while (0)
This keeps the scope of the label local, allowing any number of them inside the primary macro.
If you want the labels to be accessed more globally, it's not clear how your macro "MAKE_FUNNY_JUMPING_LOOP" references these labels. Can you explain?
It doesn't seem possible with a standard preprocessor, although you could fake it out by putting parameters within MAKE_LABEL or MAKE_FUNNY_JUMPING_LOOP, and use token pasting to create the label.
There's nothing preventing you from making your own preprocessing script that does the automatic increment for you. However, it won't be a standard C/C++ file in that case.
A list of commands available: http://www.cppreference.com/wiki/preprocessor/start
I have, in a .c file, the following (this is a much smaller array to exemplify):
static const char* __someNames[] =
{
"Fox",
"Wulf",
"Cat"
};
Then later I am defining a macro like this:
#define EXAMPLE(N) XXX
where I would like XXX to be replaced by __someNames[N] without the "..i.e I would like
#define EXAMPLE(1)
to expand to:
Wulf
How can I go about this?
EDIT
Some cool ideas. This is more out of intellectual curiosity that I want to do this. I like the idea of the #include "file.h# twice with a redefined macro..what if I can also use the boost preprocessor (I added c++ and boost tags to question) - would I be able to get around having the extra "file.h"? The one with a #define per string is also cool though slightly less idea given how many #defines I would have...
I think the solution to your X problem (where you have asked about the Y solution) is to turn the thing around and use macros to put the string in, and then use the same macro redefined to do whatever else it is you want to do.
For example:
#define EXAMPLE(x) #x,
static const char* __someNames[] =
{
#include "file.h"
};
#undef EXAMPLE
#define EXAMPLE(x) x,
enum animals
{
#include "file.h"
};
where file.h contains:
EXAMPLE(Fox)
EXAMPLE(Wulf)
EXAMPLE(Cat)
There is no way to do this with the standard C or C++ pre-processor.
The pre-processor scans your code for identifiers, and if an identifier matches a macro, it expands the macro. The expanded macro, in this case, would actually be the array name followed by the input number in brackets.
It is a limitation of the way the pre-processor works!
A work-around is like this...
#define EXAMPLE_1 Wolf
#define EXAMPLE_2 Dog
#define EXAMPLE_3 Cat
#define EXAMPLE_X(n) EXAMPLE_##n
// Then say
EXAMPLE_X(1); // will put Wolf;
int EXAMPLE_X(2) = 0;// expands to int Dog = 0;
Unfortunately that only works if you pass in constants like 1 or 2 etc... Variables would not work.
OR ...
static const char* __someNames[] =
{
#define __someNames_1 Fox
"Fox",
#define __someNames_2 Wulf
"Wulf",
#define __someNames_3 Cat
"Cat"
};
#define EXAMPLE_X(n) __someNames_##n
That will work the way you expect and keep the same scheme, but it will put a lot of defines for big arrays!.
#define EXAMPLE(_x) __someNames[(_x)]
I have two macros that declares class properties:
DECLARE_QUERY_PARAM_LONG(name)
DECLARE_QUERY_PARAM_STRING(name)
I want to count number of calls of this macros inside of my class and init
static const size_t paramsCount
with that number like this:
class MyClass {
...
DECLARE_QUERY_PARAM_LONG(param1)
DECLARE_QUERY_PARAM_STRING(param2)
DECLARE_QUERY_PARAM_STRING(param3)
DECLARE_QUERY_PARAM_LONG(param4)
static const size_t paramsCount = PARAMS_COUNT; // 4 in this case
...
};
Is this ever possible?
There would be a solution, rather complicated:
All your parameters will have a fixed name (say param)
You need to create one header file per type
You shall need boost
So here is the header creation file:
// file declare_int.h
#include BOOST_PP_UPDATE_COUNTER()
int stringize(param,BOOST_PP_COUNTER) ;
and the class file:
//file declare_auto.cpp
#include <boost/preprocessor/slot/counter.hpp>
#define _stringize(a,b) a##b
#define stringize(a,b) _stringize(a,b)
// reset counter
#if defined(BOOST_PP_COUNTER)
#undef BOOST_PP_COUNTER
#endif
class A {
public:
#include "declare_int.h"
#include "declare_int.h"
#include "declare_int.h"
#include "declare_int.h"
static const int nbParams = BOOST_PP_COUNTER ;
};
and finally the output of:
g++ -E -P -c declare_auto.cpp -IPATH_TO_BOOST
is
class A {
public:
int param1 ;
int param2 ;
int param3 ;
int param4 ;
static const int nbParams = 4 ;
};
You can at least count number of lines in the following way:
class MyClass
{
static const int line_1 = __LINE__;
DECLARE_QUERY_PARAM_LONG(param1)
DECLARE_QUERY_PARAM_STRING(param2)
DECLARE_QUERY_PARAM_STRING(param3)
DECLARE_QUERY_PARAM_LONG(param4)
static const int line_2 = __LINE__;
static const int macro_calls = line_2 - line_1 - 1;
public:
MyClass()
{
cout << macro_calls << endl;
}
};
But I think you'll need C++11 to do that. And You cannot have empty lines within those two __LINE__s. Otherwise, you'll have to count those empty lines as well.
As such no.
What you are asking for would require some form of introspection, which is not natively supported by C++.
You can improve the macro though, if you had:
DECLARE_QUERY_PARAMS(((LONG , param1))
((STRING, param2))
((STRING, param3))
((LONG , param4)))
then you could do what you want.
You can have a look at Boost.Preprocessor to learn how to obfuscate your sources this way.
Note: this uses a Sequence, in boost parlance.
I don't think there's a standard way to do this, but the DevStudio compiler has this preprocessor macro:
__COUNTER__
Expands to an integer starting with 0 and incrementing by 1 every time it is used in a compiland. __COUNTER__ remembers its state when using precompiled headers. If the last __COUNTER__ value was 4 after building a precompiled header (PCH), it will start with 5 on each PCH use.
__COUNTER__ lets you generate unique variable names. You can use token pasting with a prefix to make a unique name. For example:
// pre_mac_counter.cpp
#include <stdio.h>
#define FUNC2(x,y) x##y
#define FUNC1(x,y) FUNC2(x,y)
#define FUNC(x) FUNC1(x,__COUNTER__)
int FUNC(my_unique_prefix);
int FUNC(my_unique_prefix);
No. Macro's don't respect scope at all, and don't understand that they're inside a class.
No. Macros aren't executed, they're expanded and not even by compiler, but by preprocessor.