miércoles, 11 de septiembre de 2013

Estructuras de control



Las estructuras que incorpora el C basadas en la programación estructurada son:
  1. Secuenciales.
  2. Selectivas.
  3. Repetitivas.

  • Estructuras Secuenciales

En un programa en C, las sentencias se ejecutan una tras otra en el orden en el que están escritas. El fin de sentencia marca el comienzo de la siguiente.

{ sentencia1; sentencia2; ... sentenciaN;}


    • Estructuras Selectivas
    También son llamadas condicionales; permiten que ciertas sentencias se ejecuten o no en función de una determinada condición. Tipos de estructuras selectivas:

    • la simple: if 
    • la doble: if else
    • la múltiple: switch

    La estructura general de una estructura selectiva simple en C es:
    Primero evaluará que la expresión sea verdadera (distinta de cero) para proceder a ejecutar la o las sentencias dentro del bloque_if. Es importante que cuando sean de dos sentencias en adelante dichas sentencias estén dentro de llaves { }.
         

         if(expresion)
               bloque_if

    La estructura general selectiva doble:

    Al igual que la simple, primero evalúa que la expresión sea verdadera, en caso de que si lo sea ejecuta las sentencias que estén en el bloque_if. En caso de que no sea verdadera la expresión ejecutará la o las sentencias que estén en el bloque_else

       if(expresion)
               bloque_if
       else 
               bloque_else


    La estructura general selectiva múltiple :

    En la estructura selectiva múltiple, se puede seleccionar entre varias alternativas según el valor de una expresión.


            switch(expresion)
          {
                case exprConst1: 
                         listaProp1
                         break;
                case exprConst2:
                         listaProp2
                         break;
                case exprConstN:
                         listaPropN
                         break;
                default
                         propDefault
                         break;
            }

    Primero se evalúa la expresión que acompaña al switch (se evalúa como expresión entera). 

    Se compara el valor obtenido, secuencialmente, con los valores que acompañan los case, deteniéndose en el primero que coincida. Estos valores deberán ser expresiones constantes enteras.


    Existe una etiqueta especial,
    default, que siempre es cierta, por lo que se utiliza para contemplar el resto de los casos que no se han considerado en los case anteriores. Es muy importante que esta etiqueta sea la última.

    Al final de cada case se utiliza un break ya que si la expresión coincide con un case se ejecutarán todos los case que estén por debajo, entonces break finaliza la ejecución del switch.


    • Estructuras Repetitivas
    En este tipo de estructuras, se repite un conjunto de instrucciones en función de una condición. La principal entre las diferentes estructuras repetitivas consiste en qué punto se realiza la comprobación de la condición. Las tres tipos de estructuras repetitivas son:

    • while
    • do while
    • for

    Sentencia while:

    Primero se evalúa la expresión que acompaña a la cláusula while. Si la expresión es cierta (el valor es distinto de cero), se ejecuta el bloque que sigue a continuación. Se vuelve al primer paso, y se repite el proceso.


    Sintaxis:

            while (expresion)
              bloque


    Sentencia do while:

    A diferencia de la sentencia while. en esta estructura primero se ejecuta el bloque y posteriormente se comprueba la condición. Por lo tanto, el bloque de una sentencia do while se ejecuta siempre al menos una vez.

    Sintaxis:

         do
         bloque
      while(expresion);


    Sentencia for:

    En esta sentencia se ejecuta primero el bloque inicial, se evalúa la expresión, si es falsa, se finaliza la sentencia. Si es verdadera se ejecuta el bloque, se ejecuta el bloque final y se vuelve a evaluar la expresión.





    Sintaxis:

          for( inicial;
                 expresion;
                 final)
            bloque

    En esta estructura puede omitirse cualquiera de los tres campos, pero es impresindible mantener los ";". Si se omite el segundo campo, la condición se da por cierta, y se obtiene un bucle infinito.  

    • Estructuras anidadas
    Se puede colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque if else dentro de un bucle for cuando una estructura de control se coloca dentro de otra estructura de control, se dice que se está anidando.

         for( inicial; expresion; final)
         {
           if (expresion)
             sentencia
           else
             sentencia
         }     

    Ejemplos:

    • Estructura selectiva doble: if else
    #include <stdio.h>
    /* Programa que calcula si un año es bisiesto o no*/

    int main()
    {
       int year = 0;

       printf("Introduzca un anio: ");
       scanf("%d", &year);

       if((0 == year %400) || ((0 == year % 4) && (0 != year % 100)))
          printf("El anio %d es bisiesto\n", year);
       else 
          printf("El anio %d no es bisiesto\n", year);

       return 0;
    }


    • Estructura selectiva multiple: if else
    #include <stdio.h>
    /* Programa que lea un número del mes (en el rango de 1 a 12) e indique el número de días que tiene el mes*/

    int main()
    {
      int mes = 0;
      int ndias = 0;

      printf("Introduzca el número de un mes  (1-12): ");
      scanf("%2d", &mes);

      switch(mes)
      {
         case 2: 
                 ndias = 28;
                 break;
         case 4:
         case 6:
         case 9:
         case 11:
                 ndias = 30;
                 break;
         default:
                 ndias = 31;
                 break;
      }
      
      printf("El mes %d tiene %d dias.\n", mes, ndias);

      return 0;
    }


    • Estructura repetitiva: while
    #include <stdio.h>
    /* Programa que hace una suma de 1 hasta 10*/

    int main()
    {
      int sumatoria = 0;
      int contador = 0;

      while(contador < 10)
      {
        contador++;
        sumatoria += contador;
      }
      printf("La sumatoria de 1 hasta 10 es: %d", sumatoria);
      
      return 0;
    }

    • Estructura selectiva multiple: for
    #include <stdio.h>
    /*Programa que obtiene la suma de los números pares comprendidos entre 2 y 1000*/

    int main()
    {
       int i;
       int suma = 0;

       for( i = 2; i <= 1000; i += 2 )
           suma += i;
       printf("La suma de los pares hasta 1000 es: %d", suma);

       return 0;
    }

    Conceptos básicos del lenguaje C

    • Identificadores

    Se usan para referenciar variables, funciones, etiquetas y otros objetos que son definidos por el usuario. La regla para nombrar los identificadores es que el primer caracter debe ser una letra o guión bajo, los siguientes caracteres pueden ser números, letras, guión bajo, el lenguaje es sensible a mayúsculas o minúsculas.

    Ejemplos: variable, variable1, variable_1,  _variable1, v. 

    • Tipos de datos
    Cuando en C, se dice que un objeto es de un tipo, se quiere decir que ese objeto pertenece a un conjunto específico de valores con los cuales se pueden realizar un conjunto de operaciones también determinadas.

    Existen cinco tipos básicos: carácter, entero, coma flotante, coma flotante de doble precisión y void.

    Los demás tipos se basan en alguno de estos tipos básicos. El tamaño y el rango de estos tipos de datos varían con cada tipo de procesador y con la implementación del compilador de C.

    Tipo Tamaño en bits Rango
    char  8 -127 a 127
    unsigned char 8  0 a 255
    signed char 8  -127 a 127
    int 16  -32767 a 32767
    unsigned int 16  0 a 65535
    signed int 16  -32767 a 32767
    short int 16  -32767 a 32767
    unsigned shor int 16  0 a 65535
    signed short int 16  -32767 a 32767
    long int 32 -2147483647 a 2147483647
    signed long int 32 -2147483647 a 2147483647
    unsigned long int 32 0 a 4294967295
    float 32 seis dígitos de precisión
    double  64 diez dígitos de precisión
    long double  64 diez dígitos de precisión

    • Variables
    Una variable es una posición de memoria con nombre que se usa para mantener un valor que puede ser modificado en el programa. Todas las variables deben ser declaradas antes de poder usarlas,
    La declaración de objetos en C tiene como finalidad dar a conocer el tipo y propiedades de los identificadores.
    En general la forma de una declaración es: (durabilidad) tipo identificador (=expresión de inicialización);


    Por ejemplo, static int n=10;

    • Constantes #define
    #define sirve para dos cosas definir constantes o macros. Por ejemplo:
    #define PI 3.14159 
    entonces cada que escribamos PI en el programa, C lo interpretará como 3.14159.

    • Operadores
    C es un lenguaje muy rico en operadores. Se definen seis tipos de operadores aritméticos, relacionales, de asignación, lógicos, de dirección y de movimiento.

    Operadores aritméticos 
     +  suma
     -  resta
     *  multiplicación
     /  división
     % módulo 
    Operadores lógicos
     !  not 
    && and
    || or
    Operadores relacionales 
     ==  igual a
    != diferente de 
    > mayor que
    < menor que
    >=  mayor o igual que
    <= menor o igual que
    Operadores de asignación 
     =
     ++ 
     --
     +=
     -=
     *=
     /=
     %=


    Prioridad de operadores


    Grupo de operadores Orden de evaluación Comentarios
    () [] -> . de izquierda a derecha Este es el grupo de operadores con mayor prioridad.
    ! ~ ++ -- + - (tipo) * & sizeof de derecha a izquierda La refundición de tipos y sizeof son operadores unarios.
    * / % de izquierda a derecha El símbolo "%" denota el operador módulo, que produce el resto entero obtenido al dividir el primer operando por el segundo.
    + - de izquierda a derecha Los operadores aditivos tienen menor prioridad que los multiplicativos.
    << >> de izquierda a derecha Estos son los operadores de desplazamiento bit a bit (q.v.)
    < <= > >= de izquierda a derecha
    == != de izquierda a derecha
    & de izquierda a derecha Este operador y los dos siguientes realizan operaciones lógicas bit a bit, considerando bits individuales de sus operandos.
    ^ de izquierda a derecha
    | de izquierda a derecha
    && de izquierda a derecha Este operador y el siguiente producen resultados lógicos, pero no consideran bits individuales sino el valor global del operando.
    || de izquierda a derecha
    ?: de derecha a izquierda
    = += -= *= /= %= &= ^= |= <<= >>= de derecha a izquierda
    , de izquierda a derecha Este es el operador de menor prioridad en C. Sirve para separar una colección de expresiones, que se irán evaluando de izquierda a derecha. El resultado es el producido por la expresión situada en último lugar (más a la derecha), y tiene por tanto el tipo y valor de esta última expresión. Se emplea a veces en expresiones de control; un ejemplo sería la cláusula de iniciación de un for o la cláusula de mantenimiento de iteración de un while.

    • Sentencias
    Una sentencia es cualquier expresión en C que se espera que tenga una consecuencia. Pueden ser asignaciones, operaciones, llamadas a funciones o combinaciones entre ellas.
    Toda sentencia termina con un ";". Una sentencia simple consiste en una expresión acabada en un punto y coma.. Al conjunto de sentencias que se encierran entre símbolos "{" y "}" para formar un bloque de código se le denomina sentencias compuestas.

    • Palabras reservadas
    Las palabras reservadas son palabras que tienen un significado gramatical especial para ese lenguaje y no puede ser utilizada como un identificador de objetos en códigos del mismo, como ser variables. 


    auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while

      • Comentarios

      Los comentarios son textos que no son procesados por el compilador. Sirven como información para el programador. Para que un texto sea comentario debe estar entre símbolos "/*" (para iniciar) "*/" (para terminar). Si se desea comentario de una sola línea también se puede escribir "//"


      viernes, 6 de septiembre de 2013

      Funciones predefinidas

      C posee ciertas funciones que nos ayudan hacer nuestros programas más fáciles y a utilizar menos código.  El lenguaje C, cuenta con una serie de funciones de bibliotecas que realizan operaciones y cálculos de uso frecuente. 

      • Funciones matemáticas 

      Para acceder a ellas, se debe colocar la directiva #include <math.h>  en el encabezado del programa.
      Función (Sintaxis) Tipo de Dato Propósito
      acos(d) double Devuelve el arco coseno de d
      asin(d) double Devuelve el arco seno de d
      atan(d) double Devuelve el arco tangente de d
      atan(d1, d2) double Devuelve el arco tangente de d1/d2
      ceil(d) double Devuelve el valor redondeado por exceso, al siguiente entero mayor
      cos(d) double Devuelve el coseno de d
      cosh(d) double Devuelve coseno hiperbólico de d
      exp(d) double Eleva a la potencia d
      fabs(d) double Devuelve el valor absoluto de d
      floor(d) double Devuelve el valor redondeado por defecto al entero menor más cercano
      log(d) double Devuelve el logaritmo natural de d
      log10(d) double Devuelve el lo. (base10) de d
      pow(d1, d2) double Devuelve d1 elevado a la potencia d2
      sin(d) Double Devuelve el seno de d
      sinh(d) double Seno hiperbólico de d
      sqrt(d) double Raíz cuadrada de d
      Tan(d) double Devuelve la tangente de d
      tanh(d) double Devuelve la tangente hiperbólica de d


      • Funciones de cadenas

      Para acceder a ellas, se debe colocar la directiva #include <string.h>  en el encabezado del programa.

      memcpy copia n bytes entre dos áreas de memoria que no deben solaparse
      memmove copia n bytes entre dos áreas de memoria; al contrario que memcpy las áreas pueden solaparse
      memchr busca un valor a partir de una dirección de memoria dada y devuelve un puntero a la primera ocurrencia del valor buscado o NULL si no se encuentra
      memcmp compara los n primeros caracteres de dos áreas de memoria
      memset sobre escribe un área de memoria con un patrón de bytes dado
      strcat añade una cadena al final de otra
      strncat añade los n primeros caracteres de una cadena al final de otra
      strchr localiza un carácter en una cadena, buscando desde el principio
      strrchr localiza un carácter en una cadena, buscando desde el final
      strcmp compara dos cadenas alfabéticamente ('a'!='A')
      strncmp compara los n primeros caracteres de dos cadenas numéricamente ('a'!='A')
      strcoll compara dos cadenas según la colación actual ('a'=='A')
      strcpy copia una cadena en otra
      strncpy copia los n primeros caracteres de una cadena en otra
      strerror devuelve la cadena con el mensaje de error correspondiente al número de error dado
      strlen devuelve la longitud de una cadena
      strspn devuelve la posición del primer carácter de una cadena que no coincide con ninguno de los caracteres de otra cadena dada
      strcspn devuelve la posición del primer carácter que coincide con alguno de los caracteres de otra cadena dada
      strpbrk encuentra la primera ocurrencia de alguno de los caracteres de una cadena dada en otra
      strstr busca una cadena dentro de otra
      strtok parte una cadena en una secuencia de tokens
      strxfrm transforma una cadena en su forma de colación (??)
      strrev invierte una cadena