create a instance within a #define macro - c++

Question

I wan't something like:
#define some_func(a) some_func(a, create_foo())
and then when using:
void loop() {
some_func(3);
some_func(40);
}
the Foo instance should only be created once for each line.
So in the above case, 2 times. And when loop is running again, it should not create the Foo instances again.
Is such a thing possible?
Here is the complete non working program:
The output should be 3, 40, 6, 80, 9, 120, 12, 160, ...
typedef struct {
int a;
} Foo;
Foo create_foo() {
return {0};
}
void some_func(int a, Foo &f) {
f.a += a;
Serial.println(f.a);
}
#define some_func(a) some_func(a, create_foo())
void setup() {
Serial.begin(9600);
}
void loop() {
some_func(3); // 3, 6, 9, 12
some_func(40); // 40, 80, 120, 160
}
Edit.
I tried to isolate the example to a bare minimum, but i'm shooting myself in the foot now. In the actual thing, I don't have a void as return type but a boolean.
So I try something like this now:
#define debounce(val) for(static auto d = create_debounce(); debounce(d, val), false;)
But that of course fails when used with:
int state = debounce(digitalRead(BUTTON_FIRE));
Cause the macro is not giving a value back so no assignment can happen.
So I need something like:
#define debounce(val) true; for(static auto d = create_debounce(); debounce(d, val), false;)
where true is the result of the create_debounce function.
So can poison it even more to make it possible? Here is the complete code:
// ----------------- L I B R A R Y . S T U F F -------------------------
#define debounce_delay 50
typedef struct {
int state;
int last_state;
unsigned long last_state_change_time;
} Debounce;
Debounce create_debounce() {
return {0, 0, 0L};
}
boolean debounce(Debounce &deb, int val) {
if (val != deb.last_state) {
deb.last_state_change_time = millis();
deb.last_state = val;
}
else if ((millis() - deb.last_state_change_time) > debounce_delay) {
deb.state = val;
}
return deb.state;
}
//#define debounce(val) for(static auto d = create_debounce(); debounce(d, val), false;)
#define debounce(val) true; for(static auto d = create_debounce(); debounce(d, val), false;)
// ----------------- S K E T C H -------------------------
#define BUTTON_FIRE 7
void setup() {
Serial.begin(9600);
}
void loop() {
int state = debounce(digitalRead(BUTTON_FIRE));
if (state == HIGH) {
Serial.println("HIGH");
}
else {
Serial.println("LOW");
}
}

Answer 1

If you are willing to get really ugly, you can accomplish practically anything. I'm only answering this because this is a brain teaser.
You can define the macro like this:
#define some_func(a) for(static auto f = create_foo(); some_func(a, f), false;)
Yes, this will work. In standard C++, the init clause of a for loop can contain a static variable declaration. So the variable will be initialized only once. Then the "condition" is the actual call to some_func followed by the comma operator with false, so the function is only execute once each time the for loop is entered.
Adapting your code from Arduino to standard C++, and simulating the four cycles, generated the same output you wanted. See it live.
Alternatively, if you want to appear slightly less cryptic (but why would you?), you can opt for this:
#define some_func(a) do {static auto f = create_foo(); some_func(a, f); } while(0)
Same thing really.
Alright, applying it to your actual problem calls for something different:
#define debounce(a) [](int v){static Debounce d = create_debounce(); \
return debounce(d, v); }(a)
This defines and immediately invokes a lambda. Since a lambda creates a unique closure type everywhere it appears in a program, this will create a unique static object for every expression you write debounce(...) in. An alternative is the GCC specific statement expression. But unlike a lambda, that is an extension. Which you may or may not want to use, YMMV.

Answer 2

When the loop is run again, then the Foo instances are created again, they are not restore from the previous run.
I suspect what you want to do is using a set of static variables. Or refactor your code for clarity.
This macro is not helping you in this matter, don't use it, use explicit variables and then you will see the lifetime of objects. A macro is not part of the compiler, but of the preprocessor.

Answer 3

Besides being ill-formed, your macro isn't useful for what you want because you're calling create_foo on each invocation.
You can use static variables:
void loop() {
static Foo f1, f2;
some_func(3, f1);
some_func(40, f2);
}

Answer 4

The first thing to note, is that your state is a boolean. This will save you a few bytes of RAM.
The next thing to point out is that you want to ignore changes to the input for a period of time; this means you don't need to store the "current" state; just the last state... which will end up being the same. This might not save you anything, since the 2 booleans and 1 boolean will likely just take a byte; but it gives the compiler a chance, and most importantly, makes things simpler.
With those 2 fairly minor improvements made, we get to the bigger ones. Don't use macros unless you really know what you're doing; and even then reconsider.
Arduino example code tends to offer them because someone thought it would make it easier to learn; but honestly, they don't. They're not a function, and your usage of it really isn't doing what you think it's doing. Arduino offer limited ways to debug it, so you can't actually tell that your state will ALWAYS be high, because the macro expansion is this:
int state = true;
for(static auto d = create_debounce();
debounce(d, val),
false;);
//New lines added for clarity.
Move it to a function; let the compiler optimise the code because it will ALWAYS do a better job than you as long as you write the code in a way that lets it.