Kann man mit #define rechnen?

UnderDog schrieb:
> MAJOR += '0'

In C: Nö. Der Präprozessor ist primär ein Textersetzungstool. Warum 
nicht erneutes #define von MAJOR mit dem korrekten Wert?
Davon ab: '0' ist ungleich einer dezimalen Null.

Erkläre doch erstmal, was du vor hast.

Man kann "MAJOR" ja auch als eine int Nummer angeben.
Dies musste ich zur Laufzeit ja erst noch umrechnen. Das wollte ich mit 
dem Prep.. machen.

Falls ich mal vergesse '1' etc. einzugeben und dafür 1 etc.

#if (VERSION_MAJOR < '0')
#undef VERSION_MAJOR
#define VERSION_MAJOR (hier der wert vom alten #define VERSION_MAJOR + 
'0')
#endif

ich bräuchte den alten wert

Frank M. schrieb:
> A. K. schrieb:
>> #if (MAJOR < '0')
>>  #error Depp!
>> #endif
>
> Absolut ACK. Man sollte einen persönlichen Fehler ("Vergessen, in
> Hochkommata zu schreiben") nicht durch irgendwelche Automatismen
> kompensieren, sondern eindeutig auf den Fehler hinweisen, damit er
> anschließend korrigiert wird.

ebenfalls ACK. Die Faustformel hier lautet, dass Fehlererkennung und 
-Korrektur um so besser und effektiver ist, je früher sie angewandt 
werden kann. Also jeder zur Designzeit erkennbare Fehler sollte auch 
dort erkannt werden (Designzeit vor Compilierzeit vor Laufzeit).

Wobei Erkennung in diesem Fall besser ist als Korrektur, denn wenn der 
TO tatsächlich so eine Krücke mit On-the-Fly- Geradebiegen einbauen 
sollte, dann wird lt. Murphy §23 Abs. 4, Satz 2 garantiert irgend Jemand 
im späteren Projektverlauf durch eine ungünstige Verkettung von 
#includes auf MAJOR zugreifen, BEVOR es umgebogen wurde.

Oder der Andere Klassiker: Der Wertebereich von MAJOR wird später so 
uminterpretiert, dass '0' - 1 plötzlich erlaubt ist (z.B. als Broadcast 
o.ä.), und dann wird die Fehlerkorrektur plötzlich zur Fehlerquelle.

Beide Fehler resultieren aus dem einfachen Fakt, dass MAJOR bei der 
Korrektur durch den Präprozessor eine dynamische Komponente bekommt, 
also mehr als einen Wert annehmen kann. Bei der #error Variante ist der 
Wert vollständig statisch, also garantiert immer das, als was er einmal 
definiert worden ist.

Also automatische Erkennung zur Compilezeit und Korrektur zur Hirnzeit. 
Sicherer geht's nicht (natürlich nur in diesem Fall und äquivalenten 
Fällen).

Brauchst Du vielleicht so etwas :

1

#define MAJOR 1

2

3

#if (MAJOR < '0')

4

#define ASCII_MAJOR ((MAJOR)+'0')

5

#else

6

#define ASCII_MAJOR (MAJOR)

7

#endif

undef ist nämlich böse :-)

Und : nein, #define rechnet nicht...

Zum Thema Murphy :
Ich denke eher, dass er im Programm noch so viel korrigieren muss, dass 
er irgendwann bei Major-Version 10 und höher ist, welche dann als 
Doppelpunkt, Semikolon oder ähnliches ausgegeben werden.

fop schrieb:
> Brauchst Du vielleicht so etwas :#define MAJOR 1
>
> #if (MAJOR < '0')
> #define ASCII_MAJOR ((MAJOR)+'0')
> #else
> #define ASCII_MAJOR (MAJOR)
> #endif
>
> undef ist nämlich böse :-)
>
> Und : nein, #define rechnet nicht...

> #define ASCII_MAJOR ((MAJOR)+'0')

? Ist '+' keine Rechenoperation?

Du kannst bei Word auch den Text 17+4 einfügen, ohne das Word versucht 
die beiden Zahlen zu addieren...

Erst nachdem der Precompiler stumpf den Text eingefügt hat, läuft der 
Compiler los, erkennt hoffentlich den Ausdruck als konstant und macht 
sich daran, dessen Wert zu bestimmen. Zu diesem Zeitpunkt ist aber schon 
so gut wie alles, was mit # beginnt Geschichte.

UnderDog schrieb:
> Falls ich mal vergesse '1' etc. einzugeben und dafür 1 etc.

Falls Major eine Versionsnummer darstellen soll, wirst Du mit '1' nicht 
glücklich. Mach als int und rechne wie empfohlen um.