Embed Size (px)
Citation preview
Introducción <Subir>
El lenguaje de programación que veremos a continuación es el Lenguaje C++. Este lenguaje pertenece a la clase de lenguajes comúnmente 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 un programa C++. El Lenguaje C++ es un lenguaje de programación de propósito general, 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 almacenan los valores utilizados durante los cálculos. Nuestro ejemplo es una función llamada main. Normalmente 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 comÚnicar 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 instrucciones 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 argumentos 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 (cadena 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";}
Variables y Expresiones Aritméticas <Subir>
El siguiente Programa utiliza la formula ºC=(5/9)x(ºF-32) para imprimir una tabla de temperaturas Fahrenheit 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, consta 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 tabulació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 lenguajes, 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) 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 secciones 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 termina si la condición es falsa. Tal como con el while, el cuerpo del ciclo puede ser una proposición sencilla 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 incremento 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.
Tipos, Operadores y Expresiones <Subir>
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úsculas.
Los siguientes identificadores son palabras reservadas:
auto double int structbreak else long switchcase enum register typedefchar extern return unionconst float short unsignedcontinue for signed voiddefault goto sizeof volatiledo if static whileasm _cs _ds _escatch friend operator publicclass inline overload template_ss cdecl far hugedelete new private thisinterrupt near pascal throwtry virtual catch
Tipos básicos de datos, declaraciones <Subir>
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 locales a un bloque y son descartados al salir del bloque. Las declaraciones dentro de un bloque crean objetos automáticos si no se emplea el especificador auto.
1. Los objetos declarados como register son automáticos y sugiere que se harán acceso frecuente a los objetos declarados y se almacenan (si es posible) en los registros rápidos de la máquina. Para los objetos declarados como auto no es necesario especificar esta condicion puesto que cada variable dentro de un bloque al que pertenece es automática, es decir es su espacio es creado al entrar al bloque.
2. 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 static 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 programa 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
void ------Tiene tres tipos de usos que luego se
explicaran.char 8 bits -128 a 127 unsigned char 8 bits 0 a 255signed char 8 bits -128 a 127 enum 16 bits -32.768 a 32.767int 16 bits -32.768 a 32.767unsigned int 16 bits 0 a 65.535signed int 16 bits -32.768 a 32.767short int 16 bits -32.768 a 32.767
unsigned short int
16 bits 0 a 65.535
signed short int 16 bits -32.768 a 32.767long int 32 bits -2.147.483.648 a 2.147483.647unsigned long 32 bits 0 a 4.294.967.295signed long int 32 bits -2.147.483.648 a 2.147483.647float 32 bits 3.4 * (10**-38) a 3.4 * (10**+38)double 64 bits 1.7 * (10**-308) a 1.7 * (10**+308)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 efecto con los tipos de datos de punto flotante.
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 manera 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 hexadecimalint 123 012 0x1a o 0X1A
long 1234567l ó L 0123456l ó L 0x1al ó L ó 0X1ABl ó L
unsigned 1234u ó U 012u ó U 0x1au ó 0X1AU
unsigned long 12345678 ul ó UL 0123456ul ó UL 0x1aul ó UL ó 0X1Aul ó UL
2. 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.
3. 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, este 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, como:
´\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"
4. 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+34Tipo double 123.478283829232lf ó lF 1.23478283e+200 Tipo long double 1.267282749502238737362732LF o Lf 1.26727495e+450
5. 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 orden progresivo hasta terminarse la lista de declaraciones.
enum escapes { BELL=´\a´,RETROCESO=´\b´,TAB=´\t´, NVALIN=´\n´, VTAB=´\v´,RETURN=´\r´};
6. Las constantes simbólicas son constantes que pueden ser expresiones de cualquier tipo. Una constante 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#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.71828182845904523536const char msg[]="Hola mundo, esto es C++";
Operadores.—
1. Aritméticos.
Los operadores aritméticos son:
* , / , % (operador módulo para enteros)+ , -en orden de precedencia.
2. Lógicos y de relación.
Los operadores de relación son:
> , >= , < , <=
Todos ellos tienen la misma precedencia.
3. 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.
4. Los operadores lógicos son:
&& y || (and y or)
5. Operadores de Incremento y decremento.
El lenguaje C o el C++ proporcionan dos operadores muy propios y poco comunes. El operador de aumento ++ 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 decrementar 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.
6. 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;
Aquí una lista mas completa:
+= , -= , *= , /= , %= , &= , ^= , |= , <<= , >>= .
7. 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 <Subir>
Las proposiciones de control de flujo de un lenguaje especifican el orden en que se realiza el procesamiento. 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 declaraciones 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.
If-else.—
Formalmente la sintaxis es:
if(expresión) proposición1;else proposición2;
Ejemplo: if(a<b) z=a; [else 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(a < b) z = a; else z = b;
El else va con el if mas interno como se muestra en el sangrado. Si esto no es lo que se desea, se deben utilizar las llaves para forzar la asociación correcta o deseada.
if(n >0) { if(a < b) z = a; } else z = b;
Else-if.—
La construcción es:
if(expresión) proposición1;else if(expresión) proposición2;else if(expresión) proposición3;else proposición4;
Esta secuencia de proposiciones if es la forma general de escribir una decisión múltiple. Las expresiones se evalúan en orden, si cualquier expresión es verdadera, la proposición asociada con ella se ejecuta, y esto termina toda la cadena. Como siempre, el código para cada proposición es una proposición simple o un grupo dentro de llaves.
La parte del ultimo else maneja el caso "ninguna de las anteriores", esta también puede omitirse
Switch.—
La proposición switch es una decisión múltiple que prueba si una expresión coincide con uno de un número de valores constantes (casos) enteros, y traslada el control adecuadamente:
switch(expresión) {case exp-constante : proposición1;case exp-constante : proposición2;case exp-constante : proposición3; default : proposición4;}
Dentro de cada case y como proposición final, debe ir la proposición break, para que la selección culmine con la ocurrencia del caso único que se ha cumplido. La clausula default es opcional
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;}
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.
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.
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 <Subir>
El archivo de cabecera iostream.h, está definido en C++ y se usa para las operaciones de entrada y salida. 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 redirecció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 predefinidos, 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.
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/Salidadec Formato de datos numéricos en
decimal.Entrada/Salida
endl Salida de un caracter de nueva linea y vaciado del flujo.
Salida
ends Salida de un caracter nulo. Salidaflush Vaciado de un flujo. Salidahex Formato de datos númericos en
hexadecimal.Entrada/ Salida
oct Formato de datos númericos en octal.
Entrada/ Salida
resetiosflag(lon Desactiva los indicadores Entrada/Salida
g f) especificados en f.setbase(int base)
Establece el número de la base a base.
Salida
setfill(int c) Establece el caracter de relleno a c.
Entrada/Salida
setiosflag(long f)
Activa los indicadores especificados en f.
Entrada/Salida
setprecision(int p)
Establece el número de dígitos a mostrar después del punto decimal.
Entrada/Salida
setw(int w) Establece la anchura de campo a w.
Entrada/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 <Subir>
C o C++ no es un lenguaje estructurado en bloques, puesto que las funciones no se pueden definir dentro 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 inicial. 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.
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 <Subir>
En C o C++ existe una fuerte relación entre apuntadores y arreglos. Tan fuerte que deben discutirse simultá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 nument[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 arreglo bidimensional. Esencialmente, un arreglo bidimensional es un arreglo de arreglos unidimensionales. Su declaración es la siguiente:
esp.-categ.-almacen. espec.-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 <Subir>
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 adecuadamente, 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;}
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 preprocesamiento, y es el primer paso
antes de la compilación. En particular #include indica que se debe incluir informació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, librerí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ícitamente en la línea 3. Esta función retorna un valor long double y recibe como parámetros dos valores enteros. 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 cualquier 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 invoca recibe los valores de sus argumentos en variables temporales y no en las originales. Esto es, la función que se invoca no puede alterar directamente una variable de la función que hace la llamada; solo puede modificar su copia privada y local.
Cuando es necesario, es posible hacer que una función modifique una variable dentro de una rutina invocada. 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 ordenamiento requiere en algún momento, el intercambio entre dos elementos de dicho arreglo, y para realizar tal tarea, recurrimos a una función:
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 como 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 localizació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"; 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 funciones, 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 caracteres 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 : "; 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 soportan 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
complejosctype.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 definen sus prototipos.
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 pulsada, 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 listado 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); 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 valor 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#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
Consideraciones <Subir>
Para mas referencias a las funciones disponibles consultar la ayuda de Turbo C++.
Para mas bibliografía, consultar cualquier libro de Programación C++ de cualquier autor.
