sizeof error de cálculo miembro de

Question

Tengo una estructura de este tipo (por alguna razón no puedo sólo tiene que utilizar una matriz):

struct OperatorData 
    { 
    char m_record_0[RIX_OPERATOR_CONFIG_SIZE]; 
    char m_record_1[RIX_OPERATOR_CONFIG_SIZE]; 
    //.... 
    char m_record_9[RIX_OPERATOR_CONFIG_SIZE]; 
    }; 

Y yo estoy tratando de calcular la cantidad de campos en tiempo de compilación:

enum {fieldsAmount = sizeof(OperatorData)/sizeof(OperatorData::m_record_0)}; 

un mensaje

y los informes del compilador como:

Error: #245: a nonstatic member reference must be relative to a specific object 
    enum{fieldsAmount = sizeof(OperatorData)/sizeof(OperatorData::m_record_0)}; 
                   ^

utilizo Keil uVision3 V3.60. No importa dónde coloque la declaración enum dentro o fuera de la estructura. ¿Por qué no puede el compilador tomar el tamaño de este membmer?

Answer 1

Parece que su compilador no admite C++ 11 que permite el uso de Type::member en expresiones no evaluadas.Vas a tener que fabricar una expresión del tipo correcto, algo así como:

OperatorData* noImpl(); 

enum{fieldsAmount = sizeof(OperatorData)/sizeof(noImpl()->m_record_0)}; 

Answer 2

Esto es porque m_record_0 no es un miembro estático de la estructura OperatorData. Solo puedes hacer eso cuando es un miembro estático.

Answer 3

Crea un objeto de tu estructura y usa el operador sizeof() en él.

Answer 4

No creo que esto sea seguro; puede haber relleno añadido entre o después de los miembros, que se incluirá en sizeof (OperatorData) pero no en el tamaño de ningún miembro específico.

Por supuesto, usted podría utilizar el valor ya disponible RIX_OPERATOR_CONFIG_SIZE para obtener una aproximación:

const size_t num_records = sizeof (OperatorData)/RIX_OPERATOR_CONFIG_SIZE; 

suponiendo que sólo se usa para char matrices, y que los enanos cualquier relleno.

También puede utilizar offsetof(), esto tiene la ventaja de incluir al menos relleno entre los miembros:

const size_t num_records = sizeof (OperatorData)/
     (offsetof(OperatorData, m_record_1) - offsetof(OperatorData, m_record_0)); 

nota, de nuevo, que esto también es sólo una aproximación. Con suerte, cualquier relleno será mucho más pequeño que los propios miembros para que su contribución se redondeará.

Answer 5

No se puede acceder a un miembro no estático mediante el operador ::.

En C++ 11, se puede hacer esto (quick demo):

#include <utility> 

size = sizeof(OperatorData)/sizeof(std::declval<OperatorData>().m_record_0); 

Y en C++ 03, haga lo siguiente:

size = sizeof(OperatorData)/sizeof(((OperatorData*)(0))->m_record_0); 

El tipo de la expresión ((OperatorData*)(0)) es OperatorData* , así que uso ((OperatorData*)(0))->m_record_0 para obtener el tamaño que es más o menos equivalente a esto:

OperatorData* od = ((OperatorData*)(0)); 
size_t size = sizeof(od->m_record_0); 

Pero no es exactamente lo mismo, ya que la declaración anterior se ejecutará, pero la expresión en sizeof() no se ejecutará.

Answer 6

Use typedefs:

typedef char RecordType[RIX_OPERATOR_CONFIG_SIZE]; 

struct OperatorData 
{ 
    RecordType m_record_0; 
    RecordType m_record_1; 
    //.... 
    RecordType m_record_9; 
}; 

continuación:

enum {fieldsAmount = sizeof(OperatorData)/sizeof(RecordType)}; 

Answer 7

primero hay que establecer la alineación correcta utilizando compiladores pragmas (http://msdn.microsoft.com/en-us/library/2e70t5y1(v=vs.80).aspx en Visual Studio, http://gcc.gnu.org/onlinedocs/gcc/Structure_002dPacking-Pragmas.html en gcc) de lo contrario sizeof(OperatorData) puede ser cualquier cosa.

Entonces usted tiene que tener una instancia de OperatorData desde el que se recoge los registros y utilizarlos en sizeof()