Guía de consulta rápida de C

Estructura de un programa en C

• Un programa en C debe contener como mínimo una función llamada main, que es por donde se inicia siempre la ejecución. El principio y el final de la función se marca con unas llaves.


main(){

/* esto es un comentario */

printf("Hello world!");

}


• Además puede tener otras funciones todas ellas definidas al mismo nivel (es decir, no existe el anidamiento de funciones).


main(){
printf("Hello world!");
otro_saludo();
}

otro_saludo(){
printf("Hola mundo!");
}

• Cualquier función (incluida la función main) tiene la siguiente estructura:
  
  
tipo_devuelto nombre_función (nom_par1, nom_par2,...,nom_parN)

/*declaración del tipo de los parámetros */
tipo nom_par1;
tipo nom_par2;
. . .
tipo nom_parN;

{

/* declaración de las variables locales */

tipo variable1;
tipo variable2;
. . .
tipo variableK;

sentencias_del_cuerpo_de_la_función;

return valor;
}


• Todas las sentencias en C tienen que acabar con el carácter ;
• Declaración de parámetros y variables
  • La declaración del tipo de cada parámetro tiene que hacerse antes de la llave de inicio de función.
  • La declaración de las variables locales se hace justo a continuación de la llave de inicio de bloque
  • Si nuestro programa necesitara usar variables globales, las tendríamos que declarar fuera de todas las funciones.
  • Las sentencias de declaración siempre son de la forma:
    
    tipo_dato nombre_var;
    
    Si tenemos mas de una variable/parámetro del mismo tipo, se pueden declarar en la misma sentencia, separando los nombres con el carácter ,:
    
    tipo_dato nombre_var1,nombre_var2;
    
    
  • Las variables (locales o globales) se pueden inicializar en la misma sentencia de declaración:
    
    tipo_dato nombre_var=valor_inicial;
    
    

Algunos tipos de Datos en C

Constantes en C

• Las constantes de tipo carácter en C se representan encerradas entre comillas simples (''). Por ejemplo, para inicializar una variable de tipo carácter con el valor de la letra A:
  char variable='A';
  
  
• Las constantes de tipo string en C se representan encerradas entre comillas dobles (""):
  printf("Hello world");
  Hay que tener presente que al poner una tira de caracteres entre comillas dobles el compilador añade al final el carácter nulo.
  
  
• Se pueden definir constantes en C mediante la directiva del preprocesador #define:
  #define NOMBRE_CTE valor
  
  #define MAX_VALOR 200
  

Operadores en C

• Aritméticos:
  • suma: i = i + 1;
    
  • resta: i = i - 1;
    
  • multiplicación: i = i * 1;
    
  • división: i = i / 1;
    
  • resto: i = i % 1;
    
  • autoincremento: i++; ó ++i;
    
  • autodecremento: i--; ó --i;
    
• Asignación:
  
  • Asignar a una variable un valor: a=b+c;
  • Asignar a una variable el resultado de operar esa variable con un valor: a+=4; a-=4; a*=4; a/=4; a%=4;
• Relacionales:
  • mayor que/mayor o igual que: i>4; i>=4;
    
  • menor que/menor o igual que: i<4; i<=4;
    
  • igual que/diferente que: i==4; i!=4;
    
• Lógicos:
  • and: a && b;
  • or: a || b;
• Manipulación de bits:
  • and bit a bit: a & b;
  • or bit a bit: a | b;
  • or exclusivo bit a bit: a ^ b;

Control de ejecución

• Bucles

  bucle while: while (expresion) { sentencias; }

  bucle do-while: do { sentencias; }while (expresion);

  bucle for: for (inicializaciones; expresion; actualizaciones) { sentencias; }

  • Comentarios sobre el for :
    • inicializaciones: estas sentencias se ejecutan antes de entrar por primera vez en el bucle.
    • expresion: esta es la condición que se debe cumplir para entrar en el bucle. Se comprueba antes de iniciar una nueva iteración.
    • actualizaciones: estas sentencias se ejecutan al final de cada iteración, antes de comprobar si se debe entrar de nuevo en el bucle.
    
    
    
• Condicionales
  
  

  if, caso 1 if (expresion) { sentencias; }

  if, caso 2 if (expresion) { sentencias; } else { sentencias; }

  if, caso 3 if (expresion) { sentencias; } else if (expresion) { sentencias; }

  elección múltiple switch (expresion){ case etiqueta1: sentencias; break; case etiqueta2: sentencias; break; case etiqueta3: sentencias; break; default: sentencias; }

  • Comentarios sobre el switch:
    • La etiqueta default es opcional, y se utiliza cuando se quiere hacer un tratamiento en caso de que la expresión no coincida con ninguna de las etiquetas anteriores.
    • La sentencia break se utiliza para forzar la salida del switch una vez se han ejecutado las sentencias del caso correspondiente. Si no se pone, la ejecución continuará por las sentencias del siguiente caso (hasta que se encuentre un break).

Punteros

• Un puntero es una variable que almacena una dirección de memoria. Los punteros se utilizan en C, entre otras cosas, para implementar el paso de parámetros por referencia, para gestionar la reserva dinámica de memoria, y para manipular arrays.
  
• Para declarar una variable de tipo puntero se debe especificar de que tipo es el dato que se almacenará en la dirección de memoria que contendrá el puntero:
  
  int *p_int;
  
  Esta sentencia declara una variable de nombre p_int (por lo tanto, tendrá una posición de memoria asignada), que va a contener una dirección de memoria, en la que se almacenará un entero.
  
  
• Si tenemos una variable de tipo puntero, es posible acceder a su propio valor (como en el caso de cualquier otra variable):
  p_int=&i;
  
  Esta sentencia utiliza el operador & para obtener la dirección de memoria en la que se guarda la variable i y se la asigna a la variable p_int.
  
  
• Pero también es posible acceder mediante una indirección a la posición de memoria que indica su valor.
  *p_int=4;
  
  Esta sentencia obtiene el valor que guarda p_int, y accede a la posición de memoria que indica ese valor (es decir, accede a la posición de memoria en la que se guarda la variable i) para dejar un 4.
  
  
• Antes de utilizar el operador de indirección sobre un puntero, hay que asegurarse de que está inicializado de forma correcta. Esto es, el valor que contiene se corresponde con una dirección de memoria válida (que se ha reservado estática o dinámicamente), y además es la dirección a la que interesa acceder.
  
  
• La manera de inicializar correctamente un puntero es asignándole la dirección de memoria de otra variable, o asignándole el resultado de alguna de las funciones de reserva de memoria dinámica (malloc, calloc,...). Estas funciones reciben como parámetro la cantidad de memoria que interesa reservar, marcan como válida esa cantidad y devuelven la dirección de memoria base de la nueva región.

Uso de punteros para paso de parámetros por referencia

• En C el mecanismo de paso de parámetros es por valor. Es decir, se hace una copia de la variable que se pasa por parámetro, y el código de la función trabaja con esa copia. Por lo tanto, cualquier modificación que la función haga sobre el parámetro se pierde una vez la función acabe.
  Si interesa que esas modificaciones se conserven una vez que se sale de la función, necesitamos una manera para que el código de la función acceda a la posició de memoria en la que tenemos la variable que se pasa como parámetro.
  
  
• Esto se implementa declarando el parámetro como un puntero que apunte a la variable que nos interesa, y usando dentro de la función el operador de indirección para acceder a ese dato.
  
  int funcion(param1,param2)
  int *param1;
  char *param2;
  {
  int i=*param1+10;
  . . .
  *param1=4;
  *param2='a';
  . . .
  }
  
  Esta función recibe dos parámetros que quiere modificar, por lo tanto en lugar de pasarle los datos, se le tiene que pasar la dirección de memoria donde se guardan esos datos. Y para acceder a ellos utiliza el operador de indirección *.
  
  
• Por su parte, en la llamada a la función hay que pasar la dirección de memoria de los datos, por ejemplo usando el operador de dirección &.
  
  main(){
  int i=17;
  char c='b';
  . . .
  funcion(&i,&c);
  . . .
  }
  

Uso de punteros en la gestión de memoria dinámica

Siempre que sea necesario utilizar memoria dinámica para almacenar una estructura de datos, se puede declarar la variable como un apuntador al tipo de la estructura, y retrasar la inicialización hasta que se reserva la memoria. Cuando es posible hacer esta reserva, se asigna a la variable que se había declarado la dirección de memoria reservada, para que sea posible el acceso.
Por ejemplo, si se quiere implementar una lista de tamaño variable, cada vez que haya que añadir un nodo, habrá que reservar memoria para el nuevo nodo antes de inicializarlo. Suponiendo que habeis definido el tipo nodo_t:

nodo_t *nodo_aux;
. . .
nodo_aux=malloc(tamanyo_nodo);
inicializar_nodo(nodo_aux);
insertar_nodo(lista, nodo_aux);
. . .


Uso de punteros en la manipulación de arrays

• El nombre de una variable de tipo array es también un puntero al primer elemento del array. Pasar un array como parámetro consiste en pasar la dirección del primer elemento (sino, habria que copiar todos los elementos, y para arrays grandes sería un desperdicio de tiempo y de memoria).
  Por lo tanto, una función que tiene un array como parámetro puede ser de cualquiera de las dos maneras siguientes:

  funcion(param) char param[]; { . . . param[0]=4; . . . }

  funcion(param) char *param; { . . . param[0]=4; . . . }

Paso de parámetros al main

Compilación de un programa sencillo escrito en C en un entorno Unix

Algunas funciones de la librería de C

• Funciones para la manipulación de strings.
  Recordad que un string es un array de caracteres que tiene como marca de final el carácter '\0'. Si utilzáis un array de caracteres que no tenga este carácter, el comportamiento de estas funciones será erróneo y aleatorio.
  También debéis tener presente que "a" indica constante de tipo string, mientras que 'a' indica constante de tipo carácter. Así, para almacenar la constante "a" se necesitaría como mínimo un array de 2 posiciones (para 'a' y para '\0').
  • size_t strlen (char *s1): devuelve el tamaño del string s1 (no cuenta el '\0').
  • char *strncpy (s, ct, n): copia hasta n caracteres de la cadena ct a s; devue lve s. Rellena con '\0' si ct tiene menos de n caracteres.
  • char *strcat (s, ct): concatena la cadena ct al final de la cadena s; devuelv e s.
  • char *strncat (s, ct, n): concatena hasta n caracteres de la cadena ct a la c adena s, terminando con '\0'; devuelve s.
  • int strcmp (cs, ct): compara la cadena cs con ct; devuelve <0 si cs0 si cs>ct.
  • int strncmp (cs, ct, n): compara hasta n caracteres de la cadena cs con la c adena ct; devuelve <0 si cs0 si cs>ct
  • char *strchr (cs, c) : devuelve un puntero a la primera aparición de c en cs o NULL si no está presente.
  • char *strrchr (cs, c): devuelve un puntero a la última aparició n de c en cs, NULL si no está presente.
• Otras funciones útiles de C:
  • int sprintf(char *s, const char *format, ... /* [args] */): deja en el string s el resultado de combinar con el formato indicado por format el resto de argumentos
  • char *strerror (int errnum): devuelve el string representativo del tipo de error indicado por errnum.
  • int atoi (const char *s): convierte el string s en entero.
  • double atof (const char *s): convierte el string s en double.
  • void *malloc(size_t size): valida una zona de memoria de tamaño size, y devuelve su direcció, o NULL si no hay memoria disponible.
  • void free (void *p): libera la zona de memoria a la que apuntaba p