Olvídate de lo definido
Contaminarán su código.
bitfields?
struct RecordFlag {
unsigned isnew:1, isdeleted:1, ismodified:1, isexisting:1;
};
Nunca uses eso . Le preocupa más la velocidad que economizar 4 ints. El uso de campos de bits es en realidad más lento que el acceso a cualquier otro tipo.
Sin embargo, los miembros de bits en estructuras tienen inconvenientes prácticos. Primero, el orden de los bits en la memoria varía de un compilador a otro. Además, muchos compiladores populares generan código ineficiente para leer y escribir miembros de bits , y existen problemas de seguridad de subprocesos potencialmente graves relacionados con los campos de bits (especialmente en sistemas multiprocesador) debido al hecho de que la mayoría de las máquinas no pueden manipular conjuntos arbitrarios de bits en la memoria, pero en su lugar debe cargar y almacenar palabras completas. por ejemplo, lo siguiente no sería seguro para subprocesos, a pesar del uso de un mutex
Fuente: http://en.wikipedia.org/wiki/Bit_field :
Y si necesita más razones para no usar bitfields, quizás Raymond Chen lo convencerá en su publicación The Old New Thing Post: El análisis de costo-beneficio de bitfields para una colección de booleanos en http://blogs.msdn.com/oldnewthing/ archivo / 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;
}
Ponerlos en un espacio de nombres es genial. Si se declaran en su CPP o archivo de encabezado, sus valores estarán en línea. Podrá usar el interruptor en esos valores, pero aumentará ligeramente el acoplamiento.
Ah, sí: elimine la palabra clave estática . static está en desuso en C ++ cuando se usa como lo hace, y si uint8 es un tipo buildin, no necesitará esto para declarar esto en un encabezado incluido por múltiples fuentes del mismo módulo. Al final, el código debería ser:
namespace RecordType {
const uint8 xNew = 1;
const uint8 xDeleted = 2;
const uint8 xModified = 4;
const uint8 xExisting = 8;
}
El problema de este enfoque es que su código conoce el valor de sus constantes, lo que aumenta ligeramente el acoplamiento.
enumeración
Lo mismo que const int, con un tipeo algo más fuerte.
typedef enum { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } RecordType;
Sin embargo, todavía están contaminando el espacio de nombres global. Por cierto ... Eliminar el typedef . Estás trabajando en C ++. Esos typedefs de enumeraciones y estructuras están contaminando el código más que cualquier otra cosa.
El resultado es un poco:
enum RecordType { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } ;
void doSomething(RecordType p_eMyEnum)
{
if(p_eMyEnum == xNew)
{
// etc.
}
}
Como puede ver, su enumeración está contaminando el espacio de nombres global. Si coloca esta enumeración en un espacio de nombres, tendrá algo como:
namespace RecordType {
enum Value { xNew = 1, xDeleted, xModified = 4, xExisting = 8 } ;
}
void doSomething(RecordType::Value p_eMyEnum)
{
if(p_eMyEnum == RecordType::xNew)
{
// etc.
}
}
int externo const?
Si desea disminuir el acoplamiento (es decir, poder ocultar los valores de las constantes y, por lo tanto, modificarlos como desee sin necesidad de una compilación completa), puede declarar los ints como externos en el encabezado y como constantes en el archivo CPP , como en el siguiente ejemplo:
// Header.hpp
namespace RecordType {
extern const uint8 xNew ;
extern const uint8 xDeleted ;
extern const uint8 xModified ;
extern const uint8 xExisting ;
}
Y:
// Source.hpp
namespace RecordType {
const uint8 xNew = 1;
const uint8 xDeleted = 2;
const uint8 xModified = 4;
const uint8 xExisting = 8;
}
Sin embargo, no podrá usar el interruptor en esas constantes. Así que al final, elige tu veneno ... :-p