Sintaxis del lenguaje C

La sintaxis de un lenguaje de programación es el conjunto de reglas que debemos seguir para que el compilador sea capaz de reconocer nuestro programa como un programa C válido.

Tipos, operadores y expresiones

Identificadores: Formados por letras, números y '_'. Los primeros 31 caracteres son significativos (dependiente del compilador). Las mayúsculas y las minúsculas se distinguen (case sensitive). Las palabras reservadas van en minúsculas

Tipos de datos:

Simples:

 Caracter:
      char -> 1 byte
 Entero:
      int Normalmente refleja el tamaño de los enteros en la máquina host
      short [int] -> 16 bits
      long [int] -> 32 bits
 Real: 
      float Los tamaños son dependientes de la implementación.
      double -> Precisión doble
      long double -> Precisión extendida

Complejos: enumeraciones, arreglos, estructuras y uniones.

Declaraciones:

Todas las variables deben declararse antes de usarse. Una declaración especifica un tipo seguido de una lista no vacía de variables de ese tipo (separadas por comas).

Ejemplo:

float f1, f2;
int i = 1; /* Inicializada al definirla */

Enumeraciones:

enum <nombre> {<enumeradores>}

Ejemplos:

enum boolean {false, true} false vale 0, (por defecto) y true vale 1
enum semana {Lun=1, Mar, Mie, Jue, Vie, Sab, Dom}
enum constantes {nl = '\n', cr = '\r'}

Arreglos:

<tipo> <nombre>[<#elem>].

Ejemplo:

char nombre[30];

arreglo de 30 caracteres- posiciones del 0 al 29.

Estructuras:

struct <nombre> {declaración de los elementos}

Ejemplo:

struct círculo{
int radio;
int x,y; /* Coordenadas del centro */ } circ;

Acceso a los campos a través del operador de proyección '.' circ.radio, circ.x, circ.y

Declaración de nuevos tipos:

typedef <declaración del que será sinónimo> <nuevo nombre>

Ejemplo:

typedef struct s_emp{
char nombre[30];
float sueldo;
int dpto; } empleado;

Constantes:

#define <nombre> <valor>

El #define es una directiva para el compilador que indica que se reemplazará <nombre> por <valor> en el texto.

Ejemplos:

#define MAX_ELEMS 50

Operadores:

Asignación:

=

Casting: operador que obliga a la conversión a un tipo dado:

f = (float) i; /* i no se ve alterado */

Conversiones de tipo:

f = i; /* no hace falta el cast */
i = f; /* se trunca f */

Aritméticos:

+, -, *, /, %, ++, - -, +=, -=.

Hablar de la diferencia entre el pre y el post-decremento i++ vs. ++i

Relacionales:

>, >=, <, <=, ==, !=.

Lógicos:

&&, ||, &, |, !.

Ejemplos:

a && b -> a y b
a || b -> a ó b
!p -> no p

Estructuras de control

Son expresiones seguidas por punto y coma (;). Las llaves son utilizadas para agrupar instrucciones en bloques, que sintácticamente equivalen a una instrucción.

Condicionales:

if_else:

if (cond) inst1
[else inst2]

switch:

switch (exp)
    { case val1: inst1
        ...
      case valn: instn
      [default: instn+1]
    }

Para romper el flujo de control dentro del bloque insti se utiliza la instrucción break.

Ciclos:

while

while (exp)
   inst;

for

for (exp1; exp2; exp3)
   inst;

do_while:

do
   inst;
while (cond);

Funciones

En C no existen procedimientos, sólo hay funciones. Los procedimientos pueden ser simulados por medio de funciones que no retornan ningún valor.

<tipo ret> <nombre>(<parámetros>)
{ declaraciones;
  instrucciones;
}

donde <tipo ret> es el tipo de valor que devuelve la función (por defecto int). Para indicar que no se devuelve nada se coloca void. <parámetros> es una lista de elementos: <tipo nombre>, separados por comas. Para devolver el valor se tiene la instrucción return <exp>. No se pueden devolver estructuras complejas.

Pasaje de parámetros

El pasaje de parámetros es siempre por valor. Si se desea simular un pasaje de parámetros por referencia se debe pasar un apuntador por cada variable cuyo valor se desea modificar. Lo que se pasará como parámetro en este caso será la variable apuntador, i.e., la que contiene la dirección de la variable a modificar.

Apuntadores

Los apuntadores se declaran así:<tipo_de_lo _apuntado> *<nombre_ap>;

Ejemplo:

char *s,c; /* s es un apuntador a un caracter */

Se puede realizar la siguiente asignación:

c = *s; /* c <- contenido de la dir. indicada por s */
El valor NULL se encuentra definido en un a librería (stdio) y vale 0

La dirección de una variable se obtiene aplicando a ésta el operador &. Supongamos que a es char. Siguiendo con el ejemplo: s=&a; es una asignación válida. Si se desea pasar por referencia la variable a en la función f, la llamada se hace así: f(&a) y f debe recibirlo así: <tipo_ret> f(char *ap) ...

Aritmética de apuntadores

Cualquier operación que puede ser realizada sobre los índices de un arreglo puede realizarse con apuntadores.

Ejemplo:

int a[5], x, *ap;
ap= a; es equivalente a ap=&a[0];

Se coloca ap a apuntar al primer elemento del arreglo a. La equivalencia surge pues el nombre del arreglo es un sinónimo para la dirección del primer elemento.

x=*ap; es equivalente a x=a[0];
Si ap apunta a a[0] => ap + i apunta a a[i].

Esta aritmética es válida para un apuntador a cualquier cosa ya que se toma como unidad el tamaño de lo apuntado, i. e., ap + i implica que a ap se e suma i veces el tamaño del entero para obtener la posición del elemento buscado.

Los strings son arreglos de caracteres. Los strings se copian caracter por caracter teniendo apuntadores a cada una de las estructuras en las que se trabaja e "incrementando" el apuntador.

La marca de fin de string es '\0'.

Apuntadores a funciones

Son tratadas como los arreglos (no se necesita el & para obtener su dirección, ésta la indica su nombre).

Palabra reservada void

void implica que falta el valor. Por ejemplo: si una función no retorna ningún valor ni recibe ningún argumento, lucirá así:

void f(void)

void * : Apuntador a cualquier cosa.

Bibliografía

Resumen de Sintaxis en C: http://ldc.usb.ve/~vtheok/cursos/ci2125/material/ResumenLenguajeC.pdf