SoloCodigo

La función clock retorna una veriariable tipo clock_t que permite representar la fecha y la hora como un entero largo.

Este valor de retorno representa el numero de pulsos del reloj del sistema que han ocurrido durante el tiempo que ha estado ejecutandose el programa que la llama.

Para convertir este valor en segundos se debe dividir por la macro CLOCKS_PER_SEG. que es el número de pulsos del reloj del sistema ocurridos por cada segundo transcurrido

Claudio H. Núñez Guzmán
<chng_14@BenchSQL.com>
http://www.BenchSQL.com/

Tengo un array de puntero a descriptores de archivo FILE **listado[30] ,y deseo redimensionarlo sin tenerlo que copiar en una cadena auxiliar. Se que se puede hacer con realloc() pero no me sale.
Alguien podria hecharme un cable...  

Salu2

La Declaración:

FILE **Listado[30] ?.
 Seria Similar a Declarar FILE *Listado[][30] o sea estas haciendo un Arreglo Tridimencional,
 Es eso lo que estas buscando hacer ?. Es probable que por aqui tengas el problema al tratar de usar Realoc.

Acuerdate que FILE es una estructura, de Tal Forma que al asignar memoria dinamica para copiar la información, no solo debes asignar memoria al puntero sino tambien a la estructura.

Saludos

Bench
http://www.BenchSQL.com/

Enga:

   No se que estas tratando de hacer Pero aqui tienes información Para el manejo de fecha y horas en forma estandar en lenguaje C.

    Las Funciones estandar para manejar la fecha y la hora del sistema estan
definidas en el archivo de cabezera TIME.H.
    En ella se definen dos tipos de variables para el manejo de las fechas y
las horas:

size_t:
    Similar a un entero sin signo.
clock_t y time_t:
    Permiten representar la fecha y la hora como un entero largo.
y el tipo de estructura "tm"
    Este tipo de estructura permite mantener la fecha y la hora separada en
sus elementos y esta definida de la siguiente manera:

struct tm
  {
    int tm_sec;     /* segundos 0-59 */
    int tm_min;    /* minutos 0-59 */
    int tm_hour;   /* horas 0-23 */
    int tm_mday; /* día del mes 1 - 31 */
    int tm_mon;   /* meses desde enero 0-11 */
    int tm_year;   /* años desde 1900, 00 (+)*/
    int tm_wday; /* dias desde el domingo, 0-6 */
    int tm_isdst;  /* indicador de horario de verano */
{; /*fin de la estructura -> cerrar llave:*/

(+) el elemento tm.tm_year contiene los años trascurridos desde el año 1900,
de tal forma que al algoritmo hay que sumarle 1900 para obtener el año en 4
digitos: por ejemplo 100+1900 = año 2000.

obtener la fecha y hora del sistema:
struct tm *Mi_Fecha;
char *Buffer_Datos_Fecha;
time_t Hora = time();
Mi_Fecha = localtime(&Hora);
/***
Se convierte el contenido de los datos de
la estructura tm en una cadena con la forma siguiente:
dia_semana mes día horas:minutos:segundos año n
****************************/
Buffer_Datos_Fecha = asctime(Mi_Fecha);

los buffer generados por asctime y por localtime son estaticos y se
modifican con cada llamada a las respectivas funciones, por lo tanto si se
quieren conservar se tienen que copiar en otro sitio.

las otras funciones ansi son :

clock_t clock(void)

      Esta función devuelve el numero de pulsos del reloj del sistema que han ocurrido desde que ha estado ejecutandose el programa que la llama.

     Para Obtener el Valor aproximado del tiempo EN SEGUNDOS, que tiene ejecutandose el programa que la llama el valor devuelto por esta función se debe dividir por la macro CLOCKS_PER_SEC


char *ctime(const time_t *Hora);
double difftime(time_t hora2, time_t hora1); /* diferencia en segundos */

    Estas son casi todas las funciones ANSI de las que dispoce el c para el
manejo de fechas y horas, el resto hay que construirlo a partir de ellas.

Como Podras observar el Tema no es sencillo. Por lo Menos si lo quieres manejarlo en forma estandar. Algunos Compiladores Ofrecen opciones más sencillas, pero al no ser estandares no son de mi interes.

Espero les sirva la información

Saludos

Bench

http://www.BenchSQL.com/

La forma es crear un socket de escucha para recibir la peticiones de los clientes y crear nuevos procesos para atenderlas.

Esto ya depende del Sistema operativo con el que trabajes, si el servidor es bajo ambiente unix puedes utilizar la primitiva fork o vfork para crear los procesos hijos que van a atender las peticiones de los clientes (que pueden estar corriendo en cualquier sistema operativo), ya que se trata de un sistema operativo multiusuario.

En ambiente windows, existe lo que se llaman hebras (creo que es treads en ingles) para crear varias tareas y que desde cada una se atiendan las peticiones de los clientes. por tratarse de un sistema multitarea y no multiusuario (?).

Saludos:

http://www.BenchSQL.com/

Si el Dato es muy grande Declara un double.

Algunos compiladores tienen problemas cuando se le asigna un número entero a una variable double. de tal forma que es recomendable que lo escribas con dos ceros como decimales.

Ejemplo:
double Dato = ZERO;
Dato = 123456789012.00;

La otra forma es que moldees el dato:

Por ejemplo si lo estas recibiendo en modo texto:

char Buffer[16] = "123456789012";
double Dato = (double)atoi(Buffer);

Si tienes problemas con esta instruccion
Prueba con esta:

char Buffer[16] ="123456789012";
double Dato = ZERO;
strcat(Buffer,".00");
Dato = atof(buffer);

Espero que la información te sea de utilidad.

Saludos Bench:

http://www.BenchSQL.com/

La Primitiva fork(). Retorna un Cero al Proceso Hijo y el Pid del hijo al proceso padre. Creando una Copia de los Datos con los Valores que tengan al momento de lanzar el proceso hijo, a partir de ese momento las variables son independientes  y si se modifican en un proceso, no afecta su valor en los otros.
Para comunicar los procesos se puede Utilizar pipes, memoria compartida SHM, archivos de disco y otros.

Esquema:

...
int Mi_Pipe[];
int Fid[3];
....
Fid[0] = getpid(); /* Pid del Padre */
pipe(Mi_Pipe);
/******************************
Se creo el Cauce de comunicación
Mi_Pipe[0] => Descriptor de Acceso an Lectura.
Mi_Pipe[1] => Decriptor de Acceso en Escritura.
*****************************/
....

if(!(Pid[1] = fork()))
  {
   /***
   Codigo del Proceso Hijo 1.
   ***************/
   return; /* Finalizar el Proceso */
   }
/***
Proceso Padre Tiene en Pid[1]
El pid del Primer Porceso Hijo
***********************/
if(!(Pid[2] = fork()))
  {
   /***
   Codigo del Proceso Hijo 2.
   ***************/
   return; /* Finalizar el Proceso */
   }
/***
Proceso Padre Tiene en Pid[2]
El pid del Primer Proceso Hijo
***********************/
/*******
Codigo del Padre
*************/
Para Sincronizar los Procesos se Pueden
Utilizar la Primitiva signal, kill

Espero te Sirva la Información

DELpi:

Si Creas Una Matriz de Punteros, Que No Apuntan a Nada: Lo Que Vas a Obtener al Tratar de leer su Contenido es Nada. o Lo que es peor BASURA.

Debes Inicializar Todos los Punteros de La Matriz = NULL, e ir inicializando cada uno de los puntos de la matriz con el puntero que apunta al area de memoria reservada para el NODO que contiene la informacion, en la medida que esta se vaya incluyendo.

No Entiendo Lo Que quieres Hacer:

Pero de Todas Maneras en C Cualquier Area de Memoria Se Accede a Traves de Un Puntero:

Por Ejemplo Si Deseas Atacar La Memoria de Video:
Declaras Un PUntero Tipo Char a la Direccion de Memoria. conocida

char *Punt = (char)A00000;

has declarado un Puntero tipo char
que apunta a la direccion de memoria A00000;

Para Utilizar Un Archivo Como Una Base de Datos. Tipo Texto Por Ejemplo Tipo DBF
Debes:
Desarrollar Un Menejador de Base de Datos.
El Archivo.dbf.
Compuesto Por:
La Cabezera
Estructura que Contiene la Fecha, El Usurio, La Descripcion, el Nombre y el Tamaño de Los Campos, el Nro de Registros que Contiene el Archivo y el Inicio del Primer Registro.

y el archivo.idx

La Cabezera. Contiene entre Otras Cosas
El Nombre de los Campos Clave, Su  Tamaño, El Inicio del Primer Nodo del Arbol Binario. y el Apuntador al Nodo Raiz del Arbor.
y Luego Desarrollar:
Funciones de Apertura de Base de Datos
Funciones de Busqueda,
Funciones Para Agregar o Eliminar Registros.

Todo Estos Si Deseas Manejar Los Archivos Como Base de Datos. y Los Puedes Menejar Tanto en Modo Texto o en Modo Binario. Por Va a Depender de la Forma Como Desarrolles Las Funciones. Tanto Para Grabar Como Para Leer Los Campos de las Bases de Datos.

Ahora Si Lo Que Deseas es Manejar Un Pequeño Fichero de Datos. Con Campos y Tamaño de Registro ya Conocidos Por el Programador, en el Momento de Iniciar la Aplicacion:

Puedes Crear La Estructura del Registro, Con el Nombre de Los Campos, y Como ya Coneces el Tamaño Puedes Agregar o Eliminar Registros en la Medida que le vayas entrando Informacion. Con Algoritmos Recursivos Relativamente. Simples:

Por Ejemplo Si Tienes Un Campo Numerico de 10 Caracteres con Dos Decimales:

Cunado Lo Vayas a Utilizar Lo Conviertes a un double

double Dato = atof(Campo_Numerico);

Y Cuando Lo Vas a Grabar Lo Conviertes
a Mod texto con la funcion:

sprintf(Campo_Numerico,"%10d",Dato);

Pasame el  Codigo Por Correo Para Echarle Una Mirada:

chng_14@hotmail.com

De todas Formas Si Estas Tratando Con Diferentes Tipos de Fuente en la Pantalla
Es conveniente Crear un Buffer Con Una Estructura Donde se debe Guardar: La Posicion el Caracter y el Atributo. Normalmente Tratados Con Logica de bits.

petcher

El Tema es Bastante interesante, ya que es la base de la filosofia cliente servidor:
De Tal forma que la Aplicacion Tiene Dos Puntos de Vista:

El Primero desde el Punto de vista del Cliente que va a recibir el servicio

Y el Segundo desde el punto de vista del Servidor que es Quien Va a Prestar el Servicio a los Diferentes Clientes.

Me Pareceria interesante Que Plantearamos Un Nuevo Tema Para Crear Una Aplicación Cliente Servidor en el dominio internet.

Por Que NO Pruebas Con Una Rutina Similar a la Evaluacion de Una Secuencia de Escape.

Evaluando Primero La Primera Tecla y Esperar Mediante un timeout Si Se Teclea
la Segunda Tecla Esperada.