El lenguaje de Programacion “C” by mercy2beans111

VIEWS: 0 PAGES: 17

									Calculo Numérico                                                              Introducción al Lenguaje C
                                                Turbo C++

Introducción.—
    El lenguaje de programación que veremos a continuación es el Lenguaje C++. Este lenguaje pertenece a la
clase de lenguajes comunmente llamados híbridos, pues soportan dos filosofías distintas de programación: la
primera la que veremos a lo largo de este curso: la programación estructurada; la segunda de estas filosofías
es la programación orientada a objetos, POO.
   El lenguaje C++ es algo así como una versión mejorada del lenguaje C, con lo cual cualquier programa
escrito en el lenguaje C también es C++. El Lenguaje C++ es un lenguaje de programación de propósito ge-
neral, es decir, es posible escribir cualquier tipo de programas con él, incluyendo programas específicos de
tipo matemáticos.
Comencemos.—
   La única forma de aprender un nuevo lenguaje de programación es escribiendo algunos programas en él y
describirlo a partir de estos.
                               Imprimir las palabras
                               Hola Mundo, esto es “C++”.

 #include <iostream.h>

 main()
 {
    cout << "Hola Mundo, esto es \"C++\"\n";
 }


 Un programa en C++ cualquiera sea su tamaño, consta de funciones y variables. Una función contiene
 proposiciones que especifican las operaciones de cálculo que se van a realizar, y a las variables que alma-
 cenan los valores utilizados durante los cálculos. Nuestro ejemplo es una función llamada main. Normal-
 mente se tiene la libertad de dar cualquier nombre que se desee a una función, pero main es especial, el
 programa siempre debe tener un main, porque el programa comienza a ejecutarse a partir de él.

 La primera línea:
                        #include <iostream.h>
   Indica al compilador que incluya información acerca de algunas de las funciones que luego se usaran en el
   programa y que están definidas en esta biblioteca o comúnmente llamada “librería”.

 Un método para comunicar datos entre las funciones es que la función que llama, proporciona una lista de
 valores, llamados argumentos, a la función a la que se está invocando. Los paréntesis que están después
 del nombre de la función encierran a la lista de argumentos. En este ejemplo, main está definido para ser
 una función que no espera argumentos, lo cual esta indicado por la lista vacía (). Las proposiciones de una
 función están encerradas entre llaves {...}, las que indican el comienzo y el final del bloque de instruccio-
 nes de un programa.

 En nuestro ejemplo
                     cout << "Hola Mundo, esto es \"C++\"\n";
   cout es un identificador asociado a un dispositivo de salida, en particular la pantalla, este identificador esta
   definido en la librería <iostream.h> y lo que hace el operador << es enviar hacia la pantalla los ar-
   gumentos recibidos.

   \" y \n son denominadas secuencias de escape.
  \" es el caracter comillas, la función que cumple aquí es evitar que se malinterprete un final de string (ca-
  dena de caracteres).
  \n es para que se imprima una nueva línea luego de imprimir el o los argumento/s que contiene.
  Si se omite \n, no habrá avance de línea puesto cout no lo proporciona.

   Nuestro programa también se hubiera podido escribir así:
   #include <iostream.h>
   main()
   {
     cout << "Hola ";
     cout << "Mundo ";
     cout << "Esto es \"C++\"\n";
   }


1) Variables y Expresiones Aritméticas.—
Facultad de Ciencias de la Administración                                                             Página 1
Calculo Numérico                                                            Introducción al Lenguaje C
                                              Turbo C++
   El siguiente Programa utiliza la formula ºC=(5/9)x(ºF-32) para imprimir una tabla de temperaturas Fah-
   renheit y sus equivalentes en grados centígrados o Celsius.
   #include <iostream.h>
   /* Imprime la tabla Faherenheit-Celsius para fahr=0,20,40,...,300 */
   main()
   {
     int fahr,celsius;
     int minima,maxima,paso;
       minima=fahr=0;             // temperatura mínima de la tabla
       maxima=300;                // temperatura máxima de la tabla
       paso=20;                   // tamaño del incremento
       while(fahr <= maxima)
       {
         celsius=5*(fahr-32)/9;
         cout << fahr << "\t" << celsius;
         fahr=fahr+paso;
       }
   }
   Las dos líneas encerradas entre /* y */ o también los caracteres después de // son comentarios.
 En C++ se deben declarar todas las variables antes de su uso, generalmente al principio de la función y
  antes de cualquier proposición ejecutable. Una declaración notifica las propiedades de una variable, cons-
  ta de un nombre de tipo y una lista de variables como:
           int fahr,celsius;
   "\t hace que los valores de los dos enteros fahr y celsius se impriman como valores enteros con una ta-
   bulación (\t) entre ellos.
 El ciclo while funciona de la siguiente manera: se prueba la condición entre paréntesis (fahr <= maxima).
   De ser verdadera, el cuerpo del ciclo (definido entre llaves) se ejecuta. El cuerpo del ciclo puede tener una
   o mas proposiciones, si solo tiene una, no es necesario encerrarla entre llaves como por ejemplo:
           while(i < j) i=i*2;
 La razón de multiplicar por 5 y después dividir por 9 es que en C++ como en la mayoría de los otros len-
 guajes, la división de enteros trunca el resultado: cualquier parte fraccionaria se descarta puesto que 5 y 9
 son enteros, 5/9 sería truncado a 0 y todas las temperaturas se reportarían como 0.
 Existe un problema aquí, debido a que se ha utilizado aritmética de enteros, las temperaturas Celsius no
 son muy precisas; por ejemplo, 0 ºF es en realidad aproximadamente -17.78 ºC no 17 ºC como se reportar-
 ía. Para obtener soluciones mas precisas se debe utilizar aritmética de punto flotante, a saber:

   #include <iostream.h>
   /* Imprime la tabla Faherenheit-Celsius para fahr=0,20,40,...,300                                 */
   main()
   {
     float fahr,celsius;                // Punto flotante de simple precision
     int minima,maxima,paso;            // Tipo de dato entero
       minima=fahr=0;             // Temperatura mínima de la tabla
       maxima=300;                // Temperatura máxima de la tabla
       paso=20;                   // Tamaño del incremento
       while(fahr <= maxima)
       {
         celsius=(5.0/9.0)*(fahr-32.0);
         cout << fahr << "\t" << celsius;
         fahr=fahr+paso;
       }
   }

 Existen suficientes formas de escribir un programa para una tarea en particular. Observemos el mismo
  programa de temperaturas.
   #Include <iostream.h>
   /* Imprime la tabla Faherenheit-Celsius para fahr=0,20,...,300 */
   main()
   {
     int fahr;

       for(fahr = 0 ; fahr <= 300 ; fahr = fahr + 20)

Facultad de Ciencias de la Administración                                                           Página 2
Calculo Numérico                                                           Introducción al Lenguaje C
                                              Turbo C++
              cout << fahr << "\t" << (5.0/9.0)*(fahr-32.0);
  }
  Produce los mismos resultados que los programas anteriores, pero ciertamente se ve diferente. Un
     cambio importante es la eliminación de la mayoría de las variables; solo permanece fahr y la hemos
     hecho entera (int).
 La proposición for es un ciclo, una forma generalizada del while. Dentro de los paréntesis existen tres sec-
 ciones separadas por punto y coma. La primera vez, la inicialización se ejecuta una vez, antes de entrar
 propiamente al ciclo. La segunda sección es la condición que controla el ciclo: fahr <= 300;. Esta
 condición se evalúa si es verdadera, el cuerpo del ciclo (en este caso un simple cout) se ejecuta. Después
 el incremento de avance: fahr=fahr+20; se ejecuta y la condición se vuelve a evaluar. El ciclo ter-
 mina si la condición es falsa. Tal como con el while, el cuerpo del ciclo puede ser una proposición senci-
 lla o un grupo de proposiciones encerradas entre llaves. La inicialización, la condición y el incremento
 pueden ser cualquier expresión. La elección entre el while y el for es arbitraria y se basa en aquello que
 parezca más claro. El for es por lo general apropiado para ciclos en los que la inicialización y el incre-
 mento son expresiones sencillas y lógicamente relacionadas, puesto que es mas compacto que el while y
 mantiene reunidas en un lugar a las proposiciones que controlan el ciclo.
 Una observación final antes de dejar el tema de conversiones de temperaturas. Es una mala práctica poner
 “números mágicos” como 300 y 20 en un programa, ya que proporciona muy poca información a quien
 tenga que leer el programa y son difíciles de modificar en forma sistemática.
   Una línea #define define un nombre simbólico o constante simbólica, como una cadena de caracteres
   especial:
                   #define nombre texto de reemplazo

   #include <iostream.h>

   #define MAXIMA 300                              // TEMPERATURA FAHRENHEIT MAXIMA
   #define MINIMA 0                                // TEMPERATURA FAHRENHEIT MINIMA
   #define PASO 20                                // TAMAÑO DEL INCREMENTO

                  /* Imprime la tabla Faherenheit-Celsius                       */

   main()
   {
     int fahr;
    for(fahr = MINIMA ;fahr <= MAXIMA; fahr = fahr + PASO)
                  cout << fahr << "\t" << (5.0/9.0)*(fahr-32.0);
   }

   *Nótese que no hay punto y coma después de la línea #define.
Todo lo visto, debe servir para orientarlos en la filosofía del lenguaje, en el estilo y estructuración. Ahora
dejaremos un poco estas ejemplificaciones y seremos más concretos en los aspectos de este lenguaje.
3) Tipos, operadores y expresiones
   Nombre de los identificadores
 Existen algunas restricciones en los nombres de las variables y de las constantes.
 El primer caracter debe ser una letra. El caracter de subrayado también es válido, pero no es aconsejable
  que una variable comience con tal caracter, dado que la mayoría de las rutinas de las librerías anexas usan
  tal caracter como característica en sus nombres.
 Las letras mayúsculas y minúsculas son distintas, de tal manera x y X son dos nombres diferentes. La
  práctica tradicional y mas aconsejable en C++ es usar letras minúsculas para nombres de variables y todo
  en mayúsculas para nombres de constantes.
 Las palabras claves o reservadas, no se deben utilizar como variables. Todas deben escribirse con minús-
  culas.
 Los siguientes identificadores son palabras reservadas:
      auto                      double                    int                        struct
      break                     else                      long                       switch
      case                      enum                      register                   typedef
      char                      extern                    return                     union
      const                     float                     short                      unsigned
      continue                  for                       signed                     void
      default                   goto                      sizeof                     volatile
      do                        if                        static                     while

Facultad de Ciencias de la Administración                                                           Página 3
Calculo Numérico                                                             Introducción al Lenguaje C
                                                   Turbo C++
      auto                          double                   int                        struct
     asm                           _cs                      _ds                        _es
     catch                         friend                   operator                   public
     class                         inline                   overload                   template
     _ss                           cdecl                    far                        huge
     delete                        new                      private                    this
     interrupt                     near                     pascal                     throw
     try                           virtual                                          
   Tipos básicos de datos, declaraciones.
  Las declaraciones especifican la interpretación dada a cada identificador (variable o constante). El formato
  sería:
      especificador-categoría-almacenamiento         especificador-de-tipo tipo     lista de declaraciones;
   Especificadores de categoría de almacenamiento.
    auto
    register
    static
    extern
   Existen dos categorías de almacenamiento: la automática y la estática. Los objetos automáticos son lo-
    cales a un bloque y son descartados al salir del bloque. Las declaraciones dentro de un bloque crean ob-
    jetos automáticos si no se emplea el especificador auto.
   Los objetos declarados como register son automáticos y sugiere que se harán acceso frecuente a los ob-
    jetos declarados y se almacenan (si es posible) en los registros rápidos de la máquina.
   Los objetos estáticos pueden ser locales a un bloque o externos a todos los bloques, pero en cualquier
    caso, mantiene su valor entre las salidas y reentradas a funciones o bloques. Las palabras reservadas sta-
    tic y extern declaran objetos estáticos.
   Especificadores de tipos de datos.
    signed
    unsigned
    long
    short
  Estos especificadores de tipos se pueden aplicar a los tipos enteros y a los tipos caracteres.
   Modificadores de acceso.—
    C++ incorpora dos especificadores de tipos, que se utilizan para controlar las formas en que un pro-
    grama accede o modifica las variables que usa. Estas modificadores son:
    const
    volatile
  Todas las combinaciones posibles de especificadores de tipos y tipos posibles en Turbo C++.—
       TIPO                           LONGITUD                                  RANGO
      1. void                           ------         Este tipo tiene tres tipos de usos que luego se explica-
                                                                                  ran.
      2.    char                         8 bits                                -128 a 127
      3.    unsigned char                8 bits                                   0 a 255
      4.    signed char                  8 bits                                -128 a 127
      5.    enum                         16 bits                           -32.768 a 32.767
      6.    int                          16 bits                           -32.768 a 32.767
      7.    unsigned int                 16 bits                                  0 a 65.535
      8.    signed int                   16 bits                           -32.768 a 32.767
      9.    short int                    16 bits                           -32.768 a 32.767
      10.   unsigned short int           16 bits                                  0 a 65.535
      11.   signed short int             16 bits                           -32.768 a 32.767
      12.   long int                     32 bits                   -2.147.483.648 a 2.147483.647
      13.   unsigned long                32 bits                                  0 a 4.294.967.295
      14.   signed long int              32 bits                   -2.147.483.648 a 2.147483.647
      15.   float                        32 bits                   3.4 * (10**-38) a 3.4 * (10**+38)
      16.   double                       64 bits                 1.7 * (10**-308) a 1.7 * (10**+308)
      17.   long double                  80 bits                3.4 * (10**-4932) a 1.1 * (10**+4932)
    Para los ejemplos: 4,8,11,14; se puede omitir declararlos con el especificador signed. Sin embargo
     para obtener un tipo de dato no signado se debe especificar unsigned, este especificador no tiene efec-
     to con los tipos de datos de punto flotante.


Facultad de Ciencias de la Administración                                                             Página 4
Calculo Numérico                                                               Introducción al Lenguaje C
                                               Turbo C++
    El tipo void (nada) tiene tres usos.
   1. Cuando se coloca como declarador de tipo en una función significa que es una función que no retorna
      valor alguno.
   2. Cuando se declaran los argumentos de una función, colocar void entre los paréntesis, indique de ma-
      nera explícita que la función no recibe valores de argumento.
   3. Como declarador para punteros genéricos.
   Las constantes.—
  Existen varias clases de constantes, a saber:
  1.    constantes enteras
  2.    constantes de caracteres
  3.    constantes de punto flotante
  4.    constantes de enumeración
  5.    constantes simbólicas
  Ejemplos de cada una:
   1. Las constantes enteras pueden ser de cualquiera de los tipos enteros, ademas pueden tomar valores
      decimales, octales o hexadecimales:
       Tipos de Enteros    Enteros decimales         Enteros octales       Enteros hexadecimales
       int 123             012                       0x1a o 0X1A
       long 1234567l ó L   0123456l ó L              0x1abcdl ó L, ó 0X1ABCDl ó L
       unsigned            1234u ó U                 012u ó U            0x1au ó 0X1AU
       unsigned long       12345678 ul ó UL          0123456ul ó UL      0x1abcul ó UL, ó 0X1ABCul ó UL
 Los sufijos en cada constante no son necesarios especificar, sin embargo pueden ayudar a determinar bien
 que tipo de datos es el que es constante.
   2. Las constantes de caracteres pueden ser de dos tipos:
 El primer tipo, es el que corresponde a un caracter que es igual al valor ASCII del caracter representado, es-
 te deberá estar encerrado entre apóstrofe: ´A´, ´x´, ´h´ , etc.
 También pertenecen a este tipo las denominadas “secuencias de escape”, las constantes de caracter, están
 representadas de igual forma con la salvedad de que después del apóstrofe le sigue una barra invertida, co-
 mo:
        ´\a´ caracter de alarma (beep)            ´\\´    diagonal invertida
        ´\b´ retroceso                         ´\?´       interrogación
        ´\f´ avance de hoja                    ´\´´       apóstrofe
        ´\n´ avance de linea                    ´\”´      comillas
        ´\r´ regreso de carro                   ´\000´    número octal
        ´\t´ tabulador horizontal                ´\xhh´ número hexadecimal
        ´\v´ tabulador vertical                  ´\0´     caracter nulo
  El segundo tipo es un conjunto de caracteres encerrados entre comillas llamados por lo general strings:
        “HOLA QUE TAL ESTO ES UN EJEMPLO”
   3. Las constantes de punto flotante tienen un punto decimal o un exponente y/o los sufijos f ó F y l ó L.
        Tipo float      123.45f ó F                      1.234e+34
        Tipo double      123.478283829232lf ó lF          1.23478283e+200
        Tipo long double 1.267282749502238737362732LF o Lf 1.26727495e+450
   4. Otra forma de definir las secuencias de escape a través de constantes de enumeración. Las constantes
      de enumeración se definen del siguiente modo:
        enum boolean {FALSE,TRUE};
  La primera constante de enumeración dentro de las llaves tiene el valor 0 la siguiente el 1. Si no se les
  asignan valores explícitos en orden ascendente, la inicialización comienza desde 0 cero y continua en or-
  den progresivo hasta terminarse la lista de declaraciones.
     enum       escapes             {          BELL=´\a´,RETROCESO=´\b´,TAB=´\t´,              NVALIN=´\n´,
  VTAB=´\v´,RETURN=´\r´};
   5. Las constantes simbólicas son constantes que pueden ser expresiones de cualquier tipo. Una constan-
      te de este tipo se define de la siguiente manera:
           #define texto     nombre de reemplazo
        Ejemplos:
           #define BELL ´\007´              // caracter campana usando secuencias de escape en octal
           #define BELL ´\x7´               // caracter campana usando secuencias de escape en hexadecimal

Facultad de Ciencias de la Administración                                                          Página 5
Calculo Numérico                                                                  Introducción al Lenguaje C
                                                   Turbo C++
             #define BELL ´\a´                 // caracter campana usando secuencias de escape
          Tres formas diferentes de definir el caracter campana ASCII.
             #define TRUE 1
             #define FALSE 0
          Muy útil, dado que el tipo de dato booleano no existe en C++.
             #define CADENA “Hola mundo, esto es C++”
             #define MAXIMO 12523646342.234LF
             #define COMILLAS ´\”´
  Todas las constantes también pueden ser declaradas con el modificador de acceso const.
             const      int ENTERO=-237;
             const      float PI=3.141592;
             const      double PI_D=3.1415926536;
             const      long double E=2.71828182845904523536
             const      char MSG[]=“Hola mundo, esto es C++”;
Operadores.—
  o   Aritméticos.
      Los operadores aritméticos son:
      *     ,      /     , % (operador módulo para enteros)
      +     ,      -
      en orden de precedencia.
  o Lógicos y de relación.
      Los operadores de relación son:
      >     ,      >=      ,    <   ,   <=
      Todos ellos tienen la misma precedencia.
      Bajo ellos en precedencia están los operadores de igualdad:
      ==      ,       !=
      Los operadores aritméticos tienen mayor precedencia que los operadores de relación, una expresión
      como:
                i < lim-1 se toma como         i < (lim-1)   como se esperaría.
      Los operadores lógicos son:
      &&          y        ||   (and y or)
  o Operadores de Incremento y decremento.

      El lenguaje C o el C++ proporcionan dos operadores muy propios y poco comunes. El operador de au-
      mento ++ agrega 1 a su operando, ent tanto que el operador de disminución -- le resta 1.
      Los dos operandos son susceptibles de ubicarse como prefijos o sufijos, por ejemplo:
      i = i + 1;           es equivalente a:       ++i, o bien i++
      i = i - 1;           es equivalente a:        --i, o bien i--
      (++i,--i) o (i++,i--) Para el primer paréntesis los efectos del operador son incrementar o de-
      crementar a las variables antes de que su valor se utilice, para el segundo paréntesis es incrementar o
      decrementar las variables despues de utilizada la variable.
  o Operadores de asignación y expresiones.
      Si expr1 y expr2 son dos expresiones, entonces:
                   expr1 op= expr2
      es equivalente a:
               expr1 = (expr1 ) op (expr2 );
      donde op puede ser cualquiera de:
      +       ,       - , * , / , %
      <<      ,       >> , & , ^ , | (operadores para manejos de bits)
      Ejemplos:
              x *= (y + 1);                           x = x * (y + 1);
              x += 2;                                 x = x + 2;

Facultad de Ciencias de la Administración                                                           Página 6
Calculo Numérico                                                                   Introducción al Lenguaje C
                                                   Turbo C++
      Aquí una lista mas completa:
      += , -= , *= , /= , %= , &= , ^= , |= , <<= , >>= .
   o El operador ternario ?.—
      C++ contiene un operador muy potente y conveniente que puede usarse para sustituir ciertas sentencias
      de la forma if-then-else. Este operador toma la forma general:
                    expr1 ? expr2 : expr3 ;
      Ejemplo:
                           x=10;
                           y = (x > 9)        ?    100 :    200 ;
      Es equivalente a:
                       x=10;
                       if(x > 9)
                           y = 100;
                       else
                           y = 200;
      Ambas porciones de código, asigna a la variable y el valor 100.
Control de flujos.—
    Las proposiciones de control de flujo de un lenguaje especifican el orden en que se realiza el procesamien-
to. Ya hemos visto algunas, aquí completaremos el conjunto y seremos específicos en sus declaraciones.
Proposiciones y bloques.—
   Una expresión como x = 0 ó i++ o cout << ... se convierte en una proposición cuando va seguida de un
punto y coma, como en:
   x = 0;
   i++;
   cout << .... ;
    En C o C++, el punto y coma es un terminador de proposición. Las llaves { } se emplean para agrupar de-
claraciones y proposiciones dentro de una proposición compuesta o bloque. No hay punto y coma después de
la llave } de cierre de un bloque.
  o   If-else.—
Formalmente la sintaxis es:

                    if(expresión)             Ejemplo:                  if(a < b)
                         proposición1;                                       z = a;
                    else                                                [else
                        proposición2;                                        z = b;]

   Los puntos y comas en proposicion1 y proposición2 dan la aclaración mencionada. Los corchetes en la
   cláusula else indica que ésta es opcional. Debido a esto, existe una ambigüedad cuando un else se omite de
   una sentencia if anidada.
   Por ejemplo:
                                                                                       if(n > 0) {
              if(n > 0)                  el else va con el if mas interno
                                                                                            if(a < b)
                   if(a < b)             como se muestra en el sangrado. Si
                                                                                               z = a;
                      z = a;             esto no es lo que se desea, se deben
                                                                                       }
                   else                  utilizar las llaves para forzar la aso-
                                                                                       else
                      z = b;             ciación correcta o deseada.
                                                                                            z = b;

o Else-if.—
      La construcción es:

                    if(expresión)                 Esta secuencia de proposiciones if es la forma general de es-
                         proposición1;            cribir una decisión múltiple. Las expresiones se evalúan en
                    else if(expresión)            orden, si cualquier expresión es verdadera, la proposición
                         proposición2;            asociada con ella se ejecuta, y esto termina toda la cadena.
                    else if(expresión)            Como siempre, el código para cada proposición es una pro-
                         proposición3;            posición simple o un grupo dentro de llaves.
                    else
                                                  La parte del ultimo else maneja el caso “ninguna de las ante-
                        proposición4;
                                                  riores”, esta también puede omitirse



Facultad de Ciencias de la Administración                                                               Página 7
Calculo Numérico                                                              Introducción al Lenguaje C
                                                 Turbo C++
o Switch.—
     La proposición switch es una decisión múltiple que prueba si una expresión coincide con uno de un núme-
     ro de valores constantes (casos) enteros, y traslada el control adecuadamente:

               switch(expresión) {                          Dentro de cada case y como proposición final,
                case exp-constante : proposición1;          debe ir la proposición break, para que la selec-
                case exp-constante : proposición2;          ción culmine con la ocurrencia del caso único que
                case exp-constante : proposición3;          se ha cumplido. La clausula default es opcional.
                default : proposición4;
               }

  o     Ciclos - whiles - for - do-while.—
     Ya hemos visto anteriormente los ciclos for y while.
             while(expresión)
                 proposición;
     La proposición for:
                           for(expr1; expr2; expr3)
                                   proposición;
     es equivalente a:
                           expr1;
                           while(expr2) {
                                  proposición;
                                  expr3;
                           }
 o      El usar while o for es principalmente cuestión de preferencia personal. El for se prefiere cuando existe
        inicialización simple e incrementos, puesto que mantiene las proposiciones de control del ciclo juntas y
        visible al principio del mismo.
 o      Tanto el índice como el límite de un ciclo for en C++ pueden ser alterados desde dentro del ciclo, y la
        variable del índice retiene su valor cuando las iteraciones terminan por cualquier razón. Debido a que
        los componentes de for son expresiones arbitrarias, sus ciclos no están restringidos a progresiones
        aritméticas.
 o      Los ciclos while y for verifican al principio la condición de término. En contraste, el tercer ciclo en
        C++, el do-while, prueba al final después de realizar cada paso a través del cuerpo del ciclo, el cual se
        ejecuta siempre por lo menos una vez.
La sintaxis del do es:
             do
                  proposición;
             while(expresión);
     El ciclo do-while en C++ es igual que el while pero la salvedad está en que la verificación de la condición
     se hace al final. Luego si el ciclo va acompañado de varias proposiciones deben encerrarse entre llaves,
     después del do y antes del while.
Operaciones de entrada/salida.—
      El archivo de cabecera iostream.h, está definido en C++ y se usa para las operaciones de entrada y sali-
      da. Por ejemplo:
           cout << “Me gusta Turbo C++.\n”;
      muestra en pantalla “Me gusta Turbo C++.” Seguido por la combinación de un salto de carro y salto de
      línea. En C++, el símbolo << tiene un cometido más amplio sigue siendo el operador de desplazamiento
      a la izquierda, pero cuando se usa como se muestra en este ejemplo, también es un operador de salida. La
      palabra cout es un identificador que esta asociado a la pantalla. Al igual que C, C++ permite la redirec-
      ción de la E/S, pero por lo que respecta a esta explicación, asumiremos que cout se refiere a la pantalla.
      Se puede usar cout y el símbolo << para mostrar cualquiera de los tipos de datos incorporados o predefi-
      nidos, además de las cadenas de caracteres.
      Si nuestro programa requiere que ingresemos algo desde el teclado, procedemos por ejemplo:
           cin >> i;
      El número se lee a través del teclado usando la sentencia cin. El identificador cin se refiere al teclado.
      En general se usa cin >> para cargar un valor en una variable cualquiera de los tipos básicos de datos o
      cadenas.



Facultad de Ciencias de la Administración                                                            Página 8
Calculo Numérico                                                             Introducción al Lenguaje C
                                               Turbo C++
    Uso de los manipuladores.—
    El sistema de E/S de C++ incluye una forma de alterar los parámetros de formato de E/S. Para esto se
    usan unas funciones especiales llamadas manipuladores, que se pueden incluir en las operaciones de
    E/S.

    Los manipuladores estándar se muestran a continuación:

     Manipulador                                         Propósito                              Entrada/Salida
     dec                   Formato de datos numéricos en decimal.                             Entrada y Salida
     endl                  Salida de un caracter de nueva linea y vaciado del flujo.          Salida
     ends                  Salida de un caracter nulo.                                        Salida
     flush                 Vaciado de un flujo.                                               Salida
     hex                   Formato de datos númericos en hexadecimal.                         Entrada y Salida
     oct                   Formato de datos númericos en octal.                               Entrada y Salida
     resetiosflag(long f) Desactiva los indicadores especificados en f.                       Entrada y Salida
     setbase(int base)     Establece el número de la base a base.                             Salida
     setfill(int c)        Establece el caracter de relleno a c.                              Entrada y Salida
     setiosflag(long f)    Activa los indicadores especificados en f.                         Entrada y Salida
     setprecision(int p)   Establece el número de dígitos a mostrar después del punto deci- Entrada y Salida
                           mal.
     setw(int w)           Establece la anchura de campo a w.                                 Entrada y Salida
     ws                    Hace que se ignoren los espacios en blanco iniciales.              Entrada

    Para acceder a esos manipuladores, se debe incluir el archivo iomanip.h en el programa. Se puede usar
    un manipulador como parte de la expresión de E/S.
    He aquí un ejemplo de programa que se usa para cambiar el formato de la salida:
    #include <iostream.h>
    #include <iomanip.h>

    main(void)
    {
      cout << setprecision(2) << 1000.243 << endl;
      cout << setw(30) << “Hola esto es Turbo C++.”;

        return 0;
    }
        El programa produce esta salida:
    1000.24
                   Hola esto es Turbo C++.
Estructura de Bloques.—
      C o C++ no es un lenguaje estructurado en bloques, puesto que las funciones no se pueden definir de-
  ntro de otras funciones. Por otra parte las variables (incluyendo la inicialización) pueden seguir a la llave
  izquierda que indica cualquier proposición compuesta, no solo la que inicia a una función. Las variables
  pueden declaradas de esta manera, cualquier nombre idéntico de variables de bloques más externos, son
  totalmente distintas, y permanecen hasta que se encuentra la llave derecha que se corresponde con la ini-
  cial. Por ejemplo en:
             if(n > 0) {
                int i;
                for(i=0;i < n;++i)
                     .......
             }
             i=3;
  La i del bloque if-else se declara al entrar al bloque y se destruye al salir de él, es por ello que no tiene
  nada que ver la variable i externa al bloque.

Facultad de Ciencias de la Administración                                                          Página 9
Calculo Numérico                                                             Introducción al Lenguaje C
                                              Turbo C++
Inicialización.—
     La inicialización de una variable puede llevarse a cabo en el momento de su declaración. Para ello se
  procede a declararla y luego el signo igual y los valores de inicialización, por ejemplo:
           int i=0;
           char letra='A';
           double sala=200.39;
  En ausencia de declaración explícita, se garantiza que las variables externas y estáticas se inicializan en 0;
  las variables automáticas y tipo registro tienen valores iniciales indefinidos (basura).
Arreglos o Arrays.—
     En C o C++ existe una fuerte relación entre apuntadores y arreglos. Tan fuerte que deben discutirse si-
  multáneamente. Cualquier operación que se pueda llevar a cabo por indexación de un arreglo, también
  puede realizarse con apuntadores (punteros). La versión con apuntadores será por lo general más rápida,
  pero más difícil de entender para los no iniciados en este lenguaje.
  Por lo pronto veremos, el formato para la declaración de arreglos es:
  especificador-categoría-almacenamiento especificador-de-tipo tipo_de_arreglo nombre[tamaño];
  Podemos inicializar un arreglo de la siguiente manera:
  Arreglo de caracteres:
           char mensaje[20];
  o bien
           char mensaje[]={
              'H','o','l','a',' ','c','o','m','o',' ','e','s','t','a','n','\0'
           };
  o bien
           char mensaje[]="Hola como están";
  Si el arreglo debe definirse sin valores iniciales, se debe especificar la primera definición, sino la tercera
  es la mas recomendable sobre la segunda.
  Arreglo de enteros:
           int nument[10];
           int nument[]={0,1,2,3,4,5,6,7,8,9};
  define un arreglo nument de tamaño 10, esto es, un bloque de 10 objetos consecutivos llamados nu-
  ment[0],nument[1],...,nument[9].
  De esta forma pueden declarse arreglos de cualquier tipo.
Arreglos Multidimensionales.—
     C admite arreglos multidimensionales. La forma mas simple de un arreglo multidimensional es el arre-
  glo bidimensional. Esencialmente, un arreglo bidimensional es un arreglo de arreglos unidimensionales.
  Su declaración es la siguiente:
  especific.-categ.-almacen. especificador-de-tipo         tipo_de_arreglo     nombre[tamaño_fila] [tama-
  ño_columna];
  Por lo tanto para definir un arreglo num de enteros bidimensional de tamaño 10,20 se definirá:
           int num[10][20];
  Para acceder a la posición 3,2 se hace:
           num[2][1]=20;
  La inicialización es de la siguiente manera:
           int num[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
Funciones.—
     En el lenguaje C++ una función proporciona una forma conveniente de encapsular algunos cálculos,
  que se pueden emplear después sin preocuparse de su implantación. Con funciones diseñadas adecuada-
  mente, es posible ignorar como se realiza un trabajo; es suficiente saber qué hace. El lenguaje C++ hace
  que el uso de las funciones sea fácil, conveniente y eficiente.
  Una definición de función tiene la siguiente forma:
  tipo_de_retorno nombre_de_funcion(declaración_de_parámetros_formales)
  {
     declaraciones;
     proposiciones;
  }

Facultad de Ciencias de la Administración                                                          Página 10
Calculo Numérico                                                             Introducción al Lenguaje C
                                               Turbo C++
  Para esto veremos un ejemplo:
  1. /******************Archivo potencia.cpp**********************/
  2. #include <iostream.h>
  3.
  4. long double potencia(int x, int y); // prototipo de la función
  5.
  6. main(void)                  // función que no recibe argumentos
  7. {
  8. int i;                // variable i local a la función
  9. for(i=0;i < 20;++i)
  10.           cout << potencia(2,i)<< potencia(3,i);
  11.       return 0;
  12. }
  13.
  14. long double potencia(int x, int y) //Retorna un valor long double
  15. {
  16.       long double i;     // variable i local a la función
  17.       for(i=1;y > 0;--y) // ciclo for con distintas variables
  18.         i*=x;           // operador i=i*x;
  19.       return i;
  20. }
  Comencemos el análisis de este programa:
  La segunda linea, ya todos la conocen, es uno de las primeras instrucciones de lo que se llama preproce-
  samiento, y es el primer paso antes de la compilación. En particular #include indica que se debe incluir in-
  formación acerca de algunas funciones que se utilizaran en el programa, como ya se sabe. Pero lo que mas
  nos interesa es el contenido en concreto de los archivos de encabezamiento (biblioteca de funciones, li-
  brería, etc.) , header de allí la extensión .h . Estas librería contienen lo que se llama en C++ el prototipo de
  la función, que vendría a ser algo así como su declaración explícita. Por lo tanto todas las funciones, salvo
  main, tienen un prototipo definido en algún lugar, y si no lo tiene, por ejemplo si ignoramos potencia() con
  dos barras consecutivas:
               3.    //     long double potencia(int x, int y);
  el compilador indicará el siguiente error:
  1.   Compiling ..\MIO\POTENCIA.CPP:
  2.   Error ..\MIO\POTENCIA.CPP 10: Function 'potencia' should have a prototype
  3.   Warning ..\MIO\POTENCIA.CPP 10: Call to function 'potencia()' with no prototype
  4.   Warning ..\MIO\POTENCIA.CPP 10: Call to function 'potencia()' with no prototype

  1.   Compilando ..\MIO\POTENCIA.CPP comienzo de la compilación
  2.   Error ..\MIO\POTENCIA.CPP linea 10: Función 'potencia' debe tener un prototipo.
  3.   Advertencia.. \MIO\POTENCIA.CPP 10: Llamada a la función 'potencia()' sin un prototipo.
  4.   Advertencia.. \MIO\POTENCIA.CPP 10: Llamada a la función 'potencia()' sin un prototipo.


  La linea 3 y 4 se debe a que potencia() fue invocada dos veces.

  Por lo tanto declarar el prototipo de la función a utilizar es muy importante e imprescindible, puesto que
  no compilaremos el programa adecuadamente. La porción de código que nos interesa más es la que va del
  numero de linea 14 a línea 20. Estas líneas contienen una función cuyo prototipo fue declarado explícita-
  mente en la línea 3. Esta función retorna un valor long double y recibe como parámetros dos valores ente-
  ros. El valor de retorno, y el control a la función que llama o el sistema operativo en el caso de main, es
  reintegrado a través de la sentencia return en las líneas 11 y 18. Return puede tener a continuación cual-
  quier expresión de cualquier tipo, si es necesario el valor se convertirá al tipo de retorno.
- Argumentos.—
  En C++, todos los argumentos de una función se pasan por valor. Esto significa que la función que se in-
  voca recibe los valores de sus argumentos en variables temporales y no en las originales. Esto es, la fun-
  ción que se invoca no puede alterar directamente una variable de la función que hace la llamada; solo pue-
  de modificar su copia privada y local.
  Cuando es necesario, es posible hacer que una función modifique una variable dentro de una rutina invo-
  cada. La función que llama debe proporcionar la dirección de la variable que se cambiará (técnicamente
  un apuntador a la variable) y la función que se invoca debe declarar que el parámetro sea un apuntador y
  tengo acceso a la variable indirectamente a través de él.
  Veamos algunos ejemplos:
     Supongamos que estamos haciendo un ordenamiento de elementos de un arreglo de enteros. Dicho or-
  denamiento requiere en algún momento, el intercambio entre dos elementos de dicho arreglo, y para reali-
  zar tal tarea, recurrimos a una función:
Facultad de Ciencias de la Administración                                                            Página 11
Calculo Numérico                                                           Introducción al Lenguaje C
                                             Turbo C++
  void intercambio(int x, int y)
  {
      int temp;
      temp=x;
      x=y;
      y=temp;
  }
  Y el problema fundamental aquí es que el intercambio de variables no afecta a las variables enviadas co-
  mo argumentos sino solo a sus copias privadas y locales. Por el contrario la siguiente función realiza el
  trabajo que deseamos obtener como resultado:
  void intercambio(int &x, int &y)
  {
      int temp;
      temp=x;
      x=y;
      y=temp;
  }
  x y y son apuntadores implícitos a enteros y por lo tanto cumplen con el requisito de paso de valores por
  referencia, requisito fundamental para que una función modifique el contenido de la variable que se pasa
  como argumentos.
  La historia es diferente a la hora de hacer pasajes de valores del tipo arrays o arreglos como argumentos.
  Cuando el nombre de un arreglo es pasado como argumento, el valor que se pasa a la función es la locali-
  zación o la dirección del principio del arreglo -no hay copia de los elementos del arreglo. Al colocarle sub-
  índices a este valor, la función puede tener acceso y alterar cualquier elemento del arreglo por ejemplo:
  A continuación presentamos un programa que realiza una carga de datos en dos matrices, y luego llama a
  una función para realizar la suma de sus elementos y mostrar los resultados en pantalla. De esta manera
  ilustramos el pasaje de parámetros tipo arrays a funciones.
  /**********************************************************************
  **
            CALCULA LA SUMA DE DOS MATRICES DEL MISMO TAMAÑO
  ***********************************************************************
  */
  #include <iostream.h>
  #include <conio.h>
  // prototipo de la función sumar
  void sumar(long double a[][50],long double b[][50],int m,int n);
  void main(void)           // función que no retorna valor                         void,    "nada"
  {
    long double a[50][50],b[50][50];
    int m,n,i,j;
      clrscr(); //Limpia la pantalla, prototipo definido en conio.h
      cout << "Ingresar Cantidad filas=> "; // prototipo definido en iostream.h
      cin >> m;                        // prototipo definido en iostream.h
      cout << "Ingresar Cantidad Columnas => ";
      cin >> n;
  /* Leer datos de la matriz del teclado */
      for(i = 1;i <= m;i++)
        for(j = 1;j <= n;j++)
        {
              cout << "A[" << i << "," << j << "] => ";
              cin>> a[i][j];
              cout << "B[" << i << "," << j << "] => ";
              cin >> b[i][j];
        }
      sumar(a,b,m,n); // paso de valores matrices a y b, enteros m y n
  // Resultado de sumar A + B
    cout << "\nMatriz A modificada \n\r";
    cout << "A[1,1] =" << a[1][1];
      getch(); // Espera por una tecla; prototipo definido en conio.h
  }
  void sumar(long double a[][50], long double b[][50],int m,int n)
  {
    int i,j;
  // Resultado de sumar A + B
    cout << "\nA + B = \n\r";

Facultad de Ciencias de la Administración                                                         Página 12
Calculo Numérico                                                         Introducción al Lenguaje C
                                            Turbo C++
      for(i = 1;i <= m;i++)
      for(j = 1;j <= n;j++)
       cout << "C[" << i << "," << j << "]=" << a[i][j] + b[i][j]<< "\n";
       a[1][1]=3.141592;
  }
  El tamaño de las filas no es necesario, pero el compilador necesita saber cual es el tamaño de la segunda
  dimensión o tamaño de las columnas es por ello que se debe informar al compilador acerca de cuan grande
  es la segunda dimensión.
  Por otro lado si lo que se pasa como argumento a una función es un elemento determinado del array, este
  elemento es tratado como una variable común por lo tanto deberemos pasar su localización en memoria a
  través de un puntero como lo hacemos para las llamadas a referencia con variables.
  Con el siguiente ejemplo, daremos una explicación de como es posible pasar como argumentos a funcio-
  nes, arrays unidimensionales de tres formas distintas:
  #include <iostream.h>
  void mostrar(int num[10]);

  main(void)
  {
    int t[10],i;
    for(i=0;i < 10;++i) t[i]=i;
    mostrar(t);
    return 0;
  }


  /*********método 1***********/
  void mostrar(int num[10])
  {
    int i;
    for(i=0;i < 10;i++) cout << num[i];
  }

  /*********método 2***********/
  void mostrar(int num[]) //reemplazamos el prototipo y la función
  {
    int i;
    for(i=0;i < 10;i++) cout << num[i];
  }

  /*********método 3***********/
  void mostrar(int &num) //reemplazamos el prototipo y la funcion
  {
    int i;
    for(i=0;i < 10;i++) cout << num[i];
  }
  Finalmente el tipo de arreglos más comunes en C++, son los arreglos de caracteres. Los arreglos de carac-
  teres son muy usuales conjuntamente con los punteros a caracteres (strings) dado que en C++ no existe el
  tipo string definido como tipo de dato.
  #include    <stdio.h>
  #include    <iostream.h>
  #include    <ctype.h>
  #include    <conio.h>
  void main(void)
  {
     int b,c,dd,mm,aa;
     char nombre[30],sal='N'; // vector de 30 caracteres
     for(b=0;(b <= 4) && (sal != 'S');b++) // flexibilidad del ciclo for
     {
       clrscr();         // LIMPIAR LA PANTALLA
       fflush(stdin);     // VACIAR EL BUFFER DE ENTRADA DE GETS() PARA NUEVOS
  DATOS
  /*******INGRESOS DE DATOS, LEER UN STRING DESDE EL TECLADO*********/
        cout << "\nHola, ...\nComo te llamas? : "; // \n salto de linea
        gets(nombre);
        cout << "\t\t" << nombre <<"\n"; //\t tabulación
  //LEER Y MOSTRAR LA FECHA EN CUALQUIER FORMATO DD/MM/AA, DD-MM-AA, ETC..
        cout << "Ingresar fecha : ";

Facultad de Ciencias de la Administración                                                      Página 13
Calculo Numérico                                                                Introducción al Lenguaje C
                                              Turbo C++
            cin >> dd >> c >> mm >> c >> aa;
            cout << "\t\t" << dd << c << mm << c << aa << "\n";
  // GETCHE() LEE DE A UN CARACTER CON ECO.
            Cout << "Salir S o N ?: ";
            sal=toupper(getche());   // toupper(char c) convierte a mayúsculas.
        }
    }
  Para finalizar daremos a continuación una lista de las librerías asociadas a turbo C y cuales funciones so-
  portan o definen su prototipo.
  Archivos de cabecera de Turbo C++.

   Nombre del archivo          Funciones relacionadas

   alloc.h                     Asignación dinámica de memoria.
   assert.h                    Define assert().
   bios.h                      Funciones de interfaz con el BIOS.
   conio.h                     Funciones de entrada/salida directa por consola.
   complex.h                   Funciones de manipulación de números complejos
   ctype.h                     Funciones relacionadas con caracteres.
   dir.h                       Funciones relacionadas con directorios.
   dos.h                       Funciones de interfaz con el DOS.
   errno.h                     Define varios códigos de error.
   fcntl.h                     Define varias constantes utilizadas por el sistema de archivos tipo UNIX.
   float.h                     Define los límites de reales en coma flotante.
   graphics.h                  Funciones relacionadas con gráficos.
   io.h                        Funciones de entrada/salida.
   iostream.h                  Funciones de entrada/salida.
   iomanip.h                   Funciones de manipulación de formatos de salida o entrada.
   limits.h                    Define varios límites de enteros.
   locale.h                    Funciones específicas de países.
   math.h                      Funciones matemáticas.
   mem.h                       Funciones de manipulación de memoria.
   process.h                   Funciones de control de procesos.
   setjmp.h                    Requerido por setjmp() y longjmp().
   share.h                     Funciones de soporte a la compartición de archivos.
   signal.h                    Soporte para signal() y raise().
   stdargs.h                   Soporte para argumentos de longitud variable.
   stddef.h                    Define tipos y macros estándar.
   stdio.h                     Funciones de entrada/salida estándar.
   stdlib.h                    Funciones variadas.
   string.h                    Funciones relacionadas con archivos.
   sys/stat.h                  Constantes relacionadas con archivos.
   sys/timeb.h                 Soporta la función ftime().
   sys/types.h                 Define time_t, usado por las funciones de hora.
   time.h                      Funciones de hora y fecha.
   values.h                    Varias constantes dependientes de la implantación.



  A continuación describimos algunas de las funciones más importantes y sus respectivas librerías que defi-
  nen sus prototipos.


Facultad de Ciencias de la Administración                                                             Página 14
Calculo Numérico                                                               Introducción al Lenguaje C
                                              Turbo C++
 PROTOTIPOS DEFINIDO EN CONIO.H
 int getch(void);        int getche(void);
    Ambas funciones leen un caracter desde el teclado y retornan como un entero el valor de la tecla pulsa-
 da, getche() muestra en pantalla el caracter leido, getch() no.
 int putch(int c);
    Esta función muestra un caracter en la pantalla y retorna como un entero el valor del caracter impreso.
 En esta librería están definidas las funciones de manipulación de pantallas de texto. A continuación el lista-
 do de las mas importantes:

  void clrscr(void);                           Limpia la ventana activa.
  void clreol(void);                           Limpia desde la posición del cursor hasta el final de la línea de la
                                               ventana activa.
  void delline(void);                          Borra la linea en donde esta ubicado el cursor.
  void gotoxy(int x, int y);                   Ubica el cursor en las coordenadas establecidas.
  void insline(void);                          Inserta una linea a partir de la posición actual del cursor.
  void textattr(int atributo);                 Define el atributo de texto de la ventana activa, color de frente y de
                                               fondo.
  void textcolor(int color);                   Define el color de frente del la ventana activa.
  void textbackground(int color);              Define el color de fondo de la ventana activa.
  void highvideo(void);                        Muestra el texto en alta intensidad.
  void lowvideo(void);                         Muestra el texto en baja intensidad.
  void normvideo(void);                        Muestra el texto en la intensidad original.
  int wherex(void);                            Devuelve la coordenada x del cursor.
  int wherey(void);                            Devuelve la coordenada y del cursor.
  void textmode(int modo);                     Establece el modo de video.

 Existen mas funciones, y cada una de ellas está explicada y comentada con un ejemplo en la ayuda en linea
 del compilador Turbo C++.
 Describiremos ahora las mas importantes funciones matemáticas definidas en math.h y algunas constantes
 predefinidas:
 long      labs (long x);
    Calcula el valor absoluto de un argumento long y retorna un valor long.
 int       abs       (int x);
    Calcula el valor absoluto de un argumento int y retorna un valor int.
 double acos (double x);
    Calcula el coseno de un argumento double y retorna un valor double.
 double atof (const char *s);
    Convierte un string de caracteres numéricos y retorna un valor double.
 double hypot (double x,double y);
    Calcula la hipotenusa de un triangulo, recibe como argumentos los lados a y b retorna un valor double.
 double poly (double x,int degree,double *coeffs);
    Calcula el valor de una funcion polinomica cuyo orden, valor para calculo y coeficientes son pasados
 como argumentos double. Los coeficientes deben pasarse como un array de valores.
 double pow10 (int p);
    Calcula el valor de una potencia en base 10 elevado a un exponente int y retorna un valor double.
 double asin (double x);
    Calcula el arco seno de un argumento double y retorna un valor double.
 double atan (double x);
    Calcula el arco tangente de un argumento int y retorna un valor double.
 double atan2 (double y,double x);
    Calcula el arco tangente del cociente de dos argumentos double y/x y retorna un valor double.
 double ceil (double x);
    Redondea un valor double x a su entero superior mas proximo y retorna dicho entero como un valor
 double.
 double cos          (double x);
    Calcula el coseno de un argumento double y retorna un valor double.
 double cosh (double x);
    Calcula el coseno hiperbólico de un argumento double y retorna un valor double.
 double exp          (double x);
    Calcula la potencia de un valor double x en base e y retorna un valor double.
 double fabs (double x);

Facultad de Ciencias de la Administración                                                                 Página 15
Calculo Numérico                                                         Introducción al Lenguaje C
                                            Turbo C++
     Calcula el valor absoluto de un argumento double y retorna un valor double.
 double floor (double x);
     Trunca un argumento double a su entero inferior mas proximo y retorna un valor double.
 double fmod (double x,double y);
     Calcula el modulo de un argumento double x divido por un argumento y, y retorna el resto como un va-
 lor double.
 double frexp (double x,int *exponent);
     Descompone el numero x en una mantisa de rango entre 0.5 y 1, sin llegar a 1, y en un exponente entero
 tal que x=mantisa*2exp. Devuelve la mantisa y el exponente se guarda en y.
 double ldexp (double x,int exponent);
     Calcula el valor de la función x*2exp y retorna el valor calculado como un double.
 double log           (double x);
     Calcula el logaritmo natural de un argumento double y retorna un valor double.
 double log10 (double x);
     Calcula el logaritmo en base 10 de un argumento double y retorna un valor double.
 double modf (double x,double *ipart);
     Descompone el valor x en su parte entera, lo coloca en ipart y retorna como un valor double el resto
 fraccionario.
 double pow           (double x,double y);
     Calcula la potencia de un valor double x elevado a un valor double y retorna un valor double.
 double sin           (double x);
     Calcula el seno argumento double y retorna un valor double.
 double sinh (double x);
     Calcula el seno hiperbólico de un argumento double y retorna un valor double.
 double sqrt (double x);
     Calcula la raíz cuadrada de un argumento double y retorna un valor double.
 double tan           (double x);
     Calcula la tangente de un argumento double y retorna un valor double.
 double tanh (double x);
     Calcula la tangente hiperbólica de un argumento double y retorna un valor double.
Las siguientes funciones son las mismas que las anteriormente explicadas, son la version para datos long
double en el caso de requerir mayor precisión de calculo.
 long   double    acosl     (long double x);
 long   double    asinl     (long double x);
 long   double    atan2l    (long double x,long double y);
 long   double    atanl     (long double x);
 long   double    ceill     (long double x);
 long   double    coshl     (long double x);
 long   double    cosl      (long double x);
 long   double    expl      (long double x);
 long   double    fabsl     (long double x);
 long   double    floorl    (long double x);
 long   double    fmodl     (long double x, long double y);
 long   double    frexpl    (long double x, int *exponent);
 long   double    ldexpl    (long double x, int exponent);
 long   double    log10l    (long double x);
 long   double    logl      (long double x);
 long   double    modfl     (long double x,long double *ipart);
 long   double    powl      (long double x,long double y);
 long   double    sinhl     (long double x);
 long   double    sinl      (long double x);
 long   double    sqrtl     (long double x);
 long   double    tanhl     (long double x);
 long   double    tanl      (long double x);
 long   double    atold     (const char *s);
 long   double    hypotl    (long double x, long double y);
 long   double    polyl     (long double x, int degree, long double *coeffs);
 long   double    pow10l    (int p);
 /* Constantes redondeadas para 21 decimales. */
 #define    M_E               2.71828182845904523536
 #define    M_LOG2E           1.44269504088896340736
 #define    M_LOG10E          0.434294481903251827651
 #define    M_LN2             0.693147180559945309417
 #define    M_LN10            2.30258509299404568402
 #define    M_PI              3.14159265358979323846
 #define    M_PI_2            1.57079632679489661923

Facultad de Ciencias de la Administración                                                      Página 16
Calculo Numérico                                                         Introducción al Lenguaje C
                                            Turbo C++
 #define    M_PI_4            0.785398163397448309616
 #define    M_1_PI            0.318309886183790671538
 #define    M_2_PI            0.636619772367581343076
 #define    M_1_SQRTPI        0.564189583547756286948
 #define    M_2_SQRTPI        1.12837916709551257390
 #define    M_SQRT2           1.41421356237309504880
 #define    M_SQRT_2          0.707106781186547524401

 Para mas referencias a las funciones disponibles consultar la ayuda de Turbo C++.




Facultad de Ciencias de la Administración                                                  Página 17

								
To top