Vergiss die Definitionen
Sie werden Ihren Code verschmutzen.
Bitfelder?
struct RecordFlag {
unsigned isnew:1, isdeleted:1, ismodified:1, isexisting:1;
};
Benutze das niemals . Es geht Ihnen mehr um Geschwindigkeit als um die Einsparung von 4 Zoll. Die Verwendung von Bitfeldern ist tatsächlich langsamer als der Zugriff auf einen anderen Typ.
Bitelemente in Strukturen haben jedoch praktische Nachteile. Erstens variiert die Reihenfolge der Bits im Speicher von Compiler zu Compiler. Darüber hinaus generieren viele gängige Compiler ineffizienten Code zum Lesen und Schreiben von Bitelementen , und es gibt potenziell schwerwiegende Thread-Sicherheitsprobleme in Bezug auf Bitfelder (insbesondere auf Multiprozessorsystemen), da die meisten Maschinen keine beliebigen Sätze von Bits im Speicher manipulieren können. sondern muss stattdessen ganze Wörter laden und speichern. zB wäre das Folgende trotz der Verwendung eines Mutex nicht threadsicher
Quelle: http://en.wikipedia.org/wiki/Bit_field :
Und wenn Sie mehr Gründe brauchen, um Bitfelder nicht zu verwenden, wird Raymond Chen Sie vielleicht in seinem Beitrag The Old New Thing Post überzeugen : Die Kosten-Nutzen-Analyse von Bitfeldern für eine Sammlung von Booleschen Werten unter http://blogs.msdn.com/oldnewthing/ archive / 2008/11/26 / 9143050.aspx
const int?
namespace RecordType {
static const uint8 xNew = 1;
static const uint8 xDeleted = 2;
static const uint8 xModified = 4;
static const uint8 xExisting = 8;
}
Es ist cool, sie in einen Namespace zu stellen. Wenn sie in Ihrer CPP- oder Header-Datei deklariert sind, werden ihre Werte eingefügt. Sie können diese Werte einschalten, aber die Kopplung wird dadurch leicht erhöht.
Ah ja: Entfernen Sie das statische Schlüsselwort . static ist in C ++ veraltet, wenn Sie wie Sie verwendet werden. Wenn uint8 ein Build-Typ ist, benötigen Sie dies nicht, um dies in einem Header zu deklarieren, der von mehreren Quellen desselben Moduls enthalten wird. Am Ende sollte der Code sein:
namespace RecordType {
const uint8 xNew = 1;
const uint8 xDeleted = 2;
const uint8 xModified = 4;
const uint8 xExisting = 8;
}
Das Problem dieses Ansatzes ist, dass Ihr Code den Wert Ihrer Konstanten kennt, was die Kopplung geringfügig erhöht.
Aufzählung
Das gleiche wie const int, mit einer etwas stärkeren Eingabe.
typedef enum { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } RecordType;
Sie verschmutzen jedoch immer noch den globalen Namespace. Übrigens ... Entfernen Sie das typedef . Sie arbeiten in C ++. Diese Typedefs von Aufzählungen und Strukturen verschmutzen den Code mehr als alles andere.
Das Ergebnis ist irgendwie:
enum RecordType { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } ;
void doSomething(RecordType p_eMyEnum)
{
if(p_eMyEnum == xNew)
{
// etc.
}
}
Wie Sie sehen, verschmutzt Ihre Aufzählung den globalen Namespace. Wenn Sie diese Aufzählung in einen Namespace einfügen, haben Sie Folgendes:
namespace RecordType {
enum Value { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } ;
}
void doSomething(RecordType::Value p_eMyEnum)
{
if(p_eMyEnum == RecordType::xNew)
{
// etc.
}
}
extern const int?
Wenn Sie die Kopplung verringern möchten (dh die Werte der Konstanten ausblenden und sie so nach Bedarf ändern können, ohne dass eine vollständige Neukompilierung erforderlich ist), können Sie die Ints im Header als extern und in der CPP-Datei als konstant deklarieren , wie im folgenden Beispiel:
// Header.hpp
namespace RecordType {
extern const uint8 xNew ;
extern const uint8 xDeleted ;
extern const uint8 xModified ;
extern const uint8 xExisting ;
}
Und:
// Source.hpp
namespace RecordType {
const uint8 xNew = 1;
const uint8 xDeleted = 2;
const uint8 xModified = 4;
const uint8 xExisting = 8;
}
Sie können diese Konstanten jedoch nicht einschalten. Also, am Ende, wähle dein Gift ... :-p