semana 9
<csignal> (señal.h)
Biblioteca C para manejar señales.
Algunos entornos en ejecución utilizan señales para informar a los procesos en ejecución de ciertos eventos. Estos eventos pueden estar relacionados con errores cometidos por el código del programa, como una operación aritmética incorrecta o con situaciones excepcionales, como una solicitud para interrumpir el programa.
Las señales generalmente representan situaciones en las que se solicitó la finalización del programa o un error irrecuperable, por lo que el manejo de una señal permite realizar operaciones de limpieza de pre-terminación o intentar recuperar el error de alguna manera.
No se requiere que todos los entornos en ejecución generen señales automáticas en los casos para los que están diseñados en la biblioteca C estándar, y algunos otros entornos no solo generan estas, sino también muchas otras señales específicas. Pero en cualquier caso, todas las señales generadas explícitamente con una llamada a la función raise se envían a su controlador de señales correspondiente.
Funciones
Establecer la función para manejar la señal (función)
Genera una señal (función)
Los tipos:
Tipo integral (tipo)
Constantes macro
tipo
macro
señal
int (señales)
SIGABRT
(Anulación de la señal) Terminación anormal, como la iniciada por abortar función.
SIGFPE
(Señal de excepción de punto flotante) Operación aritmética errónea, como la división por cero o una operación que produce un desbordamiento (no necesariamente con una operación de punto flotante).
SIGILL
(Instrucción de señal ilegal) Imagen de función no válida, como una instrucción ilegal. Esto generalmente se debe a una corrupción en el código o a un intento de ejecutar datos.
SIGINT
(Interrupción de la señal) Señal de atención interactiva. Generalmente generado por el usuario de la aplicación.
SIGSEGV
(Violación de la segmentación de la señal) Acceso no válido al almacenamiento: cuando un programa intenta leer o escribir fuera de la memoria que ha asignado.
Sigma
(Terminación de la señal) Solicitud de terminación enviada al programa.
funciones(manejadores)
SIG_DFL
Manejo predeterminado: la señal se maneja mediante la acción predeterminada para esa señal en particular.
SIG_IGN
Ignorar señal: la señal se ignora.
SIG_ERR
Valor de retorno especial que indica la falla.
Ver funcion señal para más información.
signal.h es un archivo de cabecera definido en la Biblioteca estándar de C para especificar como un programa maneja señales mientras se ejecuta. Una señal puede reportar un comportamiento excepcional en el programa (tales como la división por cero ), o una señal puede reportar algún evento asíncrono fuera del programa (como alguien está pulsando una tecla de atención interactiva en el teclado)
Una señal puede ser generada llamando a raise (para enviar una señal al proceso actual) o kill (para enviar una señal a cualquier proceso). Cada implementación define lo que genera las señales (en su caso) y en qué circunstancias las genera. Una implementación puede definir otras señales además de las que figuran en esta lista. La cabecera estándar <signal.h> pueden definir macros adicionales con nombres que empiezan con SIG para especificar los valores de señales adicionales. Todos los valores son expresiones constantes enteras >= 0.
Un manejador de la señal se puede especificar para todas las señales excepto dos (SIGKILL y SIGSTOP no puede ser atrapadas, bloqueadas o ignoradas). Un manejador de la señal es una función que el entorno de destino llama cuando se produce la señal correspondiente. El entorno de destino suspende la ejecución del programa hasta que vuelva la señal de controlador o llama a longjmp. Para una máxima portabilidad, un manejador de la señal asíncrona sólo debe:
hacer llamadas (que tienen éxito) a la señal de la función
asignar valores a los objetos de tipo volátiles sig_atomic_t
devolver el control a la función que la llamó
Si la señal informa de un error en el programa (y la señal no es asincrónica), el manejador de la señal puede terminala llamando a abort, exit, o longjmp.
Índice
Funciones miembro
int raise(int sig). Envía una señal artificialmente.
psignal(int sig, const char *s), devuelve a stderr una cadena que representa un número de señal. Esta en 4.3BSD, Solaris y Linux, pero no está especificada por POSIX o SUS.
En los mismos sistemas, string.h contiene la función no estándar strsignal(int sig) que opera de la misma forma que strerror.
void* signal(int sig, void (*func)(int)), establece las medidas adoptadas cuando el programa recibe la señal sig. Si el valor de func es SIG_DFL, se usará el manejo por defecto para esa señal. Si el valor de func es SIG_IGN, la señal será ignorada. De lo contrario se apuntará a una función manejador de señal que se llamará cuando la señar se active.
Trabajo en el c++
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#define MAX_HIJOS 3
#define INTERVALO 5
void temp(int sig);
void misAcciones(int sig);
int hijo[MAX_HIJOS];
int main (void){
int ppid = 0;
int contador = 0;
int pidActual;
ppid = getpid();
printf("Padre -> %i\n", ppid);
for(contador = 0; contador < MAX_HIJOS ; contador++){
pidActual = fork();
if(pidActual < 0) return -1;
if(pidActual == 0){
switch(contador){
case 0:
signal(30, misAcciones);
printf("HIJO[0] -> %i\n", getpid());
while(1) pause();
break;
case 1:
signal(10, misAcciones);
printf("HIJO[2] -> %i\n", getpid());
while(1) pause();
break;
case 2:
signal(16, misAcciones);
printf("HIJO[3] -> %i\n", getpid());
while(1) pause();
break;
}
}
<cstdarg> (stdarg.h)
En ocasiones, podemos querer escribir una función que use un númeron variable de argumentos como parámetros. La función printf es un buen ejemplo de esto. C tiene tres macros definidas en la cabecera estándar stdarg.h que permiten utilizar un número variable de argumentos.
También se pueden usar en C++, pero para ello necesitamos eliminar la comprobación de tipo que el compilador hace con todas las funciones en C++. Para ello se utilizan tres puntos en la lista de argumentos de la función.
Observamos que:
El prototipo dice que se requiere como primer parámetro un argumento de tipo int. Después, el compilador no comprobará el tipo.
El programa principal consiste de tres llamadas a la función, cada una con un número diferente de parámetros, pero el compilador no advierte de la diferencia en las tres llamadas. De hecho, se pueden poner tantos tipos diferentes como se deseen. Siempre que el primer parámetro sea un entero, el programa compilará y se ejecutará sin ningún problema.
En este caso, el primer parámetro indica el número de parámetros adicionales que se le van a pasar. La función simplemente imprime en pantalla los números.
Estudiemos la definición de la función:
Primero se define una va_list, llamada param_pt, y se inicializa llamando a la función va_start().
La función va_start() tiene como argumentos el nombre de la va_list y el nombre del último argumento formal que se ha pasado a la función.
La macro va_arg() se utiliza para acceder a los argumentos sin nombre por orden. En cada llamada debe especificarse un tipo: va_arg supone que se le ha pasado un argumento real de ese tipo, pero no tiene forma de verificarlo.
Antes de que la función en la que se ha utilizado va_start() devuelva algún valor, debe llamarse a va_end(). La razón es que va_start() puede modificar la lista de parámetros de forma que el return no puede ser hecho correctamente; va_end() no hace estas modificaciones.
Un programa bien diseñado necesita algunas funciones en las que el tipo de argumentos no está completamente especificado. La sobrecarga de funciones y el uso de parámetros por defecto deben ser usados para resolver estas situaciones. Sólo cuando el número de argumentos y el tipo de argumentos varían se debe utilizar las funciones con número variable de argumentos. Naturalmente, el uso de un número variable de argumentos en una función conduce a un código oscuro y apenas debe ser usado.
.
Manejo de argumentos variables
Este encabezado define macros para acceder a los argumentos individuales de una lista de argumentos sin nombre cuyo número y tipo no son conocidos por la función llamada.
Una función puede aceptar un número variable de argumentos adicionales sin las correspondientes declaraciones de parámetros incluyendo una coma y tres puntos ( , ... ) después de sus parámetros con nombre regulares:
return_type function_name (parámetro_declaraciones, ...);
Para acceder a estos argumentos adicionales , se pueden utilizar las macros va_start , va_arg y va_end , declaradas en este encabezado:
Primero, va_start inicializa la lista de argumentos variables como una lista_v .
Las ejecuciones posteriores de va_arg arrojan los valores de los argumentos adicionales en el mismo orden en que se pasaron a la función.
Finalmente, va_end se ejecutará antes de que la función regrese.
Los tipos
Escriba para contener información sobre argumentos variables (tipo)
Funciones macro
Inicializar una lista de argumentos variables (macro)
Recuperar siguiente argumento (macro)
Termine usando la lista de argumentos variables (macro)
En el c++
#include <stdio.h>
#include <stdarg.h>
void PrintFloats (int n, ...)
{
int i;
double val;
printf ("Imprimiendo flotadores:");
va_list vl;
va_start(vl,n);
for (i=0;i<n;i++)
{
val=va_arg(vl,double);
printf (" [%.2f]",val);
}
va_end(vl);
printf ("\n");
}
int main ()
{
PrintFloats (3,3.14159,2.71828,1.41421);
return 0;
}