Präprozessor - Exponnent

[Walter T. (nicolas)]

Hallo zusammen,
kennt jemand eine Möglichkeit, den Präprozessor konstante Potenzen 
berechnen zu lassen? Konkret suche ich etwas wie:

#define N_DIGITS 3

void fcn(uint16_t a) {
  a %= pow(10,NDIGITS);
  ...
}

um den konstanten Term auf der rechten Seite schon im Präprozessor 
ausrechnen zu können. Wenn ich das richtig sehe, gibt es ja keinen 
Exponnentialoperator und keine Schleifen.

Viele Grüße
Nicolas

[(prx) A. K. (prx)]

Der Präprozessor rechnet nicht. Ausnahme: der Operand in #if.

[Walter T. (nicolas)]

A. K. schrieb:
> Der Präprozessor rechnet nicht. Ausnahme: der Operand in #if.

OK, laß es mich präzisieren: Mit Präprozessormagie dafür sorgen, daß der 
GCC Konstanten daraus macht. OK, ich könnte es für sinnvolle Werte 
einfach mit einer switch-case-Tabelle machen. Aber ist das schön?

[(prx) A. K. (prx)]

#define N 3
#define CAT(a,b) a##b
#define CAT2(a,b) CAT(a,b)

CAT2(10e,N) => 10e3

Ist es das, was du willst?

Anonsten werden Compiler u.U. konstante Ausdrücke bereits selbst 
berechnen. Nicht selten sogar dann, wenn bekannte Mathefunktionen wie 
exp() dazu gehören.

[Walter T. (nicolas)]

Ich will zwar 1e3 (SCNR), aber ja, genau das ist es, was ich suche. 
Vielen Dank!

[Dave (Gast)]

Modern ist aber eher constexpr.

Ok, das ist c++. Wenn man richtig damit umgeht, ist das für einen uC 
aber auch bestens geeignet.

[chris (Gast)]

Ansonsten wird of so ein workaround gemacht:

#define N_DIGITS 3
#define pow_1(x) (x)
#define pow_2(x) pow_1(x*x)
#define pow_3(x) pow_1(x*x*x)
#define pow_4(x) pow_1(x*x*x*x)
#define pow_5(x) pow_1(x*x*x*x*x)
#define pow_6(x) pow_1(x*x*x*x*x*x)
#define pow_7(x) pow_1(x*x*x*x*x*x)
#define pow_8(x) pow_1(x*x*x*x*x*x)

#define pp_pow__(x,y) pow_##y(x)
#define pp_pow_(x,y) pp_pow__((x),y))
#define pp_pow(x,y) pp_pow_((x),y))

void fcn(uint16_t a) {
  a %= pp_pow(10,N_DIGITS);
  }

[Dr. Sommer (Gast)]

#include <iostream>
 
template <typename T>
constexpr const T clPow (const T& base, const unsigned int exp) {
    return exp == 0 ? T{1} : clPow<T> (base, exp-1) * base;
}
 
int main () {
    constexpr int x = clPow (10, 4);
    std::cout << x << std::endl;
}

"constexpr" zwingt den Compiler die Werte beim Compilieren auszurechnen. 
Funktioniert außerdem auch zur Laufzeit. So vermeidet man den 
Präprozessor komplett mit allen seinen Fallen & Nachteilen...

[Walter T. (nicolas)]

Woher kommt eigentlich dieses Konstrukt:

#define CAT(a,b) a##b
#define CAT2(a,b) CAT(a,b)

Ich habe es schon in vielen Quelltexten gesehen?

[(prx) A. K. (prx)]

## verkettet die Parameter ohne Leerzeichen zwischendrin.

Eine zweistufige Staffelung der CAT Makros ist erforderlich, weil sonst 
Makros als Parameter nicht aufgelöst werden. CAT(10e,N) führt zu 10eN.

[Andreas B. (andreas_b77)]

test.c:

#include <math.h>

double test(void)
{
  return pow(10, 3);
}

int testi(void)
{
  return pow(10, 3);
}

Compile:

avr-gcc -c -Os test.c

Ergebnis:

test.o:     file format elf32-avr


Disassembly of section .text:

00000000 <test>:
   0:  60 e0         ldi  r22, 0x00  ; 0
   2:  70 e0         ldi  r23, 0x00  ; 0
   4:  8a e7         ldi  r24, 0x7A  ; 122
   6:  94 e4         ldi  r25, 0x44  ; 68
   8:  08 95         ret

0000000a <testi>:
   a:  88 ee         ldi  r24, 0xE8  ; 232
   c:  93 e0         ldi  r25, 0x03  ; 3
   e:  08 95         ret