Me estoy haciendo un lio de cojones. A ver:


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

//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.

/***********************************************
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

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 :


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


Esto es la estructura de una burbuja.


Un saludo