Enum oder defines?

In C ist es weitgehend egal. In C++ würde ich enum (oder enum class) 
verwenden, weil da die Typprüfung strenger ist und weil sich enums dort 
an Namespaces halten.

Enums haben den Vorzug, daß man sich nicht um die Verwaltung der 
dahintersteckenden numerischen Werte kümmern muss, und daß Doppelungen 
(zwei verschiedene Namen für den gleichen Wert) ausgeschlossen sind.

Damit sind sie einfachem Textersatz durch #defines auch in normalem 
deutlich überlegen.

Man muss sich halt im klaren über die Einschränkungen sein, enums sind 
in C eine sehr primitive Kiste und als Datentyp weitestgehend 
unbrauchbar, zumal sie eben alle im selben Namensraum liegen.

Damit ist es unmöglich, in zwei verschiedenen Enums den gleichen Namen 
zu verwenden.

Sie sind aber als strukturierendes Element zu gebrauchen (das in erster 
Linie der Quelltextdokumentation dient), d.h. man weiß, welche Werte 
logisch zusammengehören, was bei #defines nur von der Disziplin des 
Quelltextschreibers abhängt, und sie haben, wie schon erwähnt, den 
Vorzug der Doublettenvermeidung.

Ein #define aus einem fremden *.h hat hier mal heimlich Textersatz in 
meinem Programm gemacht, ein sehr schöner Fehler. Seit dem gibt es 
#define nur noch, um komplizierte Initialisierungen schöner schreiben zu 
können. In C ist "const" zwar nicht soo toll, aber immer noch besser als 
#define.

1

static const char   bga_letters[] = "ABCDEFGHJKLMNPRTUVWY";

2

static const int  AFMAX = 16;

enum missbrauche ich auch für Bitmasken; jede Fehlermeldung vom Compiler 
hilft!

meinst du sowas?

1

// temperature.h

2

#pragma once

3

4

// Temperatur Bits, allgemein sind Temperaturen int32_t;

5

// uint16_t könnte auch reichen, auch für TEGs und Abgas, nicht für Flammrohr

6

7

static const int T_F_MUL = 50;  // diese sollen für die Anzeige durch 10

8

static const int T_C_MUL = 90;  // teilbar sein. Sie sollen gross genug sein,

9

                                // dass 0.1K darstellbar und größer

10

                                // als TEMP_OPEN ist

11

typedef enum temperature_enum {

12

   T_UNDEF,                     // keine Daten

13

   T_SHORT,                     // Kurzschlusß, gemessen

14

   T_OPEN,                      // Offen, gemessen

15

   T_05K      =   90 / 2,       // 0.5 Kelvin

16

   T_1K       =   1 * 90,

17

   T_2K       =   2 * 90,

18

   T_3K       =   3 * 90,

19

   T_5K       =   5 * 90,

20

   T_17K      =  17 * 90,

21

// TEMP_200K  =    18000,       // -99.67°F = -73.15°C

22

//            =    20970,       // -40.27°F = -40.15°C

23

   T_ABSMIN   =    20984,       // -40.00°F = -40.00°C

24

   T_0F       =    22984,       // 459.67 * 50 = -17.7778°C

25

   T_0C       =    24584,       // 273.15 * 90  (Fehler < 0.006K)

26

   T_25C      =  25 * 90 + T_0C,

27

   T_40C      =  40 * 90 + T_0C,

28

   T_60C      =  60 * 90 + T_0C,

29

   T_75C      =  75 * 90 + T_0C,

30

   T_ABSMAX   =  90 * 90 + T_0C,

31

//              32767           //  90.9°C

32

//              33578           //   100°C = 212°F

33

//              65535           //   455°C = 851°F = 728.2K

34

//             301784           // Wasserstoff/Sauerstoff-Flamme <= 3080°C

35

} temperature_enum;

36

37

static inline int C_(int T) { return T * T_C_MUL + T_0C; }

38

static inline int F_(int T) { return T * T_F_MUL + T_0F; }

39

static inline int K_(int T) { return T * T_C_MUL; }

40

41

int  print_temp (int unit, int kelvins);

naja, es ist eine Aufzählung von Konstanten, die alle etwas mit 
Temperaturen zu haben, nur ausnahmsweise nicht lückenlos von 0 bis n. Es 
mag unmoralisch sein, aber es ist nicht verboten und es macht nicht dick 
;)
Was könnte #define an dieser Stelle besser?

Fragen ueber Fragen schrieb:
> Deine Aufgabenstellung sieht nach einer Nachschlagtabelle aus.

Wo siehst Du das?

Und - wo würde ein #define daran irgendwas verändern?

Bevor Du "Schmutz" unterstellst, solltest Du vielleicht besser 
verstehen, was Du da versuchst, zu beurteilen.