Mensajes

Me estoy haciendo un lio de cojones. A ver:

Código [Seleccionar] Expandir

    //Declaración de señales
        //Declaramos una estructua action y un handler info
        struct sigaction action;
        void info();
        //Inicializamos la nueva estructura a cero
        sigemptyset(&newmask);
        //Asignamos el bit correspondiente a KILL_CHILD
        sigaadset(&newmask,KILL_CHILD);
        //Asignamos SIG_KILL y la bloqueamos
        sigpromask(SIG_BLOCK,&newmask,&oldmask);
       
        action.sa_flags=0;
        action.sa_handler=info;
        //
            if (sigaction(KILL_CHILD, &action, NULL) == -1)
            {
                printf("Sistema operativo cerrando");
                exit(0);
            }
       


Todo esto es para que cuando llegue la señal KILL_CHILD el proceso muera no??

Tiene buena pinta y contiene todas las funciones. Mañana le echo un vistazo que me voy a sobar ahora. Lo único malo esque es otra vez un montón de tecnicismos, a ver si alguien me lo puede explicar en pocas palabras.
Mil gracias Grok

Por si te interesa esto es un programita de manejo básico de arboles binarios. Es una chorrada pero esta bien para entender el manejo y la estructura.

En mi humilde opinión, me parece que eso de poner 8 return es un desfase. Mucho más facil es usar un doble puntero, porque esa función es pequeña pero me pones una fucnión de 300 lineas con 20 return y ni me leo el código. Algnos diran que soy un purista pesado, pero digo yo que si se creo la programación estructurada no sería para decorar o por aburrimiento.
Otra cosa es que los // o /* */ sirve para poner comentarios, una cosa que la gente agradece cuando el programa no es suyo.

Un saludo

Código (c) [Seleccionar] Expandir


//Cabeceres de precompilación o librerias
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//Estructuras globales
typedef struct arbol{
char DNI[10];
char Nombre[20];
float nota;
struct arbol *izq;
struct arbol *der;
}T_ARBOL;




//Funciones
void Menu (int *op);
void Crear_nodo (T_ARBOL **nodo,T_ARBOL Dato);
void Insertar_nodo (T_ARBOL **nodo,T_ARBOL Dato);
void Limpiar_cadena (char *cadena, int n);
void visualizar (T_ARBOL *nodo);
void preorden (T_ARBOL *nodo);
void inorden (T_ARBOL *nodo);
void postorden (T_ARBOL *nodo);
T_ARBOL *Buscar(T_ARBOL *nodo,char *clave,T_ARBOL **POS);
void Eliminar_nodo (T_ARBOL **nodo,char *clave);
void Desconectar12 (T_ARBOL **nodo,T_ARBOL *POS,T_ARBOL **PAD);
void Desconectar3 (T_ARBOL **nodo,T_ARBOL *POS,T_ARBOL **PAD);

/*************************************************
********************PRINCIPAL*********************
*************************************************/
int main(void)
{
//ENTORNO
int op;
T_ARBOL *raiz;
T_ARBOL Info;
char clave[20];

//INICIALIZACIONES
raiz=NULL;
op=0;

//ALGORITMO

system("title Practica 8: Arboles");


do{
printf("\n ");
system("pause");
system("cls");
Menu(&op);

system("cls");

switch(op)
{
case 1://Introducir alumno
printf("\t\n Nombre: ");
fflush(stdin);    
fgets(Info.Nombre,20,stdin);
Limpiar_cadena(Info.Nombre,20);
printf("\t\n DNI: ");
fflush(stdin);    
fgets(Info.DNI,10,stdin);
Limpiar_cadena(Info.DNI,10);
printf("\t\n Nota: ");
scanf("%f",&Info.nota);


Insertar_nodo(&raiz,Info);


break;
case 2://Eliminar alumno

if(raiz!=NULL)
{
printf("\t\n Introduzca el nombre del alumno a borrar: ");
fflush(stdin);    
fgets(clave,20,stdin);
Limpiar_cadena(clave,20);

Eliminar_nodo(&raiz,clave);
}
else
{
printf("\t\n El arbol est%c vac%co",160,161);
}


break;
case 3://Preorden
if(raiz!=NULL)
{
preorden(raiz);
}
else
{
printf("\t\n El arbol est%c vac%co",160,161);
}
break;
case 4://Inorden
if(raiz!=NULL)
{
inorden(raiz);
}
else
{
printf("\t\n El arbol est%c vac%co",160,161);
}
break;
case 5://Postorden
if(raiz!=NULL)
{
postorden(raiz);
}
else
{
printf("\t\n El arbol est%c vac%co",160,161);
}
break;
case 6://Salir
printf("\t\n Gracias por usar este programa ");

break;

}//Fin Switch
}while(op!=6);

// Valor devuelto por el programa en caso de funcionamiento correcto.
return(0);
}
/*************************************************
********************FUNCIONES ********************
*************************************************/
void Menu(int *op)
{
do{
printf("\t\n  *** GESTI%cN DE NOTAS DE ALUMNOS ",162);
printf("\t\n1.A%cadir alumno(nodo) ",164);
printf("\t\n2.Eliminar alumno(nodo) ");
printf("\t\n3.Mostrar datos de alumnos en preorden ");
printf("\t\n4.Mostrar datos de alumnos en inorden ");
printf("\t\n5.Mostrar datos de alumnos en posorden ");
printf("\t\n6.Salir ");
printf("\t\n     Opci%cn: ",162);
scanf("%d",&*op);
}while(*op>6);

return;
}



//CREACIÓN DE UN NODO

void Crear_nodo(T_ARBOL **nodo,T_ARBOL Dato)
{
//ENTORNO

//ALGORITMO

//Pedir memoria
(*nodo)=(T_ARBOL*)calloc(1,sizeof(T_ARBOL));
if((*nodo)==NULL)//Control de errores
{
printf("\n\t Error al pedir memoria ");
}
else
{

//Copiar datos al elemento
strcpy((*nodo)->Nombre,Dato.Nombre);
strcpy((*nodo)->DNI,Dato.DNI);
(*nodo)->nota=Dato.nota;

//Crearmos los punteros a futuros hijos
(*nodo)->izq=NULL;
(*nodo)->der=NULL;


}
return;
}

//INSERTAR RECURSIVA

void Insertar_nodo(T_ARBOL **nodo,T_ARBOL Dato)
{

if(*nodo==NULL)
{
Crear_nodo(&(*nodo),Dato);

}
else
{
if(strcmp((*nodo)->Nombre,Dato.Nombre)==0)
{
printf("\t\n El elemento ya existe ");
}
else
{
if(strcmp((*nodo)->Nombre,Dato.Nombre)>0)//Izquierda
{
Insertar_nodo(&(*nodo)->izq,Dato);
}
else//Derecha
{
Insertar_nodo(&(*nodo)->der,Dato);
}
}
}
return;
}

void visualizar(T_ARBOL *nodo)
{
printf("\t\n ");
printf(" Nombre: ");
puts(nodo->Nombre);
printf(" DNI: ");
puts(nodo->DNI);
printf(" Nota: %f ",nodo->nota);
printf("\t\n ");
return;
}

void preorden(T_ARBOL *nodo)
{
 if (nodo != NULL) {
   visualizar(nodo);
   preorden(nodo->izq);
   preorden(nodo->der);
 }
}

void inorden(T_ARBOL *nodo)
{
 if (nodo != NULL) {
   inorden(nodo->izq);
   visualizar(nodo);
   inorden(nodo->der);
 }
}

void postorden(T_ARBOL *nodo)
{
 if (nodo != NULL) {
   postorden(nodo->izq);
   postorden(nodo->der);
   visualizar(nodo);
 }
}



T_ARBOL *Buscar(T_ARBOL *nodo,char *clave,T_ARBOL **PAD)
{
//ENTORNO
T_ARBOL *POS;
int sw;


//INICIALIZACIONES
POS=nodo;
PAD=NULL;
sw=0;
//ALGORITMO
while(sw!=1 && POS!=NULL)
{
//Encontrado
if(strcmp(POS->Nombre,clave)==0)
{
sw=1;
}
//Seguimos buscando
else
{
(*PAD)=POS;
if(strcmp(POS->Nombre,clave)<0)
POS=POS->der;
else
POS=POS->izq;
}
}

return(POS);
}


void Eliminar_nodo(T_ARBOL **nodo,char *clave)
{
T_ARBOL *PAD;
T_ARBOL *POS;

//Buscar el elemento a borrar
POS=Buscar((*nodo),clave,&PAD);
if(POS==NULL)
printf("\n No encontrado");
else
{
//En caso de que tenga 2 hijos
if(POS->izq!=NULL && POS->der!=NULL)
{
Desconectar3(&(*nodo),POS,&PAD);
}
//Si no tiene o solo tiene 1 hijo.
else
{
Desconectar12(&(*nodo),POS,&PAD);
}
//Liberamos la memoria
free(POS);
}
return;
}

void Desconectar12(T_ARBOL **nodo,T_ARBOL *POS,T_ARBOL **PAD)
{

T_ARBOL *HIJO;

//No tiene hijos
if(POS->izq==NULL && POS->der==NULL)
{
HIJO=NULL;
}
//Tiene 1 hijo
else
{
if(POS->izq==NULL)
HIJO=POS->der;
else
HIJO=POS->izq;
}
//El nodo a eliminar es la raiz
if((*PAD)==NULL)
{
*nodo=HIJO;
}
else
{
if(POS==(*PAD)->izq)//ERROR
(*PAD)->izq=HIJO;
else
(*PAD)->der=HIJO;

}



return;
}

void Desconectar3(T_ARBOL **nodo,T_ARBOL *POS,T_ARBOL **PAD)
{
//ENTORNO
T_ARBOL *SIG;
T_ARBOL *PADSIG;

//INICIALIZACIONES
PADSIG=POS;
SIG=POS->der;
//ALGORITMO
//Buscar el siguiente en INORDEN
while(SIG->izq !=NULL)
{
PADSIG=SIG;
SIG=SIG->izq;
}
//Desconectarlo
Desconectar12(&(*nodo),SIG,&PADSIG);
//Borrarlo
if(PAD==NULL)
(*nodo)=SIG;
else
{
if(POS==(*PAD)->izq)
(*PAD)->izq=SIG;
else
(*PAD)->der=SIG;
}
SIG->izq=POS->izq;
SIG->der=POS->der;

return;
}


void Limpiar_cadena(char *cadena, int n)
{
   // Variable local.
   int i;
   
   // Sustituimos el \n por un \0.
   i=0;
   while(cadena[i]!='\n' && i<n-1)
   {
       i++;
   }
   cadena[i]='\0';
       
   
   return;
}




Hola todo el mundo,
me he estado machacando buscando información sobre señales por google, pero lo que encuentro esta siempre a medias y no me explica como usar las señales y sus funcione.

Basicamente lo que me gustaria saber es que hacen y como se usan ciertas señales en c.
La funciones que tengo que usar son:
1-sigqueue (no me queda claro para que sirve la variable sig).
2-sigaction ( he leido que se pueden enviar datos con esta, aunque tampoco entiendo como)
3-sigwaitinfo(entiendo que es para esperar la señal pero la variables nose como se usan).
4-sigemptyset ( Para que sirven los sets?)
5-sigaddset
6-sigprocmask (Para que sirven la mascaras?)

También he visto que para usar ciertas variables de las funciones se han de declarar estructuras he inicializar no se que cosas.
Llevo toda la tarde leyendo paginas con ejemplos raros que no hacen nada y no encuentro nada que tenga una función util o que explique como se usa de verdad cada función. Espero que alguien tenga un momento para explicarme como funcionan, aunque sean algunas, o por lo menos recomendarme alguna página donde tengan información sobre como se usan.

Para lo que necesito estas funciones es para comunicar dos procesos, el main con un hijo creado con fork y ejecutando execlp para ejecutar al hijo. Solo necesito enviar una variable al otro proceso y matarlo cuando transcurra un tiempo.

Espero que alguién me pueda echar un cable, si hace falta mas información estare pendiente del post así que diganme y lo cuelgo cuanto antes.

Un saludo

Ya, si me he fijado que estan pinchados, no se en que estaría pensando al ponerlos. Encima llevo algo de tiempo haciendo la practica y como la dejo todo el rato. Nunca me acuerdo de lo que he hecho, encima tenía 3 copias y ya ni se cual es cual XD.

Gracias a tu tiempo ya lo veo más claro, menos mal que te has dado cuenta tú porque yo me hubiese tirado 3 días frustado.

Luego le dedico algo de tiempo que ahorame estoy peleando con una de arboles que es para mañana y las funciones me las da predefinidas.


Muchas gracias otra vez

Vale eres el puto amo!
Me acabo de bajar dos IDE el KDevelop 4 y Anjuta IDE, los voy a probar ahora a ver que tal me va.
Mucha gracias tio, me has alegrado el día

Edito:

Me da que le queda un buen trabajo, porque lo que es funcionar no funciona del todo bien XD. En todo caso visto que estoy cogiendo los valores de sitios erroneos pues tendre más cuidado.

Por cierto si alguien, sabe manejar el asunto del fork() no vendría nada mal un par de consejos

Hola todo el mundo, llevo rato intentado hacer una practica estupida pero soy incapaza de realizarla de forma que funcione correctamente.
Mi principal problema es que tengo que implementarlo para linux y la entrada de datos es por main, o sea usando ./sim.exe "datos".
Se me compila perfectamente, pero al quere ejecutarlo me tira de error de segmentación.

Sospecho que el problema es la validación de la variable tiempo, o su extracción de la cadena, pero ya no se como modificar el código para que corra correctamente.

Se que pido mucho ya que es un coñazo mirar el código de otra persona e intentar entenderlo, pero lo he blindado con comentarios espero que eso ayuda.

Si se os ocurre cualquier cosa, os lo agradecería mil veces.

Código (c) [Seleccionar] Expandir


/***********************************************
Nombre: Simulador
Descripción: Primera parte de la creación de un simulador
de sistema operativo RR.
Fecha:13-01-09
Autor:Bruno Kröller da Silva
************************************************/

// Cabecera de librerías
#include <stdio.h> // Uso de printf,...
#include <stdlib.h> //Uso de atoi,...
#include <unistd.h> //Uso de waitpid,...
#include <sys/types.h> // Uso de rand,...
#include <string.h> // Uso de

//VARIABLES GLOBALES
#define N_MAX 15
#define T_MAX 30
#define T_MIN 5
//FUNCIONES
int hijos(int n_maximo,int quantum,int tiempo);



// Función main que recive parametros de entrada
int main (int argc, char *argv[])
{

// Variables de entorno.
int resultado; // 0 error 1 correcto
int tiempo;
int n_maximo;
int quantum;

//Valores predefinidos de las variables.
n_maximo=5;
quantum=80;
resultado=0;
/*
Controlamos que el número de argumentos sea correcto, en caso contrario
no empezamos a ejecutar las funciones principales.
*/
if(argc==1 || argc==3 || argc==5 || argc>6)
{

printf("\t\n Error, el formato es n p m q t");


}
else
{
/*
Si entran dos argumentos, nombre + tiempo
*/


if(argc==2)
{
tiempo=atoi(argv[2]);

if(1<=tiempo<=120)
{
resultado=1;
}


}
/*
Si entran 4 argumentos, nombre+ numero+ p + tiempo o nombre+ quantum+ q + tiempo
*/
else if(argc==4)
{
tiempo=atoi(argv[4]);
if(*argv[2]=='p' && 1<=tiempo<=120)
{
n_maximo=atoi(argv[1]);
resultado=1;
}
if(*argv[2]=='q' && 1<=tiempo<=120)
{
quantum=atoi(argv[1]);
resultado=1;
}


}
/*
Si entran6argumentos, nombre+ numero+ p+ quantum+ q + tiempo
*/
else if(argc==6)
{
tiempo=atoi(argv[6]);

if(*argv[2]=='p' && *argv[4]=='q' && 1<=tiempo<=120)
{

n_maximo=atoi(argv[1]);
quantum=atoi(argv[3]);
resultado=1;

}

}
// SAlIDA DEl PROGRAMA
if(resultado==1)
{
printf("\t\n Simulador: ");
printf("\t\n       Numero maximo de programas: %d ",n_maximo);
printf("\t\n       Quantum : %d",quantum);
printf("\t\n       Tiempo de ejecución: %d ",tiempo);
}
else
{
printf("\t\n Error al introducir los parametros:");
printf("\t\n [numero_prog] [p] [quantum] [q] [tiempo] ");
}

}

return 0;
}
int hijos(int n_maximo,int quantum,int tiempo)
{
int error; // 1 correcto, 0 error.
pid_t pid_h; // Variable donde almacenaremos el pid del hijo
int numero;
int i;
int tiempo_max;
//INICIALIZACIÓN DE VALORES
i=0;
error=1;

/*
LANZAMIENTO DEL SISTEMA OPERATIVO
*/
//Creamos un hijo
pid_t fork();
//Pedimos que nos diga su pid
pid_h=getpid();
//Comprobamos que el hijo se ha creado
if(pid_h==-1)
{
error=0;
}
else
{
//Ejecutado por el padre
if(pid_h!=0)
{
waitpid(pid_h,NULL,0);
}
//Ejecutado por el hijo
else
{
//Ejecutar el S.O.

//Aquí termina el hijo
exit(0);
}
}
/*
LANZAMIENTO DE LA TEMPORIZACIÓN.
*/
//Creamos un hijo
pid_t fork();
//Pedimos que nos diga su pid
pid_h=getpid();
//Comprobamos que el hijo se ha creado
if(pid_h==-1)
{
error=0;
}
else
{
//Ejecutado por el padre
if(pid_h!=0)
{
waitpid(pid_h,NULL,0);
}
//Ejecutado por el hijo
else
{
sleep(tiempo);
printf("\t\n Temporizador: Finalizado el tiempo de simulación ");
//Aquí termina el hijo
exit(0);
}
}
/*
LANZAMIENTO DE LA TEMPORIZACIÓN.
*/
//CREARCIÓN DE LOS 10 HIJOS

while(i<10)
{

srand(time(0));
//Generamos un numero no mayor que N_MAX
//Le sumamos 1 para que empiece en 1.
numero=1+rand()%(N_MAX);
//Generamos el tiempo de espera de cada hijo.
//Crea números en un intervalo de 5 a 30.
tiempo_max=5+rand()%21;
//Tiempo de espera para crear el siguiente hijo.
sleep(numero);
//CREAR HIJO
pid_t fork();

}
pid_h=getpid();
if(pid_h==0)
{
sleep(tiempo_max);
printf("\n\t Simulador: Lanzando programa- Tiempo ejecución %d ",tiempo_max);
exit(0);
}
//El padre espera a que todos los hijos mueran.
wait();

return(error);
}



/*
CHULETA DE VARIABLES

Valores mínimos y máximos de:
 mínimo  máximo
Tiempo : 1 120
Quantum : 20 200
Programas : 1 5

numero esta entre [1,30]






*/




Mil gracias darkraider, entonces tendre que hacer un par de cambios.

Un saludo

Fuente: http://stackoverflow.com/questions/19/fastest-way-to-get-value-of-pi (La página está en ingles.

El código fuente esta colgado en la página esa.

Este es otro método que converge rápidamente (~ 14digits por iteración), la aplicación actual es más rápido PiFast utiliza esta fórmula con la FFT. Voy a escribir la fórmula, ya que el código es muy sencillo. Esta fórmula la encontró  Ramanujan y fue descubierto por Chudnovsky. Es como logro calcular varios miles de millones dígitos del número de - por lo que  es un método a tener en cuenta. La fórmula se desbordará rápidamente, ya que estamos dividiendo factoriales, sería ventajoso para el cálculo de dicha demora para eliminar términos.



k1 = 545140134; k2 = 13591409; k3 = 640320; k4 = 100100025; k5 = 327843840; k6 = 53360;

A continuación se muestra el algoritmo de Brent-Salamín. Wikipedia dice que cuando a y b son "lo suficientemente cerca" entonces (a + b) ^ 2/4t será una aproximación de pi. No estoy seguro de lo que significa "lo suficientemente cerca", sino de mis pruebas, una iteración tiene 2 dígitos, dos tienen 7, y tres tenían 15, por supuesto, esto es con habitaciones dobles, por lo que podría error han basado en su representación y el ' verdadero 'cálculo podría ser
más exactos.

Es solo una alternativa a lo que han dicho.

Un saludo

[Entorno:]

Yo te recomendarías dos cosas para empezar: tabula y pon comentarios. Porque el código tal cual esta es incomprensible.
Antes de preguntas, por qué no usas el debuger, aprenderas más que si te resuelven otros las dudas simples.
En todo caso como dice biribau no te hace falta ordenar y en este caso no deberías ordenador es totalmente ilógico y sobrecargas el programa para nada.

Lo que tienes que hacer es coger un papel y plantearte el problema. Necesitas saber cual es la nota maxima. Pues como te ha dicho biribau :

cada vez que te entreguen un numero mayor actualizas el máximo, ya está, porque si algo es mayor que el máximo es que es el máximo. Problema: necesitas un numero mínimo(para inicializar máximo), esto a veces puede suponer un problema, a veces se coge -infinito o MIN_INT, en tu caso ya sabes cual es el mínimo posible, 0.

Después de insertar los datos en el vector con el primer for. Haz otro for igual y dentro pregunta si el dato que esta en MAX es mejor que el del vector, si es el caso cambia, sino pues que siga.
NOTA:No hace falta un mínimo para eso, tan solo inicialo con el primer valor del vector.



Una burbuja en speudocódigo

COMIENZO Burbuja

Entorno:
p,n,i son enteros
vector[n] es alfanumerico{vector}
Algoritmo:

para p<-1 a n-1 hacer {en c seria i<-0}
   para i<-1 a n-1 hacer
     si vector>vector[i+1]
        entonces
        aux<-v
        vector<-vector[i+1]
        vector[i+1]<-aux
    fin_si
   fin_para
fin_para
FIN_BURBUJA

Esto es la estructura de una burbuja.


Un saludo