Alias ​​de puntero estricto: ¿alguna solución para un problema específico?

Question

Tengo un problema causado por romper la regla de alias de puntero estricta. Tengo un tipo T que viene de una plantilla y un tipo integral Int del mismo tamaño (como con sizeof). Mi código hace esencialmente las siguientes:

T x = some_other_t; 
if (*reinterpret_cast <Int*> (&x) == 0) 
    ... 

Debido a que es un poco de T arbitrario (que no sea la restricción de tamaño) tipo que pudiesen tener un constructor, no puedo hacer una unión de T y Int. (Esto solo está permitido en C++ 0x y aún no es compatible con GCC).

¿Hay alguna manera de reescribir el pseudocódigo anterior para preservar la funcionalidad y evitar romper la regla de aliasing estricta? Tenga en cuenta que esta es una plantilla, no puedo controlar T o el valor de some_other_t; la asignación y la comparación posterior ocurren dentro del código de plantilla.

(Para el registro, el código anterior empezó a romper en GCC 4.5 si T contiene ningún campos de bits.)

Answer 1

static inline int is_T_0(const T *ob) 
{ 
     int p; 
     memcpy(&p, ob, sizeof(int)); 
     return p == 0; 
} 

void myfunc(void) 
{ 
    T x = some_other_t; 
    if (is_T_0(&x)) 
     ... 

En mi sistema, GCC optimiza la distancia tanto is_T_0() y memcpy(), lo que resulta en tan sólo unas pocas instrucciones de montaje en myfunc().

Answer 2

¿Qué tal esto:

Int zero = 0; 
T x = some_other_t; 
if (std::memcmp(&x, &zero, sizeof(zero)) == 0) 

puede que no sea tan eficiente, pero debería deshacerse de la advertencia.

---

ADDENDUM # 1:

Desde T está restringida a ser del mismo tamaño que Int, te haces un valor ficticio bit a bit cero del tipo T y comparar directamente contra ella (en lugar de la fundición y la comparación de Agaist Int(0))

Si su programa es de un solo subproceso, usted podría tener algo como esto:

template <typename T> 
class Container 
{ 
public: 
    void foo(T val) 
    { 
     if (zero_ == val) 
     { 
      // Do something 
     } 
    } 

private: 
    struct Zero 
    { 
     Zero() {memset(&val, 0, sizeof(val));} 
     bool operator==(const T& rhs) const {return val == rhs;} 
     T val; 
    }; 
    static Zero zero_; 
}; 

Si es multi-hilo, tendrá que evitar el uso de un miembro estático zero_, y que cada instancia del contenedor mantenga su propio miembro de zero_:

template <typename T> 
class MTContainer 
{ 
public: 
    MTContainer() {memset(zero_, 0, sizeof(zero_));} 

    void foo(T val) 
    { 
     if (val == zero_) 
     { 
      // Do something 
     } 
    } 

private: 
    T zero_; 
}; 

---

ADDENDUM # 2:

me deja poner por encima de la adenda en otra, manera más sencilla:

// zero is a member variable and is inialized in the container's constructor 
T zero; 
std::memset(&zero, 0, sizeof(zero)); 

T x = some_other_t; 
if (x == zero) 

Answer 3

¿Ha oído hablar de boost::optional?

Debo admitir que no tengo claro el problema real aquí ... pero boost :: optional permite almacenar por valor y aún saber si la memoria real se ha inicializado o no. También permití la construcción y la destrucción, así que podría ser una buena opción, supongo.

EDITAR:

Creo que finalmente comprendido el problema: usted quiere ser capaz de asignar una gran cantidad de objetos, en varios puntos de la memoria, y que le gustaría saber si la memoria o no en este punto realmente tiene un objeto o no.

Lamentablemente su solución tiene un gran problema: es incorrecta. Si alguna vez T se puede representar de alguna manera mediante un patrón de bits null, entonces creerá que se trata de una memoria unificada.

Tendrá que recurrir a sí mismo para agregar al menos un poco de información. En realidad no es mucho, después de todo, es solo un 3% de crecimiento (33 bits para 4 bytes).

Podría, por ejemplo, utilizar algunos mimick boost::optional pero en forma de matriz (para evitar la pérdida de relleno).

template <class T, size_t N> 
class OptionalArray 
{ 
public: 


private: 
    typedef unsigned char byte; 

    byte mIndex[N/8+1]; 
    byte mData[sizeof(T)*N]; // note: alignment not considered 
}; 

Entonces es tan simple como eso:

template <class T, size_t N> 
bool OptionalArray<T,N>::null(size_t const i) const 
{ 
    return mIndex[i/8] & (1 << (i%8)); 
} 

template <class T, size_t N> 
T& OptionalArray<T,N>::operator[](size_t const i) 
{ 
    assert(!this->null(i)); 
    return *reinterpret_cast<T*>(mData[sizeof(T)*i]); 
} 

nota: Por razones de simplicidad no he considerado la cuestión de la alineación. Si no sabe sobre el tema, lea sobre él antes de juguetear con la memoria :)

Answer 4

Utilice una computadora de 33 bits. ;-P

Answer 5

Se siente como un truco, pero al parecer encontré una solución: usando volatile para Int de fundición. En esencia, lo que estoy haciendo ahora es:

T x = some_other_t; 
if (*reinterpret_cast <volatile Int*> (&x) == 0) 
    ... 

El problema con el campo de bits T se ha ido. Aún así, no me siento muy feliz por esto como volatile no está bien definido en C++ que yo sepa ...

Answer 6

Por qué no simplemente:

const Int zero = 0; 
if (memcmp(&some_other_t, &zero, sizeof(zero)) == 0) 
    /* some_other_t is 0 */ 

(es posible que desee para tratar de añadir también el calificador static a zero para ver si se hace una en cuanto al rendimiento de diferencia)