Instituto Tecnolgico Spencer W.

Kimball Huehuetenango

Bachiller Industrial y Perito en Computacin Programacin Estructurada Prof. lvaro Martnez

CONVERSIONES DE TIPOS DE DATOS Y ARRAYS EN C++

Abisai Herrera Herrera Sexto Grado 22 de Junio de 2013

Programacin Estructurada 2013

Introduccin
En el trabajo ser presentara diferentes temas relacionados con el lenguaje de programacin C++, como por ejemplo conversiones de tipos de datos, parmetros de valor y referencia, recursividad y arreglos.

Programacin Estructurada 2013

Contenido
Conversin de tipos de datos en c++ .................................................................................................. 4 Conversiones a bool ............................................................................................................................ 5 Casting: conversiones explcitas de tipo ............................................................................................. 7 Ejemplo de conversin de tipos de datos: .......................................................................................... 8 Parmetros por valor y por referencia ................................................................................................ 8 Recursividad en C++: ......................................................................................................................... 11 Principios de la recursividad: ........................................................................................................ 13 Ventajas y desventajas de la Recursividad: ................................................................................... 14 Ejemplo de recursividad: ................................................................................................................... 14 Arreglos ............................................................................................................................................. 15 Definicin de un arreglo: ................................................................................................................... 15 Acceso al contenido de un arreglo: ................................................................................................... 15

Programacin Estructurada 2013

Conversin de tipos de datos en c++
Quizs te hayas preguntado qu pasa cuando escribimos expresiones numricas en las que no todos los operandos son del mismo tipo. Por ejemplo:
char n; int a, b, c, d; float r, s, t; ... a = 10; b = 100; r = 1000; c = a + b; s = r + a; d = r + b; d = n + a + r; t = r + a - s + c; ...

En estos casos, cuando los operandos de cada operacin binaria asociados a un operador son de distinto tipo, el compilador los convierte a un tipo comn. Existen reglas que rigen estas conversiones, y aunque pueden cambiar ligeramente de un compilador a otro, en general sern ms o menos as: Cualquier tipo entero pequeo como char o short es convertido a int o unsigned int. En este punto cualquier pareja de operandos ser int (con o sin signo), long, long long, double,float o long double. Si un operando es de tipo long double, el otro se convertir a long double. Si un operando es de tipo double, el otro se convertir a double. Si un operando es de tipo float, el otro se convertir a float. Si un operando es de tipo unsigned long long, el otro se convertir a unsigned long long. Si un operando es de tipo long long, el otro se convertir a long long. Si un operando es de tipo unsigned long, el otro se convertir a unsigned long.

Programacin Estructurada 2013

Si un operando es de tipo long, el otro se convertir a long. Si un operando es de tipo unsigned int, el otro se convertir a unsigned int. Llegados a este punto ambos operandos son int. Veamos ahora el ejemplo: c = a + b; caso 10, ambas son int. s = r + a; caso 4, a se convierte a float. d = r + b; caso 4, b se convierte a float. d = n + a + r; caso 1, n se convierte a int, la operacin resultante corresponde al caso 4, el resultado (n+a) se convierte a float. t = r + a - s + c; caso 4, a se convierte a float, caso 4 (r+a) y s son float, caso 4, c se convierte a float. Tambin se aplica conversin de tipos en las asignaciones, cuando la variable receptora es de distinto tipo que el resultado de la expresin de la derecha. En el caso de las asignaciones, cuando la conversin no implica prdida de precisin, se aplican las mismas reglas que para los operandos, estas conversiones se conocen tambin como promocin de tipos. Cuando hay prdida de precisin, las conversiones se conocen como democin de tipos. El compilador normalmente emite un aviso o warning, cuando se hace una democin implcita, es decir cuando hay una democin automtica. En el caso de los ejemplos 3 y 4, es eso precisamente lo que ocurre, ya que estamos asignando expresiones de tipo float a variables de tipo int. Conversiones a bool En C++ podemos hablar de otro tipo de conversin de tipo implcita, que se realiza cuando se usa cualquier expresin entera en una condicin, y ms generalmente, cuando se usa cualquier expresin donde se espera una expresin booleana.

Programacin Estructurada 2013

El dominio del tipo bool es muy limitado, ya que slo puede tomar dos valores: true y false. Por convenio se considera que el valor cero es false, y cualquier otro valor entero es true. Por lo tanto, hay una conversin implcita entre cualquier entero y el tipo bool, y si aadimos esta regla a las explicadas antes, cualquier valor double, long double, float o cualquiera de los enteros, inclusochar, se puede convertir a bool. Esto nos permite usar condiciones abreviadas en sentencias if, for, while o do..while, cuando el valor a comparar es cero. Por ejemplo, las siguientes expresiones booleanas son equivalentes: 0 == x equivale a !x. 0 != x equivale a x. En el primer caso, usamos el operador == para comparar el valor de x con cero, pero al aplicar el operador ! directamente a x obligamos al compilador a reinterpretar su valor como un bool, de modo que si x vale 0 el valor es false, y !false es true. De forma simtrica, si x es distinto de cero, se interpretar como true, y !true es false. El resultado es el mismo que usando la expresin 0 == x. En el segundo caso pasa algo anlogo. Ahora usamos el operador != para comparar el valor de x tambin con cero, pero ahora interpretamos directamente x como bool, de modo que si x vale 0 el valor es false, y si x es distinto de cero, se interpretar como true. El resultado es el mismo que usando la expresin 0 != x. No est claro cual de las dos opciones es ms eficaz, a la hora de compilar el programa. Probablemente, la segunda requiera menos instrucciones del procesador, ya que existen instrucciones de ensamblador especficas para comparar un entero con cero. Del otro modo estaremos comparando con un valor literal, y salvo que el compilador optimice este cdigo, generalmente se requerirn ms instrucciones de este modo. Aadir que los ejemplos anteriores funcionan aunque el tipo de x no sea un entero. Si se trata de un valor en coma flotante se realizar una conversin implcita a entero antes de evaluar la expresin.

Programacin Estructurada 2013

Casting: conversiones explcitas de tipo
Para eludir estos avisos del compilador se usa el casting, o conversin explcita. Nota: de nuevo nos encontramos ante un trmino que suele aparecer en ingls en los documentos. Se podra traducir como amoldar o moldear, pero no se hace. Tambin es un trmino que se usa en cine y teatro, y se aplica al proceso de asignar papeles a los actores. La idea es anloga, en el caso de las variables, asignamos papeles a los valores, segn sus caractersticas. Por ejemplo, para convertir el valor en coma flotante 14.232 a entero se usa el valor 14, podramos decir que 14 est haciendo el papel de 14.232 en la representacin. O que se ajusta a un molde o troquel: lo que sobra se elimina. En general, el uso de casting es obligatorio cuando se hacen asignaciones, o cuando se pasan argumentos a funciones con prdida de precisin. En el caso de los argumentos pasados a funciones es tambin muy recomendable aunque no haya prdida de precisin. Eliminar los avisos del compilador demostrar que sabemos lo que hacemos con nuestras variables, an cuando estemos haciendo conversiones de tipo extraas. En C++ hay varios tipos diferentes de casting, pero de momento veremos slo el que existe tambin en C. Un casting tiene una de las siguientes sintaxis:
(<nombre de tipo>)<expresin> <nombre de tipo>(<expresin>)

Esta ltima es conocida como notacin funcional, ya que tiene la forma de una llamada a funcin. En el ejemplo anterior, las lneas 3 y 4 quedaran:
d = (int)(r + b); d = (int)(n + a + r);

O bien:
d = int(r + b);

Programacin Estructurada 2013

d = int(n + a + r);

Hacer un casting indica que sabemos que el resultado de estas operaciones no es un int, que la variable receptora s lo es, y que lo que hacemos lo estamos haciendo a propsito. Veremos ms adelante, cuando hablemos de punteros, ms situaciones donde tambin es obligatorio el uso de casting.

Ejemplo de conversin de tipos de datos:

#include<iostream.h> #include<conio.h> #include<stdio.h> main(){ clrscr(); float a = 10.2; int b, c = 5; b = (int)(a + c); // convierte a int por truncamiento. Asigna a b el valor 15 c = int (a); // asigna a c el valor 10 getch(); return 0; }

Parmetros por valor y por referencia

En C++ el paso por valor significa que al compilar la funcin y el cdigo que llama a la funcin, sta recibe una copia de los valores de los parmetros que se le pasan como argumentos. Las variables reales no se pasan a la funcin, slo copias de su valor. Cuando una funcin debe modificar el valor de la variable pasada como parmetro y que esta modificacin retorne a la funcin llamadora, se debe pasar el parmetro por referencia. En este mtodo, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una referencia, que indica a la funcin dnde existe la variable en memoria.

Programacin Estructurada 2013

La referencia que una funcin recibe es la direccin de la variable. Es decir, pasar un argumento por referencia es, simplemente, indicarle al compilador que pase la direccin del argumento. Ejemplo: void demo(int &valor) { valor=5; cout<<valor<<endl; } void main() {int n=10; cout<<n<<endl; demo(n); cout<<n<<endl; } La salida de este programa ser: 10 5 5 Una limitacin del mtodo de paso por referencia es que se pueden pasar slo variables a la funcin. No se pueden utilizar constantes ni expresiones en la lnea de llamada a la misma. Los modificadores const y volatile El nmero y tipo de argumentos de una definicin de funcin debe coincidir con su correspondiente prototipo de funcin. Si no existe correspondencia exacta, el compilador C++ intentar convertir el tipo de los argumentos reales de modo que se puedan concordar con los argumentos formales en las funciones llamadas. Los modificadores const y volatile pueden preceder a los tipos de los argumentos formales para indicar instrucciones especficas al compilador.

Programacin Estructurada 2013

Se puede preceder a un tipo de argumento con el modificador const para indicar que este argumento no puede ser modificado. Al objeto al cual se aplica no se le puede asignar un valor o modificar de ningn modo. El modoficador volatile se puede utilizar para indicar que los argumentos formales pueden ser modificados en la ejecucin del programa, bien por el propio programador o por el propio sistema, es decir, cualquier suceso externo al programa. Tpicamente, las variables voltiles se necesitan slo para valores que pueden ser modificados por una rutina de interrupcin que opera independientemente del programa. La declaracin de una variable voltil es volatile int k;

Ejemplo de parmetros de valor y referencia #include <iostream.h> #include <conio.h> #include <stdio.h> int funcion(int n, int m); int main() { int a, b; a = 10; b = 20; cout << "a,b ->" << a << ", " << b << endl; cout << "funcion(a,b) ->" << funcion(a, b) << endl; cout << "a,b ->" << a << ", " << b << endl; cout << "funcion(10,20) ->" << funcion(10, 20) << endl; getch(); return 0; } int funcion(int n, int m) {

Programacin Estructurada 2013

n = n + 2; m = m - 5; return n+m; }

Recursividad en C++:
La recursividad es una tcnica de programacin elemental que permite que una funcin pueda llamarse asimismo desde la misma funcin. Se puede utilizar la recursividad como una alternativa a la iteracin. La recursividad es una herramienta poderosa e importante en la resolucin de problemas en programacin. Una solucin recursiva es normalmente menos eficiente en trminos de tiempo de computadora que una solucin iterativa debido a las operaciones auxiliares que llevan consigo las llamadas suplementarias a las funciones: sin embargo, en muchas circunstancias el uso de la recursin permite a los programadores especificar las soluciones naturales, ms lgicas, elegantes, sencillas, que seran, en caso contrario difcil de resolver. No todas las funciones pueden llamarse a s mismas, sino que deben estar diseadas especialmente para que sean recursivas, de otro modo podran conducir a bucles infinitos, o a que el programa termine inadecuadamente. Tampoco todos los lenguajes de programacin permiten usar recursividad. C++ permite la recursividad. Cada vez que se llama a una funcin, se crea un juego de variables locales, de este modo, si la funcin hace una llamada a s misma, se guardan sus variables y parmetros, usando la pila, y la nueva instancia de la funcin trabajar con su propia copia de las variables locales. Cuando esta segunda instancia de la funcin retorna, recupera las variables y los parmetros de la pila y contina la ejecucin en el punto en que haba sido llamada. Por ejemplo para calcular el factorial de cualquier nmero mayor que cero hay que calcular como mnimo el factorial de otro nmero. La funcin que se utiliza es la funcin en la que se encuentra en estos momentos, esta

Programacin Estructurada 2013

funcin debe llamarse a s misma para el nmero menor inmediato, para poder ejecutarse en el nmero actual. Esto es un ejemplo de recursividad. De esta forma podramos crear una funcin recursiva para calcular el factorial de un nmero entero. El factorial se simboliza como n!, se lee como "n factorial", y la definicin es: n! = n * (n-1) * (n-2) * ... * 1 Hay algunas limitaciones: No es posible calcular el factorial de nmeros negativos, no est definido. El factorial de cero es 1. De modo que una funcin bien hecha para clculo de factoriales debera incluir un control para esos casos: /* Funcin recursiva para clculo de factoriales */ int factorial(int n) { if(n < 0) return 0; else if(n > 1) return n*factorial(n-1); /* Recursividad */ return 1; /* Condicin de terminacin, n == 1 */ } Veamos paso a paso, lo que pasa cuando se ejecuta esta funcin, por ejemplo: factorial (4): 1aInstancia n=4 n>1 salida 4 * factorial (3) (Guarda el valor de n = 4) 2aInstancia n>1 salida 3*factorial (2) (Guarda el valor de n = 3) 3aInstancia n>1 salida 2*factorial (1) (Guarda el valor de n = 2)

Programacin Estructurada 2013

4aInstancia n == 1 retorna 1 3aInstancia (recupera n=2 de la pila) retorna 1*2=2 2aInstancia (recupera n=3 de la pila) retorna 2*3=6 1aInstancia (recuperan=4delapila)retorna6*4=24 Valor de retorno 24 Aunque la funcin factorial es un buen ejemplo para demostrar cmo funciona una funcin recursiva, la recursividad no es un buen modo de resolver esta funcin, que sera ms sencilla y rpida con un simple bucle for. Una funcin recursiva tiene generalmente dos partes: 1) Una llamada recursiva con parmetros ms sencillos. 2) Una parte de terminacin que detiene la recursividad.

Principios de la recursividad:
La recursividad es una de las formas de control ms importantes en la programacin. Los procedimientos recursivos son la forma ms natural de representacin de muchos algoritmos. El concepto de recursividad est ligado, en los lenguajes de programacin, al concepto de procedimiento o funcin. Un procedimiento o funcin es recursivo cuando durante una invocacin a l puede ser invocado a su vez l mismo. El conocimiento de los principios fundamentales de la recursividad evita evadir su utilizacin cuando su aplicacin sea conveniente para un determinado problema. El uso de la recursividad es particularmente conveniente para aquellos problemas que pueden definirse de modo natural en trminos de recursividad.

Programacin Estructurada 2013

Ventajas y desventajas de la Recursividad:
Ventajas: No es necesario definir la secuencia de pasos exacta para resolver el problema. Soluciones simples, claras. Soluciones elegantes. Soluciones a problemas complejos. Desventajas: Podra ser menos eficiente. Sobrecarga asociada con las llamadas a subalgoritmos Una simple llamada puede generar un gran nmero de llamadas Recursivas. (Fact(n) genera n llamadas recursivas) El valor de la recursividad reside en el hecho de que se puede usar para resolver problemas sin fcil solucin iterativa. La ineficiencia inherente de algunos algoritmos recursivos.

Ejemplo de recursividad: #include <iostream.h> #include <conio.h> #include <stdio.h> int SumaDigitos(int); int main() { cout << 32890123 << ": " << SumaDigitos(32890123) ; return 0; } int SumaDigitos(int n) { if(n < 10) return n; return n%10+SumaDigitos(n/10); }

Programacin Estructurada 2013

Arreglos
En clase ya conocimos algunos tipos bsicos como por ejemplo los tipos char, int y float. El lenguaje C++ permite, adems, construir estructuras ms complejas a partir de estos tipos bsicos. Una de las construcciones que podemos definir son los arreglos. Arreglo: Coleccin ordenada de elementos de un mismo tipo. Ordenada significa que cada elemento tiene una ubicacin determinada dentro del arreglo y debemos conocerla para accederlo. Sintaxis:

Definicin de un arreglo:
<tipo> nombre_variable[longitud]; Con esto diremos que nombre_variable es un arreglo de longitud elementos del tipo <tipo>. Cabe destacar que longitud debe ser cualquier expresin entera constante mayor que cero. Asignacin de un arreglo: nombre_variable[ndice] = expresin del tipo <tipo> Esta instruccin asigna el valor asociado de la expresin a la posicin ndice del arreglo nombre_variable. El ndice debe ser una expresin del tipo entero en el rango [0, longitud1]. Cabe destacar que C++ no chequea que el valor de la expresin sea menor a longitud, simplemente asigna el valor a esa posicin de memoria como si formara parte del arreglo, pisando, de esta manera, otros datos que no forman parte del mismo, con lo que finalmente el programa no funciona correctamente.

Acceso al contenido de un arreglo:

nombre_variable[ndice] es valor del tipo <tipo> que puede ser asignado a una variable, o pasado como parmetro, imprimirlo, etc. Aqu tambin vale la aclaracin de que el ndice debe estar dentro del rango de definicin del arreglo, C++ no chequear que esto sea cierto y devolver lo contenido en la posicin de memoria correspondiente a un arreglo de mayor longitud, el dato obtenido de esta manera es basura.

Programacin Estructurada 2013

Ejemplo: int a[5]; // Definicin de un arreglo de 5 posiciones void main() { int i; // Pedimos el ingreso de 5 nmeros for(i=0; i<4; i++) { cout << Ingrese el elemento Nro: << i <<endl; cin >> a[i]; } // Los imprimimos imprimir(a,5); } void imprimir(int b[], int tamano) { int i; for(i=0; i<tamano; i++) { cout << Nro: << i << <<b[i]<<endl; } } Notar que el parmetro b de la funcin imprimir es un arreglo, pero no se indica la longitud del mismo. Esto no es necesario ya que solo especificamos que recibiremos un arreglo sin importar su longitud (en este caso particular su longitud viene indicada en tamao). De esta manera la funcin imprimir funciona para arreglos de cualquier longitud. //No olvidar que los arreglos van de 0 a longitud-1

Programacin Estructurada 2013

OPERACIONES CON ARREGLOS EN C++

Las principales operaciones que se realizan con un array son: - Acceso: cada elemento de un array se nombra con el identificador del array al que perteneces seguido de su posicin entre corchetes [n-1]. Es decir, si en un array[10], queremos nombrar la 4 posicin, esta sera array[3].

- Asignacin: normalmente para asignar valores a un array utilizamos un bucle for. El ejemplo anterior nos muestra perfectamente el comportamiento y la funcionalidad de este bucle. El ndice del for ha de ser capaz de recorrer todas las casillas del array.

- Iniciacin: a un array le podemos dar valores iniciales, para ello se declarara de la siguiente forma: (Donde lista de valores es una lista de constante separadas por comas)

Tipo nombre_array[tamao]={lista_valores};

int lista[6]={2,4,6,8,1,5}; int datos[100]={0}; int num[4]={4,5}; // todos se inicializan a 0 // equivale a {4,5,0,0}

Es muy importante que se inicialicen los arrays antes de usarlos, ya que la declaracin slo reserva espacio en memoria para el array declarado, sin asignacin por defecto por parte del sistema.

Programacin Estructurada 2013

- Lectura/Escritura: la lectura y escritura se realiza componente a componente de la forma habitual, tal como habeis visto en el ejemplo anterior. Aplicacin de Arreglos. Veamos un ejemplo donde un arreglo puede simplificar ms el planteamiento de la solucin de un problema. Supongamos que somos meterelogos y queremos guardar en la computadora la temperatura que ha hecho cada hora del da. Para darle cierta utilidad al final calcularemos la media de las temperaturas. Con lo que sabemos hasta ahora sera algo as

Ejemplo2:

#include <stdio.h> int main() { /* Declaramos 24 variables, int temp1, temp2, temp3, int temp9, temp10, temp11, int temp17, temp18, temp19, int media; /* Ahora tenemos que dar el printf( "Temperatura de las scanf( "%i", &temp0 ); printf( "Temperatura de las scanf( "%i", &temp1 ); printf( "Temperatura de las scanf( "%i", &temp2 ); ... printf( "Temperatura de las scanf( "%i", &temp23 ); 24; printf( "\nLa temperatura media es %i\n", media ); }
Los puntos suspensivos son para no tener que escribir todo el cdigo, pero sera repetir las lneas anteriores

una para cada hora del dia */ temp4, temp5, temp6, temp7, temp8; temp12, temp13, temp14, temp15, temp16; temp20, temp21, temp22, temp23, temp0; valor de cada una */ 0: " ); 1: " ); 2: " ); 23: " );

media = ( temp0 + temp1 + temp2 + temp3 + temp4 + ... + temp23 ) /

cambiando la variable por la siguiente.

Programacin Estructurada 2013

Ahora vamos a hacer el programa con arreglos, sustituyendo todas las variables por un conjunto. Observa que todas las variables son del mismo tipo, por lo que pueden agruparse.

Ejemplo3:

#include <stdio.h> int main() { int temp[24]; float media = 0; int hora; /* Ahora tenemos que dar el valor de cada una */ for( hora=0; hora<24; hora++ ) { printf( "Temperatura de las %i: ", hora ); scanf( "%i", &temp[hora] ); media += temp[hora]; } media = media / 24; printf( "\nLa temperatura media es %f\n", media ); }

La lnea 5 ya contiene a las 24 variables a utilizar y por medio de un for en la lnea 10 recorremos cada uno de sus valores. Se ha utilizado la variable media como un sumador de cada valor y luego para almacenar el resultado dividindolo entre 24.

EJEMPLO DE ARREGLOS #include <stdio.h> #include <conio.h> #include <iostream.h>

int main() { int vector[7]; int c;

Programacin Estructurada 2013

for(c=0;c<=6;c++) { printf("Numero para guardar en vector[%d]: ",c); scanf("%d",&vector[c]); } for(c=0;c<=6;c++) { printf("\nValor Vector[%d]=%d",c,vector[c]); } getch(); return 0; }

Programacin Estructurada 2013

CONCLUSIONES:
En C++ podemos hablar de otro tipo de conversin de tipo implcita, que se realiza cuando se usa cualquier expresin entera en una condicin, y ms generalmente, cuando se usa cualquier expresin donde se espera una expresin booleana. En C++ el paso por valor significa que al compilar la funcin y el cdigo que llama a la funcin, sta recibe una copia de los valores de los parmetros que se le pasan como argumentos. Las variables reales no se pasan a la funcin, slo copias de su valor. La recursividad es una de las formas de control ms importantes en la programacin. Los procedimientos recursivos son la forma ms natural de representacin de muchos algoritmos. Arreglo: Coleccin ordenada de elementos de un mismo tipo. Ordenada significa que cada elemento tiene una ubicacin determinada dentro del arreglo y debemos conocerla para accederlo.

Programacin Estructurada 2013

EGRAFIA:
http://c.conclase.net/curso/?cap=009 http://ejercicioscpp.blogspot.com/2012/11/casting-conversion-entre-tipos-de-datos.html http://recursividadenc.blogspot.com/2012/03/recursividad-en-c.html http://codigomaldito.blogspot.com/2005/11/arreglos-o-arrays-en-c.html http://www.alipso.com/monografias/2266_arreglosestados/