Duda que me surge con una estructura y una union.-

[remi04]

Tengo esta estructura y union:

 

Código: C

1. struct vmonit {                    
2.     int1 _bit0;      
3.     int1 _bit1;      
4.     int1 _bit2;      
5.     int1 _bit3;    
6.     int1 _bit4;      
7.     int1 _bit5;      
8.     int1 _bit6;      
9.     int1 _bit7;      
10. } ;
11.  
12. union  {                          
13.     struct vmonit bitmonitor;            
14.     int8 bytemonitor;        
15. }monitor;

 
Si yo quiero asignar un valor entero, por ejemplo, el 10 a bytemonitor de una sola vez lo haría así:

 

Código: C

1. monitor.bytemonitor = 10;

  Al hacer eso, entiendo que lo que sucede no es solo que la variable bytemonitor adquiera el valor 10, sino que además, las variables, bit3, bit2,bit1, y bit0 de la estructura unida adquieren automáticamente los valores 1 0 1 0 respectivamente.

  La pregunta es, ¿estoy en lo cierto?.

    Y de estar en lo cierto:

 Si yo ahora hago esto:

Código: C

1. monitor.bitmonitor.bit7 = 1;

  El valor de la variable Bytemonitor ahora sería 138  " 0b10001010??

La union, al asignar un valor a su variable, ¿la modifica en la estructura por orden de elementos/posición de memoria?, como si fuese un puntero al primer elemento??.

   Esta ultima pregunta surge por que si en esta estructura, añado otra variable más, por ejemplo, un entero de 8 bits dejandola así:

Código: C

1. struct vmonit {                    
2.     int1 _bit0;      
3.     int1 _bit1;      
4.     int1 _bit2;      
5.     int1 _bit3;    
6.     int1 _bit4;      
7.     int1 _bit5;      
8.     int1 _bit6;      
9.     int1 _bit7;    
10.     int8 myvariable;  
11. } ;

En este caso, al asignarle valor a la variable de la unión, ¿que sucedería con la de 8 bits myvariable?. 
 Un saludo.

[remi04]

Bueno, me respondo a mi mismo.

  He estado haciendo pruebas con el debbuger del mplab y lo que veo es que si la variable de la unión es de 8 bits, al modificar esa variable se modifican los 8 primeros bits de la estructura unida por orden, por lo que la variable de 8 bits que añadí al final de la estructura queda intacta.

  Pero si meto en la unión una variable de 16 bits y la asigno un valor, los 8 bits de menos peso van a los 8 primeros bits de la estructura y para los otros 8 bits restantes entonces ya si le mete mano a la variable que añadí abajo y se los asigna a esta en su byteLSB.

  Entonces confirmado. Es un puntero a la primera posición de memoria de la estructura y va asignando por orden estricto.

  También me ha dado por probar, que sucede si meto mas variables en la union. Pues que todas adquieren el mismo valor. Cambies la que cambies, todas asumen el mismo valor.

  Pues nada, mas cositas aprendidas en esta cuarentena.

 

[KILLERJC]

No se a donde estas queriendo llegar... Pero solo una cosa a dejarte claro.

https://wiki.sei.cmu.edu/confluence/display/c/EXP11-C.+Do+not+make+assumptions+regarding+the+layout+of+structures+with+bit-fields

Y son estos dos puntos:

The internal representations of bit-field structures have several properties (such as internal padding) that are implementation-defined.
The alignment of bit-fields in the storage unit (for example, the bit-fields may be allocated from the high end or the low end of the storage unit)

No podes asumir nunca bit7 donde esta ubicado sea el bit 7 del int8 con la union, y tal ves sea el bit 1 de ese int8.
Ya que todo depende del compilador, te moves de compilador y puede cambiar el funcionamiento como te lo comente.

Ya pasando los 8 bits, el padding tambien es de implementacion del compilador, por lo que tampoco te podes "confiar" en que van a estar todo seguido, y no sabes exactamente donde van a poner los paddings, en tu caso no hay demasiado efecto, ya que son 8 bits. Pero es a tener en cuenta.


En fin, mejor intentar asegurarse de que funcione si o si a donde lo lleves y no confiarse de que siempre va a ser asi.
En esa pagina que pase tenes mas ejemplos.

[remi04]

Ahi es a donde quería llegar, a comprender como funcionan las estructuras internamente.  Si son al final punteros a datos ordenados como si fuese un array común, o si como has dicho, no se puede garantizar que así sea siempre.


 Pues nada. Mejor implemento los accesos a bits independientes con operadores de bit y mas seguro.

 Gracias...