C/Visual C - Guardar valor numerico en variable tipo char

   
Vista:

Guardar valor numerico en variable tipo char

Publicado por jaldonfer (31 intervenciones) el 23/11/2014 17:43:33
Hola:

Necesito definir una variable para almacenar un valor numérico que solamente ocupe 3 bytes ( el limite de los valores max y min está controlado ) El motivo de todo esto es porque utilizo un protocolo en el que el dato de una de sus estructuras solo puede medir tres bytes y puede contener un valor de 0 a 16777215

El tema es que en C no existen tipo de tres bytes de longitud y para ello he pensado crear una array tres bytes de tipo char y dentro de esta variable mediante un puntero guardar el valor decimal.

El problema es que realizo las operaciones, pero no tengo claro al 100% que lo este haciendo correctamente ya que al pintar los resultados por pantalla con printf y %x me saca valores de más de tres bytes.


- ¿ Esto es posible de realizar ?
- ¿ Cual es la forma correcta de hacerlo ?
- ¿ Hay alguna forma más sencilla de hacer esto ?


Gracias por su colaboración

Saludos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Guardar valor numerico en variable tipo char

Publicado por Chema (187 intervenciones) el 23/11/2014 19:19:18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define SIZEDATA (sizeof(char* ) * 3 )
 
 
typedef union Datum{
	unsigned int datum: SIZEDATA;
}Datum;
 
/* Tambien se puede realizar como estructura
typedef struct Datum{
	unsigned int datum: SIZEDATA;
}Datum;
*/
int main(void){
	int i;
	char *page;
	Datum *dat;
 
 
	page = malloc(8124);
	dat = (Datum*)page;
	for ( i = 0; i < 10; i++){
		dat->datum = i+1;
		dat++;
	}
 
	dat = (Datum*)page;
	for ( i = 0; i < 10; i++){
		printf("%d\n",dat->datum);
		dat++;
	}
 
 
	free(page);
	return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar

Guardar valor numerico en variable tipo char

Publicado por Tom (481 intervenciones) el 23/11/2014 19:51:48
Hay bastantes formas de hacerlo. Pero al final, si necesitas empaquetar en 3 bytes, lo primero que necesitas saber es el "byte order", o sea en que orden se vana interpretar esos tres bytes al otro lado.

Y yo creo que sí, lo mejor para no liarte demasiado es usar un array de 3 chars...

quizás algo así como:

1
2
3
4
5
6
7
8
9
10
11
// asumimos que buf apunta a un array de chars de al menos 3 posiciones
// y en esta maquina un tipo int es de 4 bytes
void empaqueta(char *buf, int valor) {
  buf[0] = (char)((valor & 0x00ff0000) >> 16);
  buf[1] = (char)((valor & 0x0000ff00) >> 8);
  buf[2] = (char)(valor & 0x000000ff);
}
 
int desempaqueta(char *buf) {
  return (int)((buf[0] * 512 * 512) + (buf[1] * 512) + buf[2]);
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

Guardar valor numerico en variable tipo char

Publicado por jaldonfer (31 intervenciones) el 23/11/2014 20:42:17
Hola:

Gracias a los dos por la respuesta.

Finalmente y después de probar las dos, me quedo con la de Tom. Lo único es que después de probarla, he tenido que dejarla de la siguiente forma, ya que devolvía un numero mayor del parametrizado y por otro lado a partir de cierto numero ( no recuerdo si era a partir del 255 ) , el buf[0] lo calculaba en negativo:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int desempaqueta(char *buf) {
 
	//Traza de depuración
	printf("Valor[0]: [%x]\n", buf[0] & 0x000000FF);
	printf("Valor[1]: [%x]\n", buf[1] & 0x000000FF);
	printf("Valor[2]: [%x]\n", buf[2] & 0x000000FF);
 
	//Traza de depuración
	printf("Valor[0]: [%i]\n", (int)buf[0]);
	printf("Valor[1]: [%i]\n", (int)buf[1]);
	printf("Valor[2]: [%i]\n", (int)buf[2]);
 
	//return (int)((buf[0] * 512 * 512) + (buf[1] * 512) + buf[2]);
	//return (int)((buf[0] * 256 * 256) + (buf[1] * 256) + buf[2]);
	return (int)(((buf[0] & 0x000000FF) * 256 * 256) + ((buf[1] & 0x000000FF) * 256) + (buf[2] & 0x000000FF));
	}

De todas formas, gracias a los dos ( Chema y Tom ) por la respuesta.

Me habéis ayudado a salir del paso.

Muchas Gracias
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Guardar valor numerico en variable tipo char

Publicado por Chema (187 intervenciones) el 23/11/2014 22:42:08
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define SIZEDATA (sizeof(char* ) * 3 )
typedef union Datum{
	unsigned int datum: SIZEDATA;
}Datum;
 
int main(void){
	int i;
	char *page;
	char *p;
	Datum *dat;
 
	page = malloc(8124);
 
	/*
	1 bite          2 bite      3 bite
	/---------\	/-------\   /-------\
	 0000  0001 	0000 0001   0000 0001
	 La unión de los tres bites = 65793
	 000000010000000100000001
	 
	 5 conjuntos de 3 bites (5*3;) cuyo valor individual es = 65793.
	*/
 
	for (p = page, i = 0; i < 5*3; i++){
		*p = 1; /*00000001 */
		p++;
	}
	/*
	1 bite          2 bite      3 bite
	/---------\	/-------\   /-------\
	 0000  0010 	0000 0010   0000 0010
	 La unión de los tres bites = 131586
	 000000100000001000000010
	 5 conjuntos de 3 bites (5*3;) cuyo valor individual es = 131586.
	*/
	for ( i = 0; i < 5*3; i++){
		*p = 2; /*00000010 */
		p++;
	}
 
	/*recojemos por conjunto de tres bites*/
	for (p = page, i = 0; i < 10; i++){
		dat = (Datum*)p;
		printf("%d\n",dat->datum);
		p+=3; /* la forma más sencilla de recorrer la matriz que garantiza la lectura de tres en tres*/
	}
 
	free(page);
	return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Guardar valor numerico en variable tipo char

Publicado por Tom (481 intervenciones) el 24/11/2014 09:21:33
Vaya, iba deprisa y no sé cómo se me ocurrió lo del 512. Efectivamente, un byte puede representar 256 valores.

En todo caso, además, preferiblemente usa unsigned char en lugar de char.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Guardar valor numerico en variable tipo char

Publicado por jadonfer (31 intervenciones) el 24/11/2014 09:52:33
Hola:

Muchas Gracias.

Aplico lo del unsigned char ( se me había pasado )

Saludos cordiales
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar