elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Trabajando con las ramas de git (tercera parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Cadena de bytes a string
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Cadena de bytes a string  (Leído 2,932 veces)
85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Cadena de bytes a string
« en: 22 Febrero 2013, 03:51 am »

Bueno , en realidad el título puede que no lo exprese tal como es..
En este tema alguien había preguntado cómo se pasaba de un array de bytes a convertirlo en un array de chares por decirlo así, y la operación inversa también.
http://foro.elhacker.net/programacion_cc/variable_char_a_byte-t383683.0.html

Entonces usando una lógica que suelo utilizar, lo que hice fue crear una tabla con los 256 bytes, en realidad dos tablas. Una para obtener los bytes y la otra para obtener la posición de un byte en la tabla.
Luego de eso fue tan sólo crear 2 funciones separadas que hagan las operaciones, la una y la inversa, y probarlo

Código:
/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////
/////////////////////////////////////

char* hextabla[] = { //256 BYTES
"00","01","02","03","04","05","06","07","08","09",
"0A","0B","0C","0D","0E","0F","10","11","12","13",
"14","15","16","17","18","19","1A","1B","1C","1D",
"1E","1F","20","21","22","23","24","25","26","27",
"28","29","2A","2B","2C","2D","2E","2F","30","31",
"32","33","34","35","36","37","38","39","3A","3B",
"3C","3D","3E","3F","40","41","42","43","44","45",
"46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59",
"5A","5B","5C","5D","5E","5F","60","61","62","63",
"64","65","66","67","68","69","6A","6B","6C","6D",
"6E","6F","70","71","72","73","74","75","76","77",
"78","79","7A","7B","7C","7D","7E","7F","80","81",
"82","83","84","85","86","87","88","89","8A","8B",
"8C","8D","8E","8F","90","91","92","93","94","95",
"96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9",
"AA","AB","AC","AD","AE","AF","B0","B1","B2","B3",
"B4","B5","B6","B7","B8","B9","BA","BB","BC","BD",
"BE","BF","C0","C1","C2","C3","C4","C5","C6","C7",
"C8","C9","CA","CB","CC","CD","CE","CF","D0","D1",
"D2","D3","D4","D5","D6","D7","D8","D9","DA","DB",
"DC","DD","DE","DF","E0","E1","E2","E3","E4","E5",
"E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9",
"FA","FB","FC","FD","FE","FF",
};
//////////////

BYTE poshextabla[] = { //256 BYTES
/*1*/(BYTE)'\x00',(BYTE)'\x01',(BYTE)'\x02',(BYTE)'\x03',(BYTE)'\x04',(BYTE)'\x05',(BYTE)'\x06',(BYTE)'\x07',(BYTE)'\x08',(BYTE)'\x09',
/*2*/(BYTE)'\x0A',(BYTE)'\x0B',(BYTE)'\x0C',(BYTE)'\x0D',(BYTE)'\x0E',(BYTE)'\x0F',(BYTE)'\x10',(BYTE)'\x11',(BYTE)'\x12',(BYTE)'\x13',
/*3*/(BYTE)'\x14',(BYTE)'\x15',(BYTE)'\x16',(BYTE)'\x17',(BYTE)'\x18',(BYTE)'\x19',(BYTE)'\x1A',(BYTE)'\x1B',(BYTE)'\x1C',(BYTE)'\x1D',
/*4*/(BYTE)'\x1E',(BYTE)'\x1F',(BYTE)'\x20',(BYTE)'\x21',(BYTE)'\x22',(BYTE)'\x23',(BYTE)'\x24',(BYTE)'\x25',(BYTE)'\x26',(BYTE)'\x27',
/*5*/(BYTE)'\x28',(BYTE)'\x29',(BYTE)'\x2A',(BYTE)'\x2B',(BYTE)'\x2C',(BYTE)'\x2D',(BYTE)'\x2E',(BYTE)'\x2F',(BYTE)'\x30',(BYTE)'\x31',
/*6*/(BYTE)'\x32',(BYTE)'\x33',(BYTE)'\x34',(BYTE)'\x35',(BYTE)'\x36',(BYTE)'\x37',(BYTE)'\x38',(BYTE)'\x39',(BYTE)'\x3A',(BYTE)'\x3B',
/*7*/(BYTE)'\x3C',(BYTE)'\x3D',(BYTE)'\x3E',(BYTE)'\x3F',(BYTE)'\x40',(BYTE)'\x41',(BYTE)'\x42',(BYTE)'\x43',(BYTE)'\x44',(BYTE)'\x45',
/*8*/(BYTE)'\x46',(BYTE)'\x47',(BYTE)'\x48',(BYTE)'\x49',(BYTE)'\x4A',(BYTE)'\x4B',(BYTE)'\x4C',(BYTE)'\x4D',(BYTE)'\x4E',(BYTE)'\x4F',
/*9*/(BYTE)'\x50',(BYTE)'\x51',(BYTE)'\x52',(BYTE)'\x53',(BYTE)'\x54',(BYTE)'\x55',(BYTE)'\x56',(BYTE)'\x57',(BYTE)'\x58',(BYTE)'\x59',
/*10*/(BYTE)'\x5A',(BYTE)'\x5B',(BYTE)'\x5C',(BYTE)'\x5D',(BYTE)'\x5E',(BYTE)'\x5F',(BYTE)'\x60',(BYTE)'\x61',(BYTE)'\x62',(BYTE)'\x63',
/*11*/(BYTE)'\x64',(BYTE)'\x65',(BYTE)'\x66',(BYTE)'\x67',(BYTE)'\x68',(BYTE)'\x69',(BYTE)'\x6A',(BYTE)'\x6B',(BYTE)'\x6C',(BYTE)'\x6D',
/*12*/(BYTE)'\x6E',(BYTE)'\x6F',(BYTE)'\x70',(BYTE)'\x71',(BYTE)'\x72',(BYTE)'\x73',(BYTE)'\x74',(BYTE)'\x75',(BYTE)'\x76',(BYTE)'\x77',
/*13*/(BYTE)'\x78',(BYTE)'\x79',(BYTE)'\x7A',(BYTE)'\x7B',(BYTE)'\x7C',(BYTE)'\x7E',(BYTE)'\x7F',(BYTE)'\x80',(BYTE)'\x81',(BYTE)'\x82',
/*14*/(BYTE)'\x83',(BYTE)'\x84',(BYTE)'\x85',(BYTE)'\x86',(BYTE)'\x87',(BYTE)'\x88',(BYTE)'\x89',(BYTE)'\x8A',(BYTE)'\x8B',(BYTE)'\x8C',
/*15*/(BYTE)'\x8D',(BYTE)'\x8E',(BYTE)'\x8F',(BYTE)'\x90',(BYTE)'\x91',(BYTE)'\x92',(BYTE)'\x93',(BYTE)'\x94',(BYTE)'\x95',(BYTE)'\x96',
/*16*/(BYTE)'\x97',(BYTE)'\x98',(BYTE)'\x99',(BYTE)'\x9A',(BYTE)'\x9B',(BYTE)'\x9C',(BYTE)'\x9D',(BYTE)'\x9E',(BYTE)'\x9F',(BYTE)'\xA0',
/*17*/(BYTE)'\xA1',(BYTE)'\xA2',(BYTE)'\xA3',(BYTE)'\xA4',(BYTE)'\xA5',(BYTE)'\xA6',(BYTE)'\xA7',(BYTE)'\xA8',(BYTE)'\xA9',(BYTE)'\xAA',
/*18*/(BYTE)'\xAB',(BYTE)'\xAC',(BYTE)'\xAD',(BYTE)'\xAE',(BYTE)'\xAF',(BYTE)'\xB0',(BYTE)'\xB1',(BYTE)'\xB2',(BYTE)'\xB3',(BYTE)'\xB4',
/*19*/(BYTE)'\xB5',(BYTE)'\xB6',(BYTE)'\xB7',(BYTE)'\xB8',(BYTE)'\xB9',(BYTE)'\xBA',(BYTE)'\xBB',(BYTE)'\xBC',(BYTE)'\xBD',(BYTE)'\xBE',
/*20*/(BYTE)'\xBF',(BYTE)'\xC0',(BYTE)'\xC1',(BYTE)'\xC2',(BYTE)'\xC3',(BYTE)'\xC4',(BYTE)'\xC5',(BYTE)'\xC6',(BYTE)'\xC7',(BYTE)'\xC8',
/*21*/(BYTE)'\xC9',(BYTE)'\xCA',(BYTE)'\xCB',(BYTE)'\xCC',(BYTE)'\xCD',(BYTE)'\xCE',(BYTE)'\xCF',(BYTE)'\xD0',(BYTE)'\xD1',(BYTE)'\xD2',
/*22*/(BYTE)'\xD3',(BYTE)'\xD4',(BYTE)'\xD5',(BYTE)'\xD6',(BYTE)'\xD7',(BYTE)'\xD8',(BYTE)'\xD9',(BYTE)'\xDA',(BYTE)'\xDB',(BYTE)'\xDC',
/*23*/(BYTE)'\xDD',(BYTE)'\xDE',(BYTE)'\xDF',(BYTE)'\xE0',(BYTE)'\xE1',(BYTE)'\xE2',(BYTE)'\xE3',(BYTE)'\xE4',(BYTE)'\xE5',(BYTE)'\xE6',
/*24*/(BYTE)'\xE7',(BYTE)'\xE8',(BYTE)'\xE9',(BYTE)'\xEA',(BYTE)'\xEB',(BYTE)'\xEC',(BYTE)'\xED',(BYTE)'\xEE',(BYTE)'\xEF',(BYTE)'\xF0',
/*25*/(BYTE)'\xF1',(BYTE)'\xF2',(BYTE)'\xF3',(BYTE)'\xF4',(BYTE)'\xF5',(BYTE)'\xF6',(BYTE)'\xF7',(BYTE)'\xF8',(BYTE)'\xF9',(BYTE)'\xFA',
/*26*/(BYTE)'\xFB',(BYTE)'\xFC',(BYTE)'\xFD',(BYTE)'\xFE',(BYTE)'\xFF'
};

/////

El usuario ingresa una array de bytes y la función arregla el resultado en una cadena de chares, lo hace por medio de buscar en una tabla diseñada específicamente para esta situación.
Código:
void Test1(){ //Cadena de bytes a string

BYTE* cadena_de_bytes = (BYTE*)"\x68\x68\x68\x68\x68\x68\xFF\xFF\xFF\xFF\x69";
int largo_de_la_cadena_de_bytes = strlen( (char*)cadena_de_bytes);
char* cadena_de_bytes_en_formato_string = (char*)"000000000000000000000\0";
int pos_string=0;

int i;
for(i=0; i<largo_de_la_cadena_de_bytes; i++)
{
for(int j=0; j<256; j++)
{
if(cadena_de_bytes[i] == poshextabla[j])
{
int pos = j;
for(int k=0;k<2;k++){
cadena_de_bytes_en_formato_string[pos_string++]=hextabla[pos][k];
}
}
}
}
printf(cadena_de_bytes_en_formato_string);
printf("\n");
system("pause");
}

//////////

El usuario ingresa una cadena con números que representan bytes,
la función convierte la cadena a un array de bytes.

Código:
void Test2(){//String a cadena de bytes

char* cadena_de_bytes = (char*)"686868686868FFFFFFFF69\0";
BYTE* cadena_de_bytes_resultante = (BYTE*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
int largo_de_la_cadena_de_bytes = strlen( cadena_de_bytes);
int pos_bytes=0;

int i;
for(i=0; i<largo_de_la_cadena_de_bytes; i+=2)
{
for(int j=0; j<256; j++)
{
if(cadena_de_bytes[i] == hextabla[j][0] && cadena_de_bytes[i+1] == hextabla[j][1])
{
int pos = j;

cadena_de_bytes_resultante[pos_bytes++]=poshextabla[pos];
}
}
}

for(int x=0; x<largo_de_la_cadena_de_bytes/2; x++){
printf("%X",*(cadena_de_bytes_resultante+x));
}
printf("\n");
system("pause");
}

///////

Código:
int main(){


Test1();
Test2();

return 0;
}

voy a dejar el proyecto en MSVCPP 6
DESCARGA

está listo para compilar en modo 'Release', pero si sólo quitan el archivo .cpp para usarlo en otro compilador, compilen en modo Release también..

//////////////////////////////////////////////////////////////////////

EDITADO:

Debido a que mi código dejó de ser algo didáctico para ser criticado por ser costoso con la utilización de recursos, entonces lo que hice fue simplificar mi código siguiendo la misma lógica con la cual venía trabajando.

Ahora sólo se dispone de una tabla, dicha tabla se usa como lookup en la primera función y en la segunda se requiere recorrerla pero no más de lo necesario.


atte

Código:
/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>

/////
/////////////////////////////////////

char* hextabla[] = { //256 BYTES
"00","01","02","03","04","05","06","07","08","09",
"0A","0B","0C","0D","0E","0F","10","11","12","13",
"14","15","16","17","18","19","1A","1B","1C","1D",
"1E","1F","20","21","22","23","24","25","26","27",
"28","29","2A","2B","2C","2D","2E","2F","30","31",
"32","33","34","35","36","37","38","39","3A","3B",
"3C","3D","3E","3F","40","41","42","43","44","45",
"46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59",
"5A","5B","5C","5D","5E","5F","60","61","62","63",
"64","65","66","67","68","69","6A","6B","6C","6D",
"6E","6F","70","71","72","73","74","75","76","77",
"78","79","7A","7B","7C","7D","7E","7F","80","81",
"82","83","84","85","86","87","88","89","8A","8B",
"8C","8D","8E","8F","90","91","92","93","94","95",
"96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9",
"AA","AB","AC","AD","AE","AF","B0","B1","B2","B3",
"B4","B5","B6","B7","B8","B9","BA","BB","BC","BD",
"BE","BF","C0","C1","C2","C3","C4","C5","C6","C7",
"C8","C9","CA","CB","CC","CD","CE","CF","D0","D1",
"D2","D3","D4","D5","D6","D7","D8","D9","DA","DB",
"DC","DD","DE","DF","E0","E1","E2","E3","E4","E5",
"E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9",
"FA","FB","FC","FD","FE","FF",
};


Código:

void Test1(BYTE* array_de_bytes, char* cadena_de_bytes_en_formato_string){ //Cadena de bytes a string

for(int i=0; i<(int)strlen( (char*)array_de_bytes); i++)
strcat(cadena_de_bytes_en_formato_string,hextabla[(int)array_de_bytes[i]]);
printf(cadena_de_bytes_en_formato_string);
printf("\n");
}

//////////

void Test2(char* cadena_de_bytes, BYTE* cadena_de_bytes_resultante){//String a cadena de bytes

int bytes=0;
for(int i=0; i<(int)strlen( cadena_de_bytes); i+=2){
for(int j=0; j<256; j++){
if( cadena_de_bytes[i]==hextabla[j][0] && cadena_de_bytes[i+1]==hextabla[j][1] ){
cadena_de_bytes_resultante[bytes++]=j;
j=256;
}
}
}
for(int x=0; x<(int)strlen( cadena_de_bytes)/2; x++)
printf("%X",*(cadena_de_bytes_resultante+x));
printf("\n");
}

///////

int main(){//Programa

BYTE* array_de_bytes = (BYTE*)"\x68\x68\x68\x68\x68\x68\xFF\xFF\xFF\xFF\x69";
char cadena_de_bytes_en_formato_string[256];
memset(cadena_de_bytes_en_formato_string,0,sizeof(cadena_de_bytes_en_formato_string));
printf("TEST1:\n");
Test1(array_de_bytes, cadena_de_bytes_en_formato_string);
system("pause");

char* cadena_de_bytes = (char*)"686868686868FFFFFFFF69\0";
BYTE* cadena_de_bytes_resultante = (BYTE*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
printf("TEST2:\n");
Test2(cadena_de_bytes, cadena_de_bytes_resultante);
system("pause");

return 0;
}


« Última modificación: 22 Febrero 2013, 19:03 pm por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: Cadena de bytes a string
« Respuesta #1 en: 22 Febrero 2013, 16:02 pm »

Algunos comentarios que espero se tomen como una critica constructiva.

Cuando se utilizan tablas de valores es por eficiencia, para obtener (que mas) un valor en tiempo constante en lugar de realizar una búsqueda.

Dos problemas en tu programa son: en la primera función la tabla no es necesaria porque el byte se puede descomponer utilizando los operadores de división y modulo. En la segunda función la tabla si es necesaria pero no realizas un "lookup", es su lugar realizas una búsqueda secuencial y esta es la de mayor costo (en comparación con otras).

En base a lo anterior el programa se puede reducir a:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. void to_str(void);
  6. void to_char(void);
  7.  
  8. int main(void)
  9. {
  10.   to_str();
  11.   to_char();
  12.  
  13.   return EXIT_SUCCESS;
  14. }
  15.  
  16. void to_str(void)
  17. {
  18.   const unsigned char *in = "\x68\x68\x68\x68\x68\x68\xFF\xFF\xFF\xFF\x69";
  19.   int i;
  20.  
  21.   for (i = 0; in[i] != '\0'; i++){
  22.      putchar("0123456789ABCDEF"[in[i] / 16]);
  23.      putchar("0123456789ABCDEF"[in[i] % 16]);
  24.   }
  25.   putchar('\n');
  26. }
  27.  
  28. void to_char(void)
  29. {
  30.   unsigned char val[UCHAR_MAX] = {0};
  31.   char digit[] = "0123456789ABCDEF";
  32.  
  33.   char in[] = "686868686868FFFFFFFF69";
  34.   unsigned char out[sizeof in / 2];
  35.   int i;
  36.  
  37.   for (i = 1; digit[i] != '\0'; i++)
  38.      val[digit[i]] = i;
  39.  
  40.   for (i = 0; in[i] != '\0'; i += 2){
  41.      out[i / 2] = val[in[i]] * 16 + val[in[i + 1]];
  42.   }
  43.  
  44.   for (i = 0; i < (int) sizeof out; i++)
  45.      printf("%X", out[i]);
  46.   putchar('\n');
  47. }

Otra opción es utilizar las funciones de la biblioteca estándar de C como sprintf, sscanf, etc.

Un saludo


En línea

C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Re: Cadena de bytes a string
« Respuesta #2 en: 22 Febrero 2013, 17:19 pm »

Hola,
En verdad mi código no tiene problemas, mirá yo te cuento en realidad el uso de tablas viene a razón de que muchos no saben como manejar bytes y al resultarles ilustrativo el hecho de utilizar una tabla en donde se puede observar
el proceso detalladamente.

Al mismo tiempo es reducido en cuanto a líneas de código (funciones simples pero las tablas lo hacen parecer grande) pero costoso en procesamiento debido a la búsqueda secuencial que realiza cada función por separado. Buscar en una tabla de 255 elementos contínuamente, de forma secuencial es obviamente un tanto costoso. Se puede hacer algo como cortar la búsqueda una vez que se encuentra el elemento, eso reduciría la cantidad de ciclos.
Hacer un lookup sería un acceso directo mucho mejor.
Las tablas estoy de acuerdo que su mejor utilización es cuando se las usa como lookups.

Tu código es de la misma forma reducido en líneas de código y posiblemente más rápido, aunque vemos que usás operaciones aritméticas de tipo divisorias, que dependiendo del cpu, y considerando los avances actuales en compiladores y procesadores, que tratan de reemplazar estas operaciones costosas automáticamente con otras (multiplicaciones, operaciones de bits, etc)
también se debe tomar en cuenta, no precisamente en tu código que son algunas pero no tantas.

Te dejo unos enlaces al respecto ya que es un tema que me interesaba en un proyecto anterior..
http://stackoverflow.com/questions/226465/should-i-use-multiplication-or-division
http://bytes.com/topic/c/answers/811057-how-replace-division-operator
http://www.cplusplus.com/forum/general/17811/
http://en.wikibooks.org/wiki/Optimizing_C%2B%2B/Code_optimization/Faster_operations
http://gamedev.stackexchange.com/questions/27196/which-opcodes-are-faster-at-the-cpu-level


« Última modificación: 22 Febrero 2013, 17:25 pm por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: Cadena de bytes a string
« Respuesta #3 en: 23 Febrero 2013, 17:30 pm »

Algunos comentarios sobre la función actualizada para obtener la representación en cadena:
Código
  1. void Test1(BYTE* array_de_bytes, char* cadena_de_bytes_en_formato_string){ //Cadena de bytes a string
  2. for(int i=0; i<(int)strlen( (char*)array_de_bytes); i++)
  3. strcat(cadena_de_bytes_en_formato_string,hextabla[(int)array_de_bytes[i]]);
  4. printf(cadena_de_bytes_en_formato_string);
  5. printf("\n");
  6. }
Las recomendaciones sobre lo subjetivo (estilo): dale un nombre descriptivo a la función y unos mas cortos a las variables.

Lo objetivo: no es necesario utilizar la función strlen ya que puedes conocer donde termina el array de bytes comparando contra '\0', si te preocupa que alguno de los bytes tenga ese valor entonces debes cambiar de aproximación ya que strlen tendrá el mismo problema. Lo mejor en ese escenario seria pasar el numero de bytes a procesar como un parámetro adicional.

Y si piensas utilizar la función strcat deberías colocar a cero el primer elemento del array "cadena_de_bytes_en_formato_string" (programación defensiva).

Considerando que la posición a procesar de un array define la posición en el otro una alternativa (mas) es utilizar la función sprintf mas aritmética de punteros:
Código
  1. void to_str(const unsigned char *byte, char *str)
  2. {
  3.   int i;
  4.  
  5.   for (i = 0; byte[i] != '\0'; i++)
  6.      sprintf(str + i * 2, "%02X", byte[i]);
  7. }

De nuevo espero se tome de forma constructiva.

Un saludo
En línea

C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Re: Cadena de bytes a string
« Respuesta #4 en: 24 Febrero 2013, 00:18 am »

Hola,  te cuento algo acerca de las recomendaciones, en verdad te digo que se trata de un 'Test' osea una prueba , no tanto de una publicación que intenta reemplazar una funcionalidad ya bastante conocida.
Código:
void Test1(BYTE* array_de_bytes, char* cadena_de_bytes_en_formato_string){ //Cadena de bytes a string

el nombre es parte de una prueba pero tiene el comentario que indica lo que hace, los nombres de las variables son demasiado descriptivos, la gente los va a entender mejor, al menos los principiantes..

STRLEN realmente está mal implementada en mi edición, lo raro es que no lo hayas notado, ya que dentro de un FOR está ejecutándose muchas veces, se debe utilizar como estaba antes.
Incluso STRCAT puede ser reemplazada a como se copiaba en la primera edición, pero bueno son detalles que se me escaparon.

te muestro otra solución para la función 2, en este caso no hecha por mi, pero vale igualmente

Código:
void Test2(char* cadena_de_bytes, BYTE* cadena_de_bytes_resultante)
{
static  BYTE Tabla[256] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

int Position;
int Length_de_bytes_resultante; // :)

Position = 0;
while (cadena_de_bytes[Position] != '\0')
{
cadena_de_bytes_resultante[Position >> 1] = (Tabla[cadena_de_bytes[Position]] << 4) + Tabla[cadena_de_bytes[Position + 1]];
Position = Position + 2;
}
Length_de_bytes_resultante = Position >> 1;

for (Position = 0; Position < Length_de_bytes_resultante; Position = Position + 1)
{
printf("%02X", cadena_de_bytes_resultante[Position]);
}
printf("\n");

}

Saludos
« Última modificación: 24 Febrero 2013, 00:23 am por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
pasar una cadena a un array de bytes
Programación Visual Basic
erjaker 1 1,078 Último mensaje 5 Noviembre 2007, 17:25 pm
por erjaker
Concatenar Array de bytes con string
Programación Visual Basic
Nanoc 7 8,274 Último mensaje 10 Febrero 2010, 21:54 pm
por BlackZeroX
se corta la cadena string
Programación Visual Basic
rembolso 2 1,922 Último mensaje 1 Mayo 2011, 06:13 am
por rembolso
Convertir Cadena Hex a Bytes y compararlos Con Bytes de un archivo
.NET (C#, VB.NET, ASP)
**Aincrad** 3 966 Último mensaje 14 Octubre 2018, 00:52 am
por Eleкtro
Array de Bytes a String.
.NET (C#, VB.NET, ASP)
**Aincrad** 4 950 Último mensaje 15 Mayo 2019, 21:43 pm
por Eleкtro
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines