Título del mensaje: FAQ (Respuesta a Preguntas Frecuentes)

Disculpen las molestias, estamos trabajando para mejorar el contenido del foro.

Título del mensaje: 1.Cómo leer y modificar un arreglo o array de caracteres en

Un arreglo es también conocido cómo un array, el array es un tipo de dato que almacena varios datos ordenados bajo un índice que suele comprender de cero hasta el que le hayamos indicado, osea su tamaño o longitud. La duda más común cuando no se tiene práctica en su uso, es la de recorrerlos o modificar un valor almacenado en un determinado indice. Aquí haremos un sencillo ejercicio con una cadena de caracteres para entender su funcionamiento:

Código:

#include <stdio.h>  // printf(), getchar(), etc... #include <string.h> // esta declarada la funcion strlen() int main(void) {    // definimos una cadena de caracteres con longitud 20,    // esto significa que sólo podremos almacenar cómo máximo    // 20 caracteres, de lo contrario puede causar error.    char cadena[20]="Hola bambino";        // Mostramos la cadena por pantalla    printf("La frase que contiene la cadena es la siguiente : %s \n",cadena);        // Obtener un caracter del arreglo:    // Recorremos la cadena hasta el último caracter    for (int i=0;i<strlen(cadena);i++) // la funcion strlen() nos da la longitud de la cadena       printf("En el indice(%d) esta el caracter : %c \n",i,cadena[i]); // Para acceder a los elementos                                                                 // de la cadena, abrimos corchetes y mediante                                                                 // un numero o una variable numerica entera                                                                 // le indicamos el indice o posicion.        // Si quisieramos modificar un valor de un elemento cualquiera    cadena[0]='M'; //Sustituimos la H por la M                   // También podemos usar un bucle para modificar todos sus caracteres...                     getchar();       return 0; }

Título del mensaje: 2.Cómo crear y usar una librería estática en C.

Las librerías estáticas son aquellas que se compilan junto a la aplicación, teniendo el inconveniente en que aumentan el peso del ejecutable y no dejan compartir las funciones con otras aplicaciones. Pero tiene también sus ventajas.

Para crear una librería estática hay que empezar por reunir el fuente de las funciones que deseamos incluir en la librería, y luego sólo debemos compilarla y enlazarla con el fuente que la usará. Sería muy parecido a éste ejemplo, sólo que aquí la librería está sin compilar:

MiLibreria.h

Código:

#include <stdio.h> #include <stdlib.h> #include <curses.h> #define NORMAL       0 #define BRILLO       1 #define SEMIBRILLO   2 #define INTERMITENTE 5 #define INVERSO      7 #define NEGRO       30 #define ROJO        31 #define VERDE       32 #define MARRON      33 #define AZUL        34 #define ROSA        35 #define CELESTE     36 #define BLANCO      37 #define MAXLINEAS 15 #define MAXCAD 70 WINDOW *win; /** manejaremos una única ventana de pantalla completa **/ void IniVideo(){    win=initscr();    clear();    refresh();    noecho();    cbreak();    keypad(win, TRUE);    if(has_colors()) {             start_color();             init_pair(1, COLOR_YELLOW, COLOR_BLUE);             init_pair(2, COLOR_BLACK, COLOR_RED);              init_pair(3, COLOR_BLACK, COLOR_GREEN);             init_pair(4, COLOR_WHITE, COLOR_RED);             init_pair(5, COLOR_WHITE, COLOR_GREEN);         } } /*************************/ void Exit(){         clear();         refresh();         endwin();         exit(1); } /**************************************/ void Disp(){   int posY, posX, i;     posY=(LINES/2)-((2+MAXLINEAS)/2);   posX=(COLS/2)-4;   for (i=0; i<MAXLINEAS; i++){    attrset(COLOR_PAIR(1+(i%5)));    move(posY+i, posX);    printw("%03d %03d %03d", i, i, i);   }   refresh(); }

Aplicacion.cpp

Código:

#include "MiLibreria.h" /*****************************************************************/ void main () {    IniVideo();    Disp();    getch();    Exit(); }

Entonces para el diseño de nuestra librería estática, deberíamos contar con el fuente compilado que puede encontrarse con diferentes extensiones según el compilador a usar, .lib o .a, etc..., muchas veces todo ésto es simplificado usando un entorno de desarrollo o IDE, que en algunos nos permitirá crear proyectos específicos cómo por ejemplo una librería estática. También necesitaremos la cabecera, que viene a ser la definición de constantes y funciones. Usando el mismo ejemplo anterior, hemos usado el fichero de cabecera que incluía la declaración y definición de funciones de nuestra propia biblioteca (que a su vez usa una librería dinámica, en éste caso) y una vez generada, ya sólo nos quedaría enlazarla con nuestro proyecto sin olvidarnos por supuesto de la cabecera que sólo contendrá las definiciones:

MiLibreria.h

Código:

#include <stdio.h> #include <stdlib.h> #include <curses.h> #define NORMAL       0 #define BRILLO       1 #define SEMIBRILLO   2 #define INTERMITENTE 5 #define INVERSO      7 #define NEGRO       30 #define ROJO        31 #define VERDE       32 #define MARRON      33 #define AZUL        34 #define ROSA        35 #define CELESTE     36 #define BLANCO      37 #define MAXLINEAS 15 #define MAXCAD 70 /*********************************************************************/ void IniVideo(); /*************************/ void Exit(); /**************************************/ void Disp();

Aplicacion.cpp

Código:

#include "MiLibreria_.h" /*****************************************************************/ void main () {    IniVideo();    Disp();    getch();    Exit(); }

Más o menos, ésto es resumidamente cómo se crea y se usa una librería estática. No me meto en detalles, ya que el proceso difiere si usamos un compilador u otro, o dependiendo del IDE.
Enlaces:

*Creando y usando una librería estática en Visual C++
*Librerías estáticas con GNU y Borland C++

Título del mensaje: 3.Cómo crear y usar punteros en C, C++ y C#

Punteros o apuntadores, con ellos se trabaja directamente con la memoria. Por lo que tendremos que tener sumo cuidado cuando trabajemos con ellos. Funcionan muy parecido a los vectores o arrays (véase el primer punto de éste hilo para saber más), pero al contrario que los vectores, la gestión de memoria la haremos nosotros y no el compilador.

Para declarar un puntero, se hace de la misma forma que cualquier variable, sólo que entre el tipo y el puntero se pone un asterisco.

tipo *puntero;

Una vez declarado habrá que reservarle memoria, para ello tendremos que usar la función malloc() (en la librería stdlib), si el caso fuera para un compilador de C, y el operador new en caso de trabajar en C++.

Código:

... char *puntero=(char *)malloc(5*sizeof(char)); /* en C de toda la vida */ char *puntero=new puntero[5]; // En C++ ...

Una vez declarado e inicializado el puntero, la forma de trabajo, cómo antes se comentó, es muy similar a la forma de trabajo de un array. Sólo hay que tener en cuenta, que el puntero por si sólo, nos devuelve una dirección de memoria, y para que podamos leer el contenido de la memoria o escribir en esa dirección habrá que usar el operador asterisco delante del puntero. También podremos tomar la dirección de casi cualquier objeto (variable, función, etc..) cargado en la memoria, usando para ello el símbolo de ampersand, luego para asignarla a un puntero prescindiremos del símbolo asterisco.

Código:

... // Escribir un valor directamente a un puntero *puntero=valor; // Leer un valor de donde apunta el puntero actualmente valor=*puntero; // Tomamos la dirección a donde apunta el puntero actualmente direccion=puntero; // Tomamos la dirección de donde esta alojada una variable puntero=&valor; // si escribimos en el puntero un valor, éste modifica la variable a la que apunta *puntero=3; // VALOR ahora contiene un tres ...

Podremos movernos en la memoria desde el puntero mediante operaciones aritméticas.

Código:

... puntero++; // Avanzamos a la siguiente celda de memoria puntero--; // Retrocedemos a la celda anterior ...

Para trabajar y usar punteros en C# pinchar aquí.

Título del mensaje: 5.Cómo trabajar con hilos en C de forma estándar.

Hay veces que nos encontramos con situaciones en las que necesitaremos crear varios procesos que trabajen simultáneamente y que no se estorben entre ellos, de esa forma además evitamos interrupciones en la aplicación que podría malinterpretarse por el sistema o el usuario, cómo que la aplicación ha dejado de responder. También según la configuración del compilador y el mismo compilador, podremos aprovechar mejor los sistemas multi-tarea y la tecnología multi-núcleo.

Cuando hablamos de ejecutar varios procesos en la misma aplicación nos referimos claro está a la programación multi-hebra, multi-hilos u originalmente conocida cómo Threading.

Windows

Windows posee en su API lo necesario para trabajar con hilos, para ello habrá que recurrir a la función CreateThread() la cual habrá que pasarle el puntero de la función que realizará el proceso en segundo plano. Dicha función devuelve un puntero que representa el proceso en si, osea el hilo. El puntero es de tipo HANDLE o manejador (algunos lo llaman manipulador).

Sistemas basados en Unix (Linux/MAC)

Aunque es también válido para Windows, para éstos casos podemos optar por POSIX, que es una librería estándar que contiene entre muchas de sus funciones la posibilidad de crear hilos. De la misma forma que en Windows habrá que usar una función que los crea, pthread_create() , a la cual habrá que pasarle el puntero de la función que realizará el proceso en segundo plano, y también habrá que pasarle un puntero de tipo pthread_t, que representa el proceso mismo. En caso de que no sea posible crear el hilo, la función devolverá un número mayor que cero que corresponde al código del error.

Ejemplo:

Código:

#include <stdio.h> #include <windows.h> // API Win32 #include <pthread.h> // POSIX char teclaPulsada(); //DWORD WINAPI funcionDetectaTecla( void*); // Usando el API Win32 //DWORD WINAPI funcionAplicacion( void*); void *funcionAplicacion(void *); // usando la librería POSIX void *funcionDetectaTecla( void *); // variable global que reocge las teclas char tecla=0; int main(void) { //   HANDLE detectaTecla, aplicacion; // Usando el API Win32    pthread_t detectaTecla, aplicacion; // usando la librería POSIX     //   detectaTecla = CreateThread( NULL, 0, funcionDetectaTecla, NULL, 0, NULL); // Usando el API Win32 //   aplicacion   = CreateThread( NULL, 0, funcionAplicacion  , NULL, 0, NULL);//&threadId );    pthread_create( &aplicacion  , NULL, funcionAplicacion, NULL); // usando la librería POSIX    pthread_create( &detectaTecla, NULL, funcionDetectaTecla, NULL);         //   WaitForSingleObject( detectaTecla, INFINITE ); // Usando el API Win32 //   WaitForSingleObject( aplicacion  , INFINITE );    pthread_join( aplicacion, NULL);  // usando la librería POSIX    pthread_join( detectaTecla, NULL); //   CloseHandle( hThread );    return 0; } //DWORD WINAPI funcionDetectaTecla( void*) // Usando el API Win32 void *funcionDetectaTecla( void*) // usando la librería POSIX {    while(true) tecla=teclaPulsada();     //printf( "My thread ID is: %d\n", GetCurrentThreadId() ); } //DWORD WINAPI funcionAplicacion( void*) // Usando el API Win32 void *funcionAplicacion( void*) // usando la librería POSIX {     // Aquí estaría la aplicación en si...     while(tecla!=27) {         printf("...y sigue... (tecla pulsada= %d )\n",tecla);     }        exit(0);     //printf( "My thread ID is: %d\n", GetCurrentThreadId() ); } char teclaPulsada(void) {   char caracter=0;        for (int contador=27;contador<128;contador++)           if (GetAsyncKeyState(contador) != 0) { caracter =contador; break; } // Sólo funciona en Windows   return caracter; }

Normalmente, los hilos se destruyen junto con el cierre de la aplicación de la que dependen.