“Bitwise E” e Sinistra-Imbottitura in C ++

Question

Ho una macro che sembra qualcosa di simile:

Foo(x) ((x - '!') & 070)

Se chiamo il seguente codice:

Foo('1') => 16

Tuttavia, se chiamo il seguente codice:

(('1' - '!') & 70) => 0

Quindi la mia domanda è, che cosa sta succedendo qui? Perché x & 070 calcolo per x ma x & 70 calcolo a 0?

La mia ipotesi è che l'extra 0 a sinistra sta costringendo a prendere 60 2 byte invece di 1. In quel caso, non sarebbe il bit a bit & fissate come segue?

0000 0000 0001 0000     '16
0000 0000 0100 0110 &   '70
-------------------
0000 0000 0000 0000

Answer 1

In C ++, una costante con un 0 leader è una costante ottale, non è una costante decimale. È ancora una costante intera ma 070 == 56.

Questa è la causa della differenza di comportamento.

Answer 2

No, i mezzi aggiuntivi 0 il numero viene letto come ottale (base 8). Ciò significa che non dice 70, ma 56:

0000 0000 0001 0000     '16 
0000 0000 0011 1000 &   '56
------------------- 
0000 0000 0001 0000 

Answer 3

Anteporre la 070 con una 0 come si sta facendo dice al compilatore di interpretarlo come ottale, non decimale. Probabilmente si desidera dire 70.

Answer 4

Come altri hanno detto, è un 070 ottale (e 0x70 un esadecimale) costante, che è dove il vostro problema bugie.

Mi piacerebbe aggiungere, però, che si dovrebbe utilizzare le funzioni inline invece di macro:

inline int Foo(int x) { return (x - '!' & 070); }

C ++ ha fatto molto per permetterci di sbarazzarsi del preprocessore per molte cose, perché è cattivo, comportamento anomalo, e pericoloso. Se si può fare a meno, farlo.
(E se lo si utilizza, almeno la pietà di quelle che hanno a che fare con il codice più tardi per fare le macro-tutto maiuscolo).