Bueno, este es mi primer aporte despues de mucho tiempo.
Agradezco a todos por el apoyo, especialmente al usuario "simulador" que logró lo imposible!!

Bien, dejémonos de mariconeadas y vamos a los bifes. Este es un ejemplo de como se puede implementar un split en C++.
Hay varias cosas que se pueden mejorar, como la variable "divididos" que la tuve que declarar global... ya que me daba error al querer pasarla como argumento

Les dejo el source completo (100 % codeado por mí) , probado en WxDev-C++
Sólo tienen que modificar el TOT_DATOS según el uso que se le de.

Código: Seleccionar todo

#include <iostream>
#define TOT_DATOS 3
using namespace std;

bool osnaraus_split(char *buffer,char *delimitador);
string divididos[TOT_DATOS];
int main()
{
  FILE * fp;
  long tamano;
  char * buffer;
  char *delimitador="culo"; 
  size_t result;
  
  for (int m=0;m<TOT_DATOS;m++)
    divididos[m]="";

  fp = fopen ( "C:\\archivo.exe" , "rb" );
  if (fp==NULL) exit (1);

  fseek (fp , 0 , SEEK_END);
  tamano = ftell (fp);
  rewind (fp);

 
  buffer = (char*) malloc (sizeof(char)*tamano);
  if (buffer == NULL) exit (2);

 
  result = fread (buffer,1,tamano,fp);
  if (result != tamano)  exit (3);

 if(osnaraus_split(buffer,delimitador))
    {
    for (int i=0;i<TOT_DATOS;i++)
        cout<<divididos[i]<<endl;
    }
  
  getchar();
  fclose (fp);
  free (buffer);
return 0;    
}
//--------------------------------------------------
bool osnaraus_split(char *buffer,char *delimitador)
{
    bool sigue;
    int aux;
    int i;
    long buffi=0;
    int divi=0;
    
    while (divi<TOT_DATOS)
    {
        sigue=true;
        while( (buffi<strlen(buffer)) && (sigue==true) )
        {
            aux=0;
            for (i=0;i<strlen(delimitador);i++)
            {
                if (buffer[buffi]!=delimitador[i])
                {
                    if (aux>0)
                    {
                        for (int j=0;j<aux;j++)
                        divididos[divi]+=delimitador[j];
            
                    }
                    divididos[divi]+=buffer[buffi];
                    i=strlen(delimitador)+1;
            
                }
                buffi ++;
                aux ++;
            }
            if ((strlen(delimitador))==i)
                            sigue=false;
            
            
        }
        divi++;
    }
       
    return true;
    
}

Comentarios , dudas y recomendaciones son bienvenidas.
Saludos
Muchas Gracias osna...No Manejo C++,pero de seguro veo de hacerlo en C

Salu2...
Blog técnico dedicado a la seguridad informática y al estudio de nuevas vulnerabilidades.
Blog: http://www.seginformatica.net
Twitter: https://twitter.com/#!/p0is0nseginf
Por aquí en fuentes y textos de programación me parece que postee yo también una alternativa usando "substr" se mira bien la función me la voy a leer mas detalladamente y con más tiempo para ver como la podemos optimizar.
//mHmm..
se me acaba de ocurrir una idea , envez de devolver un bool , que devuelva un puntero a la cadena , usando malloc que crea un espacio de memoria global , en un rato mas posteo el source.

gracias por el aporte man ;) , me haz alumbrado la mente.
Buenas te pedi el msn por pm asi te explico bien como podes optimizar el codigo al 100%

Hice una funcion si la queres ver , estaba aburrido y bueno es una funcion split asi pueden ver otra forma , usando memcpy para copiar.

Código: Seleccionar todo

int
split (const char * in, const char * delim, char * out1, char * out2)
{
  const char * ptr;
  if (ptr = strstr (in, delim))
    {
      memcpy (out1, in, ptr - in);
      out1[ptr - in] = 0;
      strcpy (out2, ptr + strlen (delim));
      return 1; 
    }
  return 0;
}
por el msn la seguimos asi te explico paso por paso y lo que tendrias que modificarle segun mi criterior ! pero va bien ;)

Saludos!
<Josh> y bueno hermano,tu hermana q me dijo q estaba cansada de tenerle el orto como la bandera de japon y bueno la pobre me quizo hacer un masaje prostatico nada mas pero era tanto su recelo y venganza acumulada q se esmero un poco mas de lo normal,pero bue,estuivo bien amorizado por la de dias horas años y lagrimas q echo la pobre de tanto culearla
aqui lo hize , lo dejo en pastebin para que nose echen a perder los ojos xD .

[Enlace externo eliminado para invitados]

retorna la direccion de cadena en memoria, despues de haber utilizado la cadena, basta con poner
free( ptr ); y elimina la cadena de memoria.

PD : esta funcion corta el numero de cadena que quieras , es decir puedes tener esto

Código: Seleccionar todo

Cadena1|Cadena2|Cadena3|Cadena4
y tu le puedes poner que quieres , la cadena 1 o la cadena 4.
adolf escribió:aqui lo hize , lo dejo en pastebin para que nose echen a perder los ojos xD .

[Enlace externo eliminado para invitados]

retorna la direccion de cadena en memoria, despues de haber utilizado la cadena, basta con poner
free( ptr ); y elimina la cadena de memoria.

PD : esta funcion corta el numero de cadena que quieras , es decir puedes tener esto

Código: Seleccionar todo

Cadena1|Cadena2|Cadena3|Cadena4
y tu le puedes poner que quieres , la cadena 1 o la cadena 4.
Ahora mismo le echare un vistaso
Mi blog

www.MasaSoftware.blogspot.com

Encontraras herramientas como el Masacrypter mods Indetectables joiner

___________
acabo de ver el source bro.. voy a apuntar una cosa y es que ese código tiene un coste lineal respecto del número de caracteres del EOF, o dicho de otra manera.. que si quieres hacer el split de la última string separada tienes que leer antes el resto del EOF hasta llegar al separador.
Si después lo que quieres hacer es ir sacando en plan Split (1, string1), Split(2, string2), Split(n, stringN) se hace muy lento (ineficiente) porque en el caso peor estarías leyendo el EOF N/2 veces en un caso promedio.

Cuál es la solución que propongo.. que ya que el coste es lineal.. hacer que se lea todo el EOF y las strings se almacenen en un array para que su acceso sea inmediato. Así sólo tenemos que recorrer el EOF una única vez (que es lo suyo) y el coste de leer las strings es muy bajo.

Ventajas: más eficiente en tiempo. Desventajas: almacenar en memoria el array de strings (que en la era de los Terabytes.. no es tanto problema y más si usamos memoria dinámica)

Espero haber sido claro en la explicación, y no me malinterpreten.. el code está GENIAL pero si en vez de devolver un sólo string devolviese TODOS.. sería un algoritmo más eficiente.

Un saludo! R-007 =)
R-007 escribió:acabo de ver el source bro.. voy a apuntar una cosa y es que ese código tiene un coste lineal respecto del número de caracteres del EOF, o dicho de otra manera.. que si quieres hacer el split de la última string separada tienes que leer antes el resto del EOF hasta llegar al separador.
Si después lo que quieres hacer es ir sacando en plan Split (1, string1), Split(2, string2), Split(n, stringN) se hace muy lento (ineficiente) porque en el caso peor estarías leyendo el EOF N/2 veces en un caso promedio.

Cuál es la solución que propongo.. que ya que el coste es lineal.. hacer que se lea todo el EOF y las strings se almacenen en un array para que su acceso sea inmediato. Así sólo tenemos que recorrer el EOF una única vez (que es lo suyo) y el coste de leer las strings es muy bajo.

Ventajas: más eficiente en tiempo. Desventajas: almacenar en memoria el array de strings (que en la era de los Terabytes.. no es tanto problema y más si usamos memoria dinámica)

Espero haber sido claro en la explicación, y no me malinterpreten.. el code está GENIAL pero si en vez de devolver un sólo string devolviese TODOS.. sería un algoritmo más eficiente.

Un saludo! R-007 =)
No entiendo a que code te refieres , me parece que al mío no . Ya que mi funcion usa un array de strings y el mismo es devuelto completito (con todos los strings). Saludos
una pequeña sugerencia osnarus, creo que el delimitador deberia ser un caracter solamente y no un puntero a una cadena, eso seria muy demoroso, imaginate tener que comparar una cadena entera para saber donde comienza una cadena y donde termina, bueno eso creo yo :) , creo que a eso se refiere R-007
adolf escribió:una pequeña sugerencia osnarus, creo que el delimitador deberia ser un caracter solamente y no un puntero a una cadena, eso seria muy demoroso, imaginate tener que comparar una cadena entera para saber donde comienza una cadena y donde termina, bueno eso creo yo :) , creo que a eso se refiere R-007
No te entiendo. 1 caracter de delimitador??? eso es imposible. Un delimitador es una cadena de varios caracteres, que hacen a ese string... UNICO, con la certeza que ese delimitador no va a confundirse con otros caracteres del archivo.
Saludos

Código: Seleccionar todo

A delimitador es una secuencia de uno o más caracteres especificaban el límite entre las regiones separadas, independientes adentro texto llano o la otra secuencia de datos.[1] Un ejemplo de un delimitador es el carácter de la coma, que actúa como a delimitador del campo en una secuencia de valores coma-separados.
fuente ---> [Enlace externo eliminado para invitados]

siempre se puede hacer un codigo mas corto, mas rapido e innovador, eso es lo que distingue a un buen programador, de un programador de el monton, la clave es saber utilizar las herramientas que tenemos.


osnaraus escribió:No entiendo a que code te refieres , me parece que al mío no . Ya que mi funcion usa un array de strings y el mismo es devuelto completito (con todos los strings). Saludos
me refería al code de Adolf
adolf escribió:una pequeña sugerencia osnarus, creo que el delimitador deberia ser un caracter solamente y no un puntero a una cadena, eso seria muy demoroso, imaginate tener que comparar una cadena entera para saber donde comienza una cadena y donde termina, bueno eso creo yo :) , creo que a eso se refiere R-007
no me refería al delimitador..y me refería a tu code Adolf xD. Se debe devolver el array de strings como hizo Osnaraus porque si no tiene que leer muchas veces como ya dije.. si lees toda la string una sola vez y guardas los trozos en un array es más rápido.

Saludos!
R-007 escribió:
osnaraus escribió:No entiendo a que code te refieres , me parece que al mío no . Ya que mi funcion usa un array de strings y el mismo es devuelto completito (con todos los strings). Saludos
me refería al code de Adolf
adolf escribió:una pequeña sugerencia osnarus, creo que el delimitador deberia ser un caracter solamente y no un puntero a una cadena, eso seria muy demoroso, imaginate tener que comparar una cadena entera para saber donde comienza una cadena y donde termina, bueno eso creo yo :) , creo que a eso se refiere R-007
no me refería al delimitador..y me refería a tu code Adolf xD. Se debe devolver el array de strings como hizo Osnaraus porque si no tiene que leer muchas veces como ya dije.. si lees toda la string una sola vez y guardas los trozos en un array es más rápido.

Saludos!
y que hize yo ? , cuantas veces leo la cadena segun tu? , leo solo una vez la cadena, saco la direccion del inicio de cadena que desea obtener, despues creo un buffer con el tamaño de la cadena y copio la cadena, y retorna la direccion del buffer,


no entiendo, alomejor tu te refieres a que al hacer esto por ejemplo

Split( 1 , buffer , delimitador )

y despues

Split( 2 , buffer , delimitador )

se pondria lento segun tu?
efectivamente me referia a eso.. y si..es ineficiente (está demostrado matemáticamente asi que no me vale que a ti te vaya rápido).
es ineficiente y ya lo expliqué anteriormente pero bueno.. lo explico otra vez porque es un concepto un poco abstracto.
piensa que el buffer tiene 2000 caracteres ok? pues la función Split si la llamas una vez, en el caso peor lee esos 2000 caracteres del buffer y devuelve por ejemplo 50 de la ultima string. Hasta aquí perfecto. Si haces 2 splits seguidos uno a continuacíon del otro (pongamos como ejemplo un crypter que tiene una configuración como "leer tipo de encriptación" y "leer password"), tendría que leer 2000 caracteres para sacar el tipo de encriptación y un poco menos de 2000 caracteres para sacar la password.. lo que sumaría ya casi 4000 caracteres leídos. Si haces 100 splits.. habrás leído casi 50 veces 2000 caracteres (haciendo una media a ojo). Cuando el tamaño de los datos asciende, el coste de sacar el resultado es una función lineal y por tanto se dice que tiene un coste lineal.

Lo que yo propongo es que ya aprovechando que en el caso peor leerías todo el Buffer... pues almacenar todas las strings en un array, así SIEMPRE lees una única vez el Buffer de entrada (y sólo tendrías que hacer un Split).. y el coste de acceder a cualquiera de las posiciones del array a por la string que quieres es inmediato (coste constante), en el ejemplo anterior si tienes 4 configuraciones.. en vez de hacer 4 splits y leer casi 4 veces 2000 caracteres, leerías 1 vez todo el Buffer.. 2000 caracteres y dispondrías de los 4 strings.

Espero que lo tomes en cuenta para mejorar tus programas de ahora en adelante amigo :)
Responder

Volver a “Fuentes”