Asignar valores a un struct sabiendo el tamaño pero no los campos

[marvicekl]

Hola

Tengo una duda, y tampoco se muy bien como buscar para encontrar alguna solución.

Tengo que asignar a un struct, del que no se que campos tiene pero si su tamaño valores hexadecimales.
Un ejemplo seria:

struct estructura{
int campo1;
int campo2;
}
//yo no sabria como esta construida la estructura, solo tengo la variable est1

void main(){
estructura est1;
}

los datos que tengo tienen el siguiente formato:

object 0: : name: 'est1'
object 0: size: 8
object 0: data: '\x01\x00\x00\x00\x00\x00\x00\x00'

Lo que quiero es asignar el valor en hexadecimal a la estructura
¿Alguien sabria como se puede hacer correctamente?

No se exactamente en el orden que los obtengo ahora mismo, pero si supiera como introducir el valor al struct podria saber el orden facilmente

muchas gracias

[sam90]

Imaginamos uqe cargaste los datos en las sigueinte dos variables:

int size;
unsigned char * bytes;

Utilizo un unsigned char porque tiene el mismo tamaño que un hexadecimal de dos digitos (8 digitos).

Una vez que tiense eso puedes hacer lo sigueinte.

estructura est1;
char * buf = &est1;

for(i = 0 ; i < size ; i ++) buf[i] = bytes [i];

Ten en cuenta que el copiado no puede ser perfecto pero eso modificaria la estructura....Cada compilador puede cambiar el orden de los campos asi que no seria portable esta operacion.

[marvicekl]

En realidad voy a tener varias estructuras, de diferentes tamaños, tendria que hacerlo para cualquier tamaño
No tiene por que ser de tamaño 8, pero supongo que simplemente haciendolo con un array de chars, para poder declararlo cada vez con el tamaño que necesite seria suficiente, pero:

¿como introduzco los datos exadecimales en el array? ¿Para que despues se asignen correctamente?

muchas gracias por la respuesta, creo que me servira de mucha ayuda

[sam90]

Mira este ejemplo del scanf, al final de todo lee un hexadecimal:

http://www.cplusplus.com/reference/c.../cstdio/scanf/

[Fw190]

Bastaría con un array de chars que apunte a la estructura.
Para introducir los datos:

Código C:

char *dir_estructura;
int i, n;
 
dir_estructura = (char *)&estructura;
 
for (i=0; i<TAM_ESTRUCTURA; i++)
{
  scanf("%x", &n);
  dir_estructura[i] = (char)n;
}
 

Con esto, sobreescribes la estructura con los valores que vayas introduciendo.

[marvicekl]

Muchas gracias
mi codigo al final quedo asi:
Code: [Select]

typedef struct{
int x;
int y;
} estructura;

int main(){
estructura est1;
int size=8;
char *buf = (char *)&est1;
char data_klee[size];
data_klee[0]=0x01;
data_klee[1]=0x00;
data_klee[2]=0x00;
data_klee[3]=0x00;
data_klee[4]=0x10;
data_klee[5]=0x00;
}
aunque creo que deberia poderse hacer de una forma mas sencilla, esto funciona
Muchas gracias por la ayuda

[sam90]

Que mas sencinllo que eso queres?? Que es lo que estabas buscando...

[marvicekl]

Hola otra vez,

pues es que debo realizar esta operacion en un codio autogenerado, que es extremadamente complicado de entender por los usuarios, por lo tanto deberia de intentar hacerlo lo mas sencillo posible,

mis tutores me han dicho que deberia poder asignarlo directamente al array segun recibo la informacion:
'\x01\x00\x00\x00\x00\x00\x00\x00'

pero yo lo he intentado y creo que no se puede (vamos que lo mas sencillo es lo que me habeis comentado)
De momento es lo que tengo funcionando
Muchas gracias

[marvicekl]

Bueno finalmente tengo otra solucion:

memcpy(&estructura1,"\x00\x00\x00\x00\x00\x00\x00\ x00",8);

El posible problema de usar esto seria que si se compila en otra maquina la representacion podria ser distinta,

asi que aprovecho para preguntar sobre esto: ya que tengo que documentar el problema de forma tecnica

alguien sabe donde puedo leer sobre distintas representaciones en distintas maquinas o el riesgo de usar memcpy

No se si quizas ya ha pasado demasiado tiempo, pero muchas gracias de antemano

[Fw190]

memcpy es estándar, simplemente copia el número de bytes que se indique de la fuente al destino, tal cual. En ese sentido no debe haber problemas al compilar en otra máquina. Ünicamente hay que tener en cuenta que los bloques de memoria de origen y de destino no deben solaparse, en tal caso el comportamiento no está definido. Si hay solapamiento, debe utilizarse la función memmove.

Problemas que pueden presentarse:

- Con las cadenas de caracteres no hay problema, se guardan tal cual.

- Con los números, ya sean enteros o en coma flotante, depende del tipo de máquina. Las que tienen el formato llamado Little-endian (procesadores INTEL, por ejemplo) guardan en primer lugar el byte menos significativo, y el más significativo al final. Las que tienen el formato llamado Big-endian (procesadores Motorola, por ejemplo) guardan en primer lugar el byte más significativo, y el menos significativo al final. Así, por ejemplo, el número 1000 (hexadecimal 03E8), como número entero de 32 bits, se guardará como E8 03 00 00 en una máquina INTEL, y como 00 00 03 E8 en una máquina Motorola. Lo mismo ocurre con el orden de los bytes de los números en coma flotante (sean del tipo que sean). Esto también afecta a estructuras que correspondan a campos de bits.

- Puede haber diferencias con los modos de utilizar las direcciones. Por ejemplo, en un sistema operativo de 16 bits las direcciones de comienzo de las variables suelen ser múltiplos de 2, y en uno de 32 bits suelen ser múltiplos de 4, con lo que podría haber espacio sin utilizar. Dependiendo del sistema operativo y del compilador, sería posible "empaquetar" las variables y que comenzasen en direcciones "extrañas", a costa de la velocidad. Por ejemplo, los compiladores Borland para MS-DOS permitían esto (optimización para espacio).

Así al pronto no se me ocurren más, si tienes alguna otra duda ya sabes dónde estamos.

Saludos,