Archive for May, 2009
May 23, 2009 a las 12:34 pm por Edwin Plauchu · Archivado en Programacion
Elabore una funcion que convierte una palabra de minusculas a MAYUSCULAS utilizando aritmetica de punteros.
Notese que los punteros, tambien pueden actuar como arreglos…
#include "stdio.h"
int main(){
char *palabra_en_minuscula="plauchu";
while ( *palabra_en_minuscula != '\0'){
printf("%c",(*palabra_en_minuscula++ - 32));
}
printf("n");
return 0;
}
Aqui como corro el ejemplo…. bien podrias convertirlo en una funcion.
[j4nusx@localhost ~]$ gcc aritmetica_punteros.c -Wall -o aritmetica_punteros
[j4nusx@localhost ~]$ ./aritmetica_punteros
PLAUCHU
Expliquemos un poco mas lo que es la aritmetica de punteros:
int vector [100]; /* un vector de enteros */
int *ptr; /* un puntero a enteros */
...
ptr = &vector[0]; /* ptr apunta al principio del vector */
*ptr = 33; /* igual que vector[0] = 33 */
*(ptr+1) = 44; /* igual que vector[1] = 44 */
*(ptr+2) = 90; /* igual que vector[2] = 90 */
La expresión que se suma al puntero ha de ser entera y no tiene por qué ser constante. Obsérvese que ptr es lo mismo que ptr+0.
La expresión sumada NO es el número de bytes que se suman a la dirección, es el número de elementos del tipo al que apunta el puntero:
/* Supongamos que un "char" ocupa 1 byte */
/* y que un "double" ocupa 8 bytes */
char* ptrchar;
double* ptrdouble;
...
*(ptrchar+3) = 33; /* la dirección es ptrchar + 3 bytes */
*(ptrdouble+3) = 33.0; /* la dirección es ptrdouble + 24 bytes, ya que cada double ocupa 8 bytes */
El compilador “sabe” cómo calcular la dirección según el tipo.
Aritmética de punteros (más)
A un puntero se le puede aplicar cualquier clase de operación de suma o resta (incluyendo los incrementos y decrementos).
/* Rellenar de unos los elementos del 10 al 20 */
int* ptr; /* el puntero */
int vector [100]; /* el vector */
int i; /* variable contadora */
ptr = &vector[0]; /* ptr apunta al origen del vector */
ptr+=10; /* ptr apunta a vector[10] */
for ( i=0; i<=10; i++ )
{
*ptr = 1; /* asigna 1 a la posición de memoria apuntada por "ptr" */
ptr++; /* ptr pasa al siguiente elemento */
}
May 23, 2009 a las 12:09 pm por Edwin Plauchu · Archivado en Programacion
#include "stdio.h"
#include "stdlib.h"
int main(){
// Se requiere un puntero del tipo de dato FILE
FILE *fichero_to_open;
// La funcion fopen retorna un puntero de tipo FILE
// esto lo logra con el path del archivo y un modo de apertura
// hacia este archivo
fichero_to_open = fopen("/home/j4nusx/chingon3.sql","r");
//Si la funcion fopen tuvo un fallo ... retornara un puntero Nulo
//Indicandonos con esto que ocurrio un fallo
if ( fichero_to_open == NULL ){
perror("Error al intentar abrir el fichero");
exit(1);
}
else {
// Aqui leemos el fichero caracter por caracter
char caracter_obtenido;
while ( ( caracter_obtenido = fgetc(fichero_to_open)) != EOF ) {
printf("%c",caracter_obtenido);
}
fclose(fichero_to_open);
}
return 0;
}
May 23, 2009 a las 11:18 am por Edwin Plauchu · Archivado en Programacion, Linux
#include "stdio.h"
int main(){
char *saludo = "Hola Mundo";
printf("%s n",saludo);
return 0;
}
Hola a todos, la razon de este programita, es manifestarles a todos mis amigos, mi interes por el lenguaje C.
Me canse de buscar en los frameworks de la WEB 2.0
Me canse de las novedades de .NET
Me canse de lo que te ofrece JAVA
Ahora estoy convencido que lo fundamental es todo!
Que clase de profesional de los sistemas soy, si no utilizo como navaja suiza a C. 
La forma en que compile el anterior ejemplo sobre linux fue la siguiente:
[j4nusx@localhost ~]$ gcc hola_mundo.c -Wall -o hola_mundo
El parametro Wall … indica a gcc que debere mostrar todos los warnings durante la compilacion, y el parametro (menos o) especifica el nombre que le dare a mi salida de este proceso de compilacion….
Para ejecutar mi ejemplo, bastara con ejecutar:
[j4nusx@localhost ~]$ ./hola_mundo
Hola Mundo
May 20, 2009 a las 3:28 pm por Edwin Plauchu · Archivado en Solaris
El kernel de solaris es multihilos,esto significa
que los servicios del kernel y tareas son ejecutados como hilos del kernel
El Hilo de Kernel es la unidad principal de ejecucion administrada por
el kernel de Solaris. El Hilo de Kernel tienen un estado de ejecucion
y contexto que inclulle una prioridad global y una clase de Planificacion de Tarea;
Los Hilos de kernel son las unidades fundamentales a ser administradas, ejecutadas
e intercambiadas de contexto sobre y fuera de los procesadores.
Este mismo modelo a los procesos de nivel de usuario.
El proceso de usuario es un contenedor que define bastante de el contexto
de ejecucion para sus hilos. Los hilos permiten multiples flujos de ejecucion
dentro de un solo entorno de memoria virtual.
Los siguientes objetos forman la implementacion y el modelo de hilos sobre el kernel de Solaris.
* Hilos de Kernel(Kernel threads): Es el objeto que se obtiene planificacion y ejecucion sobre un procesador.
* Hilos de Usuario(User threads): El el hilo a nivel de usuario, mantenido por un proceso de usuario.
* Proceso: Forma ejecutable de un programa; El entorno de ejecucion para un programa de usuario.
* Proceso de peso ligero (Lightweight process (LWP)): El contexto de ejecucion visible del kernel, para un hilo de usuario.
Solaris ejecuta hilos de kernel para tareas relacionadas al kernel, tal como el manejo de interrupciones, administracion de paginas de memoria, drivers para dispositivos, etc.
Para la ejecucion de un proceso de usuario, los hilos de kernel tienen un LWP correspondiente LWP;
los hilos de kernel son planificados para ejecucion a favor de los procesos de usuario.
Dentro del kernel, multiples hilos de ejecucion comparten el entorno del kernel,
primariamente el spacio de direcciones del kernel.
Los procesos tambien contienen uno o mas hilos,los cuales comparten el entorno de memoria virtual
de los procesos, como tambien lo hacen otros componentes del contexto de proceso.
El LWP y su correspondiente hilo de kernel definen el entorno virtual de ejecuciont para un hilo dentro de un proceso de usuario. Cada hilo en un proceso de usuario es enlazado a un LWP
, y cada LWP tiene un hilo de kernel. El LWP permite a cada hilo dentro de un proceso, invocar llamadas al sistema
independientemente de otros hilos dentro del mismo proceso.
Cada vez que una llamada al sistema es realizada por un hilo,
sus registros son puestos sobre un stack dentro del LWP.
Una vez que la llamadas al sistema retornaron sus respuestas, estan ya estaran disponibles para LWP.
La siguiente figura muestra lo anteriormente expuesto:
