Mensajes

escribir la misma cantidad de bytes leidos que retorna read

En el clavo. El strlen devuelve el tamaño del buffer hasta el primer byte nulo (que es como termina una string), pero en este caso no estoy analizando cadenas, sino bytes individuales donde probablemente haya bytes nulos muy freqüentemente, por lo que la cantidad de bytes que escribia en cada iteración podia llegar a ser hasta 0 en el peor caso, de manera que perdia una gran cantidad de información. Así que realizando unos pequeños cambios en el bucle while he conseguido que me funcione perfectamente.

Adjunto el código del bucle tal como quedaría:

Código (c) [Seleccionar] Expandir


int size;
  while((size = read(src_fc, buffer, 512)) > 0)
  {
    if(write(obj_fd, buffer, size) < 0)
    {
      strcpy (buffer, "Error in write.\n");
      write (1, buffer, strlen (buffer));
      exit(1);
    }
  }

¡Gracias por la ayuda!

Un saludo.

[Eternal Idol]

En clase de Sistemas Operativos me han enseñado a hacerlo de esa manera, ademas de que eso no cambia de la version que funciona a la que no funciona. De todas formas, cambiando el strlen(buffer) del read por 512 sigue dando el mismo problema.

¿Alguna idea?

EDIT: Eternal Idol Acabo de comprobar lo del strlen con un buffer vacío y tenías razon, no me devuelve 512 sino un valor distinto. De todas maneras, no parece que sea la fuente del problema.

Buenas noches,
estoy haciendo un programa para aprovechar la característica del EOF para ocultar archivos dentro de otros, pero tengo un problema un tanto extraño al escribir en el archivo "objetivo". Cuando hago una pequeña modificación en uno de los while del programa, deja de escribirme el archivo completo y escribe solo unos pocos bytes. Concretando:

Código fuente (funcionando)
http://pastebin.com/ygNq6K1t

La modificación que estoy realizando es substituir el código del while de la línea 31 por el siguiente:

Código (c) [Seleccionar] Expandir


  while(read(src_fc, buffer, strlen(buffer)) > 0)
  {
    if(write(obj_fd, buffer, strlen(buffer)) < 0)
    {
      strcpy (buffer, "Error in write.\n");
      write (1, buffer, strlen (buffer));
    }
  }


Como se puede ver, la única diferencia es que elimino el mensaje de "512b.", pero aun asi la aplicación deja de leer/escribir a los pocos bytes copiados.

¿Alguna idea?

¡Muchas gracias!

Podrías intentarlo también con una mini-imagen del disco.

No sería mejor recibir los parámetros desde el argv? Es decir, tu puedes crear una declaración de este tipo:

Código (cpp) [Seleccionar] Expandir


int main(int argc, char* argv[])
{
  ...
}

Entonces, si tu aplicación es app.exe, cuando hagas desde consola (Linux en este caso) "./a.exe parametro1 parametro2", argc será 3 (argument counter) y argv será {"a.exe", "parametro1", "parametro2"}, de manera que no tendrás que preocuparte por leer los datos.

A mi si me compila, y parece que no estas usando g++. Revisa la configuración de tu editor.

Rectifico: Si usas g++ y si compila. Fíjate bien en los primeros mensajes que te aparecen. Lo que aparece en rojo no se que significa, alguien que use Code::Blocks podrá ayudarte, pero en principio la aplicación ha compilado perfectamente y puedes ejecutarla.

[amchacon]

No declares la estructura dentro de la función. Declárala como global y usa una función del tipo de tu estructura, tal como te ha indicado amchacon.

De todas formas, te recomiendo que lo hagas por referencias. Es mucho más fácil y te ahorras tener que declarar una estructura nueva.

Me refiero:

Código (cpp) [Seleccionar] Expandir

void quickSort(vector<int>& v, int l = 0, int r = v.size()-1);

O bien usar un metodo lanzadera:

Código (cpp) [Seleccionar] Expandir

void quickSort(vector<int>& v)
{
    quickSort(v,0,v.size()-1);
}

Lo digo para asegurarte de que está bien inicializado.

Vale vale, ahora te entiendo jajaj
Normalmente uso lanzadera, ya que en la uni te miran mal cuando inicializas por defecto, pero esta bien recordarlo, gracias ^^

Por cierto R debería tener como valor por defecto v.size().

Y L deberia tener como valor por defecto 0

R tendría como valor v.size()-1 y L=0 en su primera llamada, la que se haría desde el "main". Os he adjuntado tan solo el código de lo que seria el algoritmo, si quereis que os pase el código completo comentadmelo y os lo subo a pastebin, pero no es nada del otro mundo: declarar el vector, leerlo, pasarle los parámetros tal como he indicado antes, y escribir el vector ordenado.

Sobre lo de usar un ciclo tradicional en vez de uno repetitivo estoy deacuerdo, pero me cuesta imaginarme ahora mismo como sería el código iterativo (debería pensarlo), supongo que sería algo más complicado y dificil de leer que el código recursivo. Como tu dices, tampoco le daría demasiada importancia a no ser que la entrada fuera exageradamente grande y la eficiencia fuera algo prioritario.

Hombre, para llenar la pila con un QuickSort te han de meter un vector extremadamente grande... jajajaj