//aqui esta el puntero a funcion
 int (*punt) (int,int);
 
  int suma(int a , int b){
     return a+b;
  } 
 
  int resta(int a , int b){
     return a-b;
  }
 
  *punt=suma;
   punt(2,3);
 
  *punt=resta;
   punt(5,1);
 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 *
 * @author Alarcon
 */
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
    class DeleteRecordDialog extends JFrame implements ActionListener {
        //declaro los elementos de que voy a utilizar
       // Concesionario owner;
 
        //botones de accion
        JButton aceptar ;
        JButton cancelar;
        JButton mostrar ;
 
        //etiquetas
        JLabel tablas ;
        JLabel clPrimaria;
 
        //campo
        JTextField key;
 
        //contenedore
        JPanel PN_Tablas;
        JPanel PN_Recoger;
        JPanel PN_Botones;
 
 
        //creamos los botones
    //            ButtonGroup union =new ButtonGroup();
    //            for(int i=0;i<tableNames.;i++){
    //
    //            }
            public DeleteRecordDialog(){
    //                    super(owner,title,true);
    //                    this.owner=owner;
 
                //inicializamos los botones
                aceptar = new JButton("Aceptar");
                cancelar = new JButton("Cancelar");
                mostrar = new JButton("Mostrar Tabla");
 
                //inicializamos etiquetas
                tablas = new JLabel("Tablas");
                clPrimaria= new JLabel("Clave Primaria:");
 
                //inicializamos campo para recoger datos
                key = new JTextField("recoger id");
 
                //agregamos los contenedores
                PN_Tablas.add(tablas);
 
                PN_Recoger.add(clPrimaria);
                PN_Recoger.add(key);
 
                PN_Botones.add(aceptar);
                PN_Botones.add(cancelar);
                PN_Botones.add(mostrar);
 
                getContentPane().setLayout(new GridLayout(3,1));
                getContentPane().add(PN_Tablas);
                getContentPane().add(PN_Recoger);
                getContentPane().add(PN_Botones);
 
                setSize (320,200);
                setVisible(true);
                validate();
 
            }
 
    public void actionPerformed(ActionEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public static void main (String arg []) {
        DeleteRecordDialog deleteRecordDialog = new DeleteRecordDialog();
 
    }
}
 

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <getopt.h>
 
#define Puerto 4000
#define N 256
#define STDIN 0
 
//declaro prototipos
int generador ();
 
int main(int argc,char *argv[]){
 
		int sockfd,connfd,opc=0,maxfd,ret_select,aleatorio;
		struct sockaddr_in servidor;
		socklen_t size_server;
		char buffer[N];
		char ip[20];
		char suministrador[15]="suministrador\0";
		char valor[2]="s:";
		struct timeval tv;
		fd_set allset,rset;
 
		//comprobamos los argunmentos qe nos pasan en argc
		if(argc!=3){	
			printf("¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡ Error !!!!!!!!!!!!!\n");
			printf("Los argumentos pasados no son los correctos.\n");
			printf("Uso: nombre_programa -opciones [ argumentos ...]\n");
			printf("Salimos del programa.......\n");
			exit(1);}
 
		//comprobaremos las opciones que nos han pasado por los comandos
		while(opc!=-1){
 
			opc=getopt(argc,argv,valor);
 
			switch(opc){
 
				case 's': 
					bzero(ip,sizeof(ip));
					strcpy(ip,optarg);
					break;
			}
		}
 
		sockfd=socket(AF_INET,SOCK_STREAM,0);
		if(sockfd<0){printf("Error en el socket\n");exit(1);}
 
		//inicializamos la structura del servidor(manejador de eventos)
		bzero(&servidor,sizeof(servidor));
			servidor.sin_family=AF_INET;
			servidor.sin_port=htons(Puerto);
			servidor.sin_addr.s_addr=inet_addr(ip);
 
 
		size_server=sizeof(servidor);
 
		connfd=connect(sockfd,(struct sockaddr*)&servidor,size_server);
		if(connfd<0){printf("Error en el connect\n");exit(1);}
 
 
		printf("\n>>>>>>>>SUMINISTRADOR<<<\n");
		printf("\n#Conectado con el servidor:%s por el puerto %d\n\n",ip,Puerto);
 
		//enviamos el mensaje suministrador para registranos en el manejador de eventos
		write(sockfd,suministrador,sizeof(suministrador));
		printf(">>>>>>DIGO :%s\n",suministrador);
 
		//inicializamos los conjuntos de descriptores
		FD_ZERO(&rset);
		FD_ZERO(&allset);
 
		//añadimos el conjunto de descriptores a observar teclado y el canal de comunicaciones
		FD_SET (STDIN,&allset);
		FD_SET (sockfd,&allset);
 
		//colocamos el descriptor como el maximo
		maxfd=sockfd;
 
		//generamos el primer tiempo de espera con un numero aleatorio y lo guardamos en la structura
		aleatorio=tv.tv_sec=generador();
		tv.tv_usec=0;
 
			while(1){
 
				//igualamos el conjunto general con el auxiliar
				rset=allset;
 
				printf("vamos a esperar %d para enviar el mensaje\n",aleatorio);
 
				ret_select=select(maxfd+1,&rset,NULL,NULL,&tv);
		//	printf("\n\tret_select=%d\n",ret_select);	
 
				//comprovaremos que descriptores an saltado o si ha sido el tiempo 
				//salta el socket
				if(FD_ISSET(sockfd,&rset)==1){
		//			printf("\n\tsoy yo el qe salta\n\t");
					//si recibimos un caracter en blanco qe cierro la conexcion
					bzero(buffer,sizeof(buffer));
					read(sockfd,buffer,sizeof(buffer));
 
					if(strlen(buffer)==1){
							printf("\n>>>>> nos desconectan...\n\t Adios\n");
							close (sockfd);
							exit(1);
						}
					}
 
			    //salta el teclado
			    if(FD_ISSET(STDIN,&rset)==1){
 
					bzero(buffer,sizeof(buffer));
					fgets(buffer,sizeof(buffer),stdin);
					if(strlen(buffer)==1){
							printf("\n>>>>> nos desconectamos...\n\t Adios\n");
							close (sockfd);
							exit(1);
						}
				}
 
				//salta el timeoout
				if(ret_select==0){printf("warning");}
			}
 
		close(sockfd);
		return 0;
}
 
int generador(){
		//generamos la semilla con el numero de proceso
		srand(time(NULL));
		//genera el numero aleatorio que ira de 0-10
		return rand()%11;
	}

//      server.c
//      DE PRUEBA
 
 
 
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <getopt.h>
 
#define N 256
 
int main(int argc, char** argv){
 
	int sockfd,bindfd,connfd;
	socklen_t size_cliente;
	char buffer[N];
	struct sockaddr_in servidor,cliente;
 
 
	//descriptor del socket
	sockfd=socket(AF_INET,SOCK_STREAM,0);
 
	//inicializamos la structura
	bzero(&servidor,sizeof(servidor));
		servidor.sin_family=AF_INET;
		servidor.sin_port=htons(4000);
		servidor.sin_addr.s_addr=htonl( INADDR_ANY );
 
	//guardamos los recursos del sistema
	bindfd=bind(sockfd,(struct sockaddr*)&servidor,sizeof(servidor));
 
	//capaz de escuchar a la vez
 
	listen(sockfd,5);
 
	size_cliente=sizeof(cliente);
 
		while(1){
			connfd=accept(sockfd,(struct sockaddr *)&cliente,&size_cliente);
 
			read(connfd,buffer,256);
			printf("%s\n",buffer);
			close(connfd);
		}
 
	close(sockfd);
	return 0;
}