Mensajes

Hola, este es mi problema:
Intento redirigir la salida estandar a un fichero para escribir DESDE EL FINAL de éste:

Código [Seleccionar] Expandir


int stdoutRedir2(const char *fichName){
    int fd=open(fichName,O_APPEND);
    int nuevoFd=-1;
    if(fd<1){
        fd=creat(fichName,0644);
    }else{
        nuevoFd=dup2(fd,1);

    }
    close(fd);
    return nuevoFd;
}


"error de escritura: Descriptor de archivo erróneo"

¿Alguien sabe por qué?

He segudido probando.

He cambiado el orden de los parámetros, en lugar de poner ls,cat y wc ahora pongo:
wc,cat y ls.

¿Me puede explicar alguien por qué pasa esto? No entiendo nada..


EDITO: lo he solucionado cambiando el execlp([i-1],[i-1],NULL) por
execlp([max-i],[max-i],NULL).

Sigo sin entender por qué pasa esto.
Ahora necesito ayuda para pasarlo de recursivo a iterativo, ¿alguien me puede ayudar? Gracias

Hola de nuevo, he seguido intentándolo y creo que un problema era que en el fragmento de código del "default" uso 'fd2' cuando debería usar 'fd', esto es:

Código [Seleccionar] Expandir


default:
            //Soy el proceso padre (pero era el hijo en la anterior llamada
            //recursiva)
            //Redirijo entrada
            inRedir(fd) //antes ponia esto ==== > inRedir(fd2);
            //ejecuto
            execlp(args[i-1],args[i-1],NULL);
            exit(0);


Estoy ejecutando pasandole como mandatos ls, cat y wc para que haga: "ls | cat | wc". El error que me da es:
"wc: entrada estándar: Error de entrada/salida"

Hola a todos.

Tengo que hacer un programa en c++ que ejecute cualquier nº de mandatos de la shell encadenados por tuberías. He conseguido hacerlo para una sola tubería, y para 2, pero cuando paso al caso general ('n' tuberías no consigo que funcione).

Os adjunto el código:

Código [Seleccionar] Expandir


/**
   Ejecuta los mandatos de la lista 'args' encadenados por tuberías.
   'fd' vector de descriptores
       inicial (se crea en el main y se le pasa a este metodo)
   'i' número de iteraciones que llevo hechas. Con cada nuevo proceso
       creado, se incrementa en 1.
   'max' número de mandatos en el vector de argumentos ('args')
**/
int p1(char *args[],int fd[],int &i,const int &max){
   //Voy a ejecutar un mandato, incremento i.
   i++;
   //Creo la tubería para el siguiente proceso.
   pipe(fd);
   //Creo el proceso
   int pid=fork();
   switch(pid){
       case -1:
           //si hay error....
           exit(-1);
       case 0:
           //Soy el proceso hijo, lo que hago es:
           //Creo otro vector de descriptores (para la tubería
           //que mi hijo tendrá que heredar.
           int fd2[2];
           //Redirecciono mi salida estándar para que mi
           //padre pueda leer la salida del mandato que voy
           //a ejecutar
           outRedir(fd);
           //Si no soy el proceso que va a ejecutar el último mandato:
           if(i<max){
               //Repito lo anterior para crear mi tubería, mi proceso hijo etc.
               p1(args,fd2,i,max);
           //Si soy el proceso que va a ejecutar el último mandato:
           }else{
               //Ejecuto y salgo
               execlp(args[max-1],args[max-1],NULL);
               exit(0);
           }
           break;
       default:
           //Soy el proceso padre (pero era el hijo en la anterior llamada
           //recursiva)
           //Redirijo entrada
           inRedir(fd2);
           //ejecuto
           execlp(args[i-1],args[i-1],NULL);
           exit(0);
   }
}

/**
   Dado un vector de descriptores:
       -Cierra el extremo de escritura
       -Redirige stdin al extremo de lectura de la tuberia
       -Stdin ya redireccionado, cierra el extremo de lectura
**/
void inRedir(int fd[]){
   close(fd[1]);
   dup2(fd[0],0);
   close(fd[0]);
}

/**
   Dado un vector de descriptores:
       -Cierra el extremo de lectura
       -Redirige extremo de escritura a stdout
       -Stout ya redireccionado, cierra el extremo de escritura
**/
void outRedir(int fd[]){
   close(fd[0]);
   dup2(fd[1],1);
   close(fd[1]);
}


Muchas gracias.

¿Nadie puede ayudarme?

No se por qué no se ve la imagen. La veo solo cuando logeo, si no no la puedo ver ni yo.

Dejo el link del esquema aquí:
http://imagizer.imageshack.us/v2/800x600q90/716/mj4a.png

["Autores que hayan escrito mas de un libro en la misma editorial"]

Hola a todos.

Tengo una duda acerca de una xquery que no se hacer. El esquema xml es este:

link a la imagen: http://imagizer.imageshack.us/v2/800x600q90/716/mj4a.png

La xquery que tengo que hacer es la siguiente:

"Autores que hayan escrito mas de un libro en la misma editorial"

Yo he intentado esto, pero no se si funciona (no tengo el documento xml ni tampoco ningun programa para probarlo):

Código [Seleccionar] Expandir


//1
<sol>{
for $i in //autor/../editor[count(/../libro)>1]
return $i
}</sol>

//2
<sol>{
for $i in //autor,
$j in //editor
where $i/../editor=$j and
count($i/..)>1
return $i
}</sol>


Dudo mucho que alguna de las dos esté bien.

¿Me puede ayudar alguien por favor?

Muchas gracias.

[En el caso de un contenedor que posea un punteroa memoria dinámica, su función sería encargarse de «mover» la memoria reservada enel temporal al objeto destino que está siendo construido o asignado.]

Hola a todos.

Estoy leyendo un pequeño documento acerca de las nuevas caracteristicas de C++11
link: http://www.eiic.ulpgc.es/documentoscongresos/Francisco%20Palomo-Inmaculada%20Medina.pdf

El caso es que, por lo que veo, la característica mas potente y compleja es la semántica de movimientos. Si lo he entendido bien, esto incide directamente en el rendimiento del código (haciéndolo mucho mas eficiente). (¿es mucho más, o poco más?)

El caso es que lo leo y releo y no consigo entenderlo.
Explico lo que "creo entender":
1 - Sé lo que es un r-value, entiendo que siempre se almacenan en la stack.
2 - Creo entender que la idea del move semantics es "mover" un r-value de la stack al heap.
¿¿¿ Esto se consigue asignando la direccion de memoria de nuestor r-value (que esta en el stack) a un puntero que está apuntado a una dirección del heap???

Cito la explicación que dan:
Estas referencias, distintas de las habituales, se construyen con &&, en lugar de &.
Las referencias && pueden ligarse a un temporal y permiten su modificación.
...
Por lo tanto, es posible incluir en las clases constructores y operadores de asignación que
reciban referencias a valores «r». En el caso de un contenedor que posea un puntero
a memoria dinámica, su función sería encargarse de «mover» la memoria reservada en
el temporal al objeto destino que está siendo construido o asignado. (WTF?!?!?)

¿Puede alguien explicarme esto por favor? no lo consigo entender.

Muchas gracias.

PD. ¿cuál es el motivo por el cual el compilador no puede conseguir el move semantics por si solo?

Ok gracias por la respuesta, espero no haber molestado, en cualquier caso no era mi intención.

Saludos.

Hola a todos, en otro post que escribí se mencionó algo sobre esto, resumiendo: que los compiladores hoy día son tan avanzados que optimizan el código igual o mejor que un programador.
Escribo en un post nuevo porque este tema no tiene nada que ver con el post del que he hablado arriva.

Dicho esto, mi pregunta es:
1 - A parte del hecho de que lenguajes como C,C++ al compilarse pasan a lenguaje máquina, ¿Su "compelgidad extra" puede aportar alguna mejora significativa del rendimiento con respecto a otros lenguajes de mas alto nivel como Java?
Es decir, si no podemos optimizar el código de C++ utilizando todas su posibilidades de "mas bajo nivel", porque el compilador ya optimiza hasta tal punto que (casi) no se puede mejorar, no es lo mismo hacer el programa en otro lenguaje de mas alto nivel? Porque el algoritmo va a se el mismo para los dos...
Porque lo que hace el compilador de C++, lo puede hacer el de java, y lo puede hacer el de cualquier otro lenguaje (compilado), ¿cierto?

Gracias de antemano.

PD. si hay tiempo, una novedad de C++11 es la semántica de moviemientos. Quizá me equivoque pero por lo que he leído es bastante potente. Mi pregunta es si esto lo consigue solo C++ o también los lenguajes de mas alto nivel como java etc.