PROGRAMACION

Instituto Tecnolgico Spencer W. Kimball Huehuetenango, Huehuetenango.

Nombre: Miqueas Israel Sales Catedrtico: lvaro Martnez

Tema: conversiones de tipos en c++, Recursividad, arreglos en c++ (vectores)

Curso: Programacin Carrera: Perito en computacin

Fecha de entrega: 23 junio 2013

Miqueas Israel Sales

PROGRAMACION

Introduccin
En conversin de tipos si los operandos de un operador aritmtico binario son del mismo tipo, ese tipo es el tipo del resultado. Pero si no es as uno de los operandos es convertido al tipo del otro, y el resultado de la operacin tiene ese tipo comn. El tipo comn es el tipo del operando que aparece primero en la lista long double, double, float, long int, int. Losoperandos de tipo char y short son tratados como si fueran de tipo int

Miqueas Israel Sales

PROGRAMACION

INDICE

Contenido
Conversin de tipos............................................................................................................................. 4 Conversiones a bool .................................................................................................................... 5 Parmetros por valor y por referencia ................................................................................................ 8 Referencias a objetos .................................................................................................................. 9 Pasando parmetros por referencia ........................................................................................... 9 Funciones V: Recursividad................................................................................................................. 10 Vectores, Matrices ............................................................................................................................ 15 VECTORES .................................................................................................................................. 15 MATRICES .................................................................................................................................. 16

Miqueas Israel Sales

PROGRAMACION
Conversin de tipos
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. 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.

Miqueas Israel Sales

PROGRAMACION

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. 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.

Miqueas Israel Sales

PROGRAMACION
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, incluso char, 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. Casting: conversiones explcitas de tipo
Miqueas Israel Sales 6

PROGRAMACION
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); d = int(n + a + r);
Miqueas Israel Sales 7

PROGRAMACION
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.

Parmetros por valor y por referencia

Dediquemos algo ms de tiempo a las funciones. Hasta ahora siempre hemos declarado los parmetros de nuestras funciones del mismo modo. Sin embargo, ste no es el nico modo que existe para pasar parmetros. La forma en que hemos declarado y pasado los parmetros de las funciones hasta ahora es la que normalmente se conoce como "por valor". Esto quiere decir que cuando el control pasa a la funcin, los valores de los parmetros en la llamada se copian a "objetos" locales de la funcin, estos "objetos" son de hecho los propios parmetros. Lo veremos mucho mejor con un ejemplo:
#include <iostream> using namespace std; 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;
return 0; } int funcion(int n, int m) { n = n + 2; m = m - 5; Miqueas Israel Sales 8

PROGRAMACION
return n+m; }

Bien, qu es lo que pasa en este ejemplo? Empezamos haciendo a = 10 y b = 20, despus llamamos a la funcin "funcion" con las valores son modificados. Sin embargo al retornar a main, a y b conservan sus valores originales. Por qu?

objetos a y b como parmetros. Dentro de "funcion" esos parmetros se llaman n y m, y sus

La respuesta es que lo que pasamos no son los objetos a y b, sino que copiamos sus valores a los objetos n y m. Piensa, por ejemplo, en lo que pasa cuando llamamos a la funcin con parmetros constantes, es lo que pasa en la segunda llamada a "funcion". Los valores de los parmetros no pueden cambiar al retornar de "funcion", ya que esos valores son constantes.

Si los parmetros por valor no funcionasen as, no sera posible llamar a una funcin con valores constantes o literales. Referencias a objetos Las referencias sirven para definir "alias" o nombres alternativos para un mismo objeto. Para ello se usa el operador de referencia (&). Sintaxis: <tipo> &<alias> = <objeto de referencia> <tipo> &<alias> La primera forma es la que se usa para declarar objetos que son referencias, la asignacin es obligatoria ya que no pueden definirse referencias indeterminadas. Pasando parmetros por referencia Si queremos que los cambios realizados en los parmetros dentro de la funcin se conserven al retornar de la llamada, deberemos pasarlos por referencia. Esto se hace declarando los parmetros de la funcin como referencias a objetos. Por ejemplo:
Miqueas Israel Sales 9

PROGRAMACION
#include <iostream> using namespace std; 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; // (1) es ilegal pasar constantes como parmetros cuando estos son referencias */ return 0; } int funcion(int &n, int &m) { n = n + 2; m = m - 5; return n+m; }

En este caso, los objetos "a" y "b" tendrn valores distintos despus de llamar a la funcin. Cualquier cambio de valor que realicemos en los parmetros dentro de la funcin, se har tambin en los objetos referenciadas.

Esto quiere decir que no podremos llamar a la funcin con parmetros constantes, como la funcin tiene como parmetros referencias a objetos variables.

se indica en (1), ya que aunque es posible definir referencias a constantes, en este ejemplo,

Y si bien es posible hacer un casting implcito de un objeto variable a uno constante, no es posible hacerlo en el sentido inverso. Un objeto constante no puede tratarse como objeto variable.

Funciones V: Recursividad
Se dice que una funcin es recursiva cuando se define en funcin de si misma.

Miqueas Israel Sales

10

PROGRAMACION
No todas la funciones pueden llamarse a si 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 si 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 continua la ejecucin en el punto en que haba sido llamada. Por ejemplo: 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): 1a Instancia n=4 n>1 salida 4 * factorial(3) (Guarda el valor de n = 4)
Miqueas Israel Sales 11

PROGRAMACION
2a Instancia n>1 salida 3*factorial(2) (Guarda el valor de n = 3) 3a Instancia n>1 salida 2*factorial(1) (Guarda el valor de n = 2) 4a Instancia n == 1 retorna 1 3a Instancia (recupera n=2 de la pila) retorna 1*2=2 2a instancia (recupera n=3 de la pila) retorna 2*3=6 1a instancia (recupera n=4 de la pila) retorna 6*4=24 Valor de retorno 24 Aunque la funcin factorial es un buen ejemplo para demostrar cmo funciona una ms sencilla y rpida con un simple bucle for.

funcin recursiva, la recursividad no es un buen modo de resolver esta funcin, que sera

La recursividad consume muchos recursos de memoria y tiempo de ejecucin, y se debe aplicar a funciones que realmente le saquen partido. Veamos otro ejemplo: visualizar las permutaciones de n elementos. Las permutaciones de un conjunto son las diferentes maneras de colocar sus elementos, usando todos ellos y sin repetir ninguno. Por ejemplo para A, B, C, tenemos: ABC, ACB, BAC, BCA, CAB, CBA. Ejemplo:
#include <iostream> using namespace std; /* Prototipo de funcin */ void Permutaciones(char *, int l=0); int main(int argc, char *argv[]) { char palabra[] = "ABCDE";

Miqueas Israel Sales

12

PROGRAMACION
Permutaciones(palabra); cin.get(); return 0; } void Permutaciones(char * cad, int l) { char c; /* variable auxiliar para intercambio */ int i, j; /* variables para bucles */ int n = strlen(cad); for(i = 0; i < n-l; i++) { if(n-l > 2) Permutaciones(cad, l+1); else cout << cad << ", "; /* Intercambio de posiciones */ c = cad[l]; cad[l] = cad[l+i+1]; cad[l+i+1] = c; if(l+i == n-1) { for(j = l; j < n; j++) cad[j] = cad[j+1]; cad[n] = 0; } } }

El algoritmo funciona del siguiente modo: Al principio todos los elementos de la lista pueden cambiar de posicin, es decir, pueden permutar su posicin con otro. No se fija ningn elemento de la lista, l = 0: Permutaciones(cad, 0) 0 A 1 B 2 C 3 D 4 /0

Se llama recursivamente a la funcin, pero dejando fijo el primer elemento, el 0: Permutacion(cad,1) 0 A 1 B

2 C

3 D

4 /0

Se llama recursivamente a la funcin, pero fijando el segundo elemento, el 1: Permutacion(cad,2)

Miqueas Israel Sales

13

PROGRAMACION
0 A 1 B 2 C 3 D 4 /0

Ahora slo quedan dos elementos permutables, as que imprimimos sta permutacin, e intercambiamos los elementos: l y l+i+1, es decir el 2 y el 3. 0 A 1 B 2 D 3 C 4 /0

Imprimimos sta permutacin, e intercambiamos los elementos l y l+i+1, es decir el 2 y el 4.

0 A

1 B

2 /0

3 C

4 D

En el caso particular de que l+i+1 sea justo el nmero de elementos hay que mover hacia la izquierda los elementos desde la posicin l+1 a la posicin l: 0 A 1 B 2 C 3 D 4 /0

En este punto abandonamos el ltimo nivel de recursin, y retomamos en el valor de l=1 e i = 0.

0 A

1 B

2 C

3 D

4 /0

Permutamos los elementos: l y l+i+1, es decir el 1 y el 2. 0 A 1 C 2 B 3 D 4 /0

En la siguiente iteracin del bucle i = 1, llamamos recursivamente con l = 2: Permutaciones(cad,2) 0 A 1 C 2 B 3 D 4 /0

Imprimimos la permutacin e intercambiamos los elementos 2 y 3.

Miqueas Israel Sales 14

PROGRAMACION
0 A 1 C 2 D 3 B 4 /0

Y as sucesivamente.

Existen otras formas de implementar algoritmos recursivos, no es necesario que una funcin se invoque a si misma.

Por ejemplo, un par de funciones A y B pueden crear un algoritmo recursivo si la funcin A invoca a la funcin B, y esta a su vez invoca a la funcin A.

Este mismo mecanismo se puede implementar con tres, cuatro o con cualquier nmero de funciones.

Veamos un ejemplo. Partamos de la siguiente serie:

1 - 1/2 + 1/3 - 1/4 + 1/5 - ... - 1/2*n + 1/2*n+1 - ...

Vectores, Matrices
VECTORES Un vector, tambin llamado array(arreglo) unidimensional, es una estructura de datos que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de memoria juntos, uno despues de otro. A este grupo de elementos se les identifica por un posicin 0. Podramos agrupar en un array una serie de elementos de tipo enteros, flotantes, caracteres, objetos, etc. Crear un vector en c++ es sencillo, seguimos la siguiente sintaxix: Tipo nombre[tamanyo]; Ejm:
1int a[5];//Vector de 5 enteros 2float b[5];//vector de 5 flotantes Miqueas Israel Sales 15

mismo nombre y la posicin en la que se encuentran. La primera posicin del array es la

PROGRAMACION
3Producto product[5];//vector de 5 objetos de tipo Producto

Podramos tambin inicializar el vector en la declaracin:

1int a[] = {5,15,20,25,30}; 2float b[] = {10.5,20.5,30.5,12.5,50.5} 3Producto product[] = {celular,calculadora,camara,ipod,usb}

Como hay 5 elementos en cada array, automticamente se le asignar 5 espacios de

memoria a cada vector.Pero si trato de crear el vector de la forma int a[]; el compilador mostrar un error, porque no indiqu el tamao del vector ni tampoco inicializ sus elementos. Asigno valores a los elementos de un vector indicando su posicin:
int a[4] = 30; // le asigno el valor 30 a la posicin 4 del vector, es

1decir, al 5to elemento. 2product[2].setPrecio(300) // le asigno un precio de 300 al producto en

la posicion 2, o sea al tercer elemento.

Obviamente el mtodo setPrecio() debe de estar implementado.

MATRICES Una matriz es un vector de vectores o un tambin llamado array bidimensional. La manera de declarar una matriz es c++ es similar a un vector:
1int matriz[fils][cols];

int es el tipo de dato, matriz es el nombre del todo el conjunto de datos y debo de tipos de datos como char, float, double,etc.

especificar el numero de filas y columnas. Las matrices tambin pueden ser de distintos

Las matrices en c++ se almacenan al igual que los vectores en posiciones consecutivas de memoria. Usualmente uno se hace la idea que una matriz es como un tablero. Pero
Miqueas Israel Sales 16

PROGRAMACION
internamente el manejo es como su definicion lo indica, un vector de vectores, es decir, los vectores estan uno detras del otro juntos. La forma de acceder a los elementos de la matriz es utilizando su nombre e indicando los 2 subindices que van en los corchetes. Si Coloco int matriz[2][3]=10; //estoy asignando al enumeran a partir de 0. Bueno y para recorrer una matriz podemos usar igualmente un bucle. En este caso 2 for
1for(int i=0;i<fils;i++){ 2 for(int j=0;j<cols;j++){ 3 matriz[i][j] = i % j; 4 } 5}

cuarto elemento de la tercera fila el valor 10. No olvidar que tanto filas como columnas se

Miqueas Israel Sales

17

PROGRAMACION

Conclusin

La recursividad consume muchos recursos de memoria y tiempo de ejecucin, y se debe aplicar a funciones que realmente le saquen partido.

Miqueas Israel Sales

18