Herramientas de usuario
curso-cpp:variables-valores-tipos
Diferencias
Muestra las diferencias entre dos versiones de la página.
| Ambos lados, revisión anterior Revisión previa Próxima revisión | Revisión previa | ||
|
curso-cpp:variables-valores-tipos [2016/09/29 16:43] santo [El operador de asignación] |
curso-cpp:variables-valores-tipos [2017/10/29 19:28] (actual) santo |
||
|---|---|---|---|
| Línea 20: | Línea 20: | ||
| * ''int'': El tipo int es uno de los más comunes. Se utiliza para representar **números enteros**. Así, los textos como ''"Seminario"'' no pueden ser valores de tipo int. El tipo int representa números enteros, ya sean positivos, negativos, o cero, pero no se puede usar para números arbitrariamente grandes: Únicamente permite números desde -2147483648 (que es 2 a la 31 negativo) hasta 2147483647 (que es 2 a la 31 menos 1), inclusive. Si las cuentas intermedias que realicemos en nuestro programa generan números por fuera de este rango, se producirán resultados erróneos. A eso lo llamamos **overflow**, y es un peligro con el que siempre se tiene que tener cuidado cuando los números con los que trabajamos puedan volverse grandes. | * ''int'': El tipo int es uno de los más comunes. Se utiliza para representar **números enteros**. Así, los textos como ''"Seminario"'' no pueden ser valores de tipo int. El tipo int representa números enteros, ya sean positivos, negativos, o cero, pero no se puede usar para números arbitrariamente grandes: Únicamente permite números desde -2147483648 (que es 2 a la 31 negativo) hasta 2147483647 (que es 2 a la 31 menos 1), inclusive. Si las cuentas intermedias que realicemos en nuestro programa generan números por fuera de este rango, se producirán resultados erróneos. A eso lo llamamos **overflow**, y es un peligro con el que siempre se tiene que tener cuidado cuando los números con los que trabajamos puedan volverse grandes. | ||
| - | * ''string'': El tipo string se utiliza para representar **cadenas de texto**. Como hemos explicado antes, no podremos entonces restar dos valores de tipo string. | + | * ''string'': El tipo string se utiliza para representar **cadenas de texto**. Como hemos explicado antes, no podremos entonces restar dos valores de tipo string. Para utilizar ''string'' hay que agregar la línea ''#include <string>'' al comienzo del programa. |
| * ''char'': Este es un tipo de datos que nunca usamos antes. Un valor de tipo ''char'' representa un caracter, es decir, una letra particular de un texto. Así como anotamos los valores de tipo string entre comillas dobles ''"'', anotamos los valores de tipo char entre comillas simples. Por ejemplo, '''a' '', '''b' '', '''A' '', ''')' '', '''+' '', ''' ' '' son todos valores distintos de tipo char. Es decir, cada letra en particular de un valor de tipo string, será un valor de tipo char. | * ''char'': Este es un tipo de datos que nunca usamos antes. Un valor de tipo ''char'' representa un caracter, es decir, una letra particular de un texto. Así como anotamos los valores de tipo string entre comillas dobles ''"'', anotamos los valores de tipo char entre comillas simples. Por ejemplo, '''a' '', '''b' '', '''A' '', ''')' '', '''+' '', ''' ' '' son todos valores distintos de tipo char. Es decir, cada letra en particular de un valor de tipo string, será un valor de tipo char. | ||
| Línea 39: | Línea 39: | ||
| Así, ''(1 + 5) * 3'' es una expresión aritmética. Otra más larga es ''( ( (1+5)*2)/3)*8''. Si ''x'' es un ''int'', entonces ''x+1'' es una expresión que denota al entero que le sigue a ''x'', y ''2*x'' es una expresión que indica el doble de ''x''. | Así, ''(1 + 5) * 3'' es una expresión aritmética. Otra más larga es ''( ( (1+5)*2)/3)*8''. Si ''x'' es un ''int'', entonces ''x+1'' es una expresión que denota al entero que le sigue a ''x'', y ''2*x'' es una expresión que indica el doble de ''x''. | ||
| + | Además de estas 4 operaciones aritméticas básicas, es común también utilizar la operación ''%'', que se llama "módulo", y sirve para obtener el **resto** de la división. De esta forma, la expresión ''9 / 2'' da por resultado ''4'' (ya que cuando trabajamos con enteros, como trabajaremos casi siempre, la operación da el resultado de hacer la **división entera**), y la operación ''9 % 2'' da por resultado ''1'', pues al dividir 9 por 2 se obtiene un **cociente** de 4, y un **resto** de 1. Similarmente, ''14 % 5'' da por resultado 4, mientras que ''14 / 5'' da por resultado 2. | ||
| ==== Expresiones con strings ==== | ==== Expresiones con strings ==== | ||
| Línea 65: | Línea 65: | ||
| Similarmente, podemos obtener la distancia en el abecedario entre dos letras haciendo su resta: '' 'e' - 'a' '' dará por resultado un **int**, en este caso 4 (pues desde la a hay que avanzar 4 letras para llegar a la e). Notar que si mezclamos mayúsculas con minúsculas, en estos casos tendremos resultados incorrectos, pues en la tabla ASCII mencionada las mayúsculas y minúsculas tienen códigos diferentes (no son el mismo caracter). | Similarmente, podemos obtener la distancia en el abecedario entre dos letras haciendo su resta: '' 'e' - 'a' '' dará por resultado un **int**, en este caso 4 (pues desde la a hay que avanzar 4 letras para llegar a la e). Notar que si mezclamos mayúsculas con minúsculas, en estos casos tendremos resultados incorrectos, pues en la tabla ASCII mencionada las mayúsculas y minúsculas tienen códigos diferentes (no son el mismo caracter). | ||
| + | Otra propiedad útil del ordenamiento ASCII es que los **dígitos** del '' '0' '' al '' '9' '' están en orden y todos juntos en el ordenamiento; y por lo tanto, si sabemos que ''x'' es un ''char'' que corresponde a un dígito, con la expresión ''x - '0' '' podemos obtener el valor numérico del caracter, directamente como un número entero. | ||
| ===== Variables ===== | ===== Variables ===== | ||
| Línea 80: | Línea 80: | ||
| Así por ejemplo, si tenemos el siguiente fragmento de programa: | Así por ejemplo, si tenemos el siguiente fragmento de programa: | ||
| - | <code> | + | <code cpp> |
| int x; | int x; | ||
| cin >> x; // Lectura 1 | cin >> x; // Lectura 1 | ||
| Línea 107: | Línea 107: | ||
| Por ejemplo, el siguiente fragmento de programa: | Por ejemplo, el siguiente fragmento de programa: | ||
| - | <code> | + | <code cpp> |
| int x = 25; | int x = 25; | ||
| int y = 10; | int y = 10; | ||
| Línea 129: | Línea 129: | ||
| ===== Operaciones de entrada / salida ===== | ===== Operaciones de entrada / salida ===== | ||
| + | Ya hemos estado trabajando con operaciones de entrada salida, mediante ''cin'' y ''cout'': Resumimos aquí brevemente su uso con variables. | ||
| + | |||
| + | Cuando queremos **recibir** datos del usuario, debemos **almacenarlos** en alguna variable. Para eso utilizamos ''cin'', que permite hacer justamente eso. Por ejemplo el siguiente fragmento de código: | ||
| + | |||
| + | <code cpp> | ||
| + | int x; | ||
| + | cin >> x; | ||
| + | int y,z; | ||
| + | cin >> y >> z; | ||
| + | cin >> x >> y >> z; | ||
| + | </code> | ||
| + | |||
| + | Muestra un ejemplo de 3 lecturas de datos realizadas con ''cin'': En la primera, se recibe un número entero y se guarda en la variable ''x''. En la segunda, se reciben **dos** enteros más, y se guardan (¡En este orden!) en las variables ''y'' y ''z''. Notar que es posible en una misma instrucción leer varias variables, utilizando para eso el operador ''>>'' varias veces. Finalmente, en la tercera y última lectura con ''cin'' se leen **tres** variables: ''x'', ''y'' y ''z''. Notar que en este caso, la tercera lectura **borra** los valores que se hayan leído en las primeras dos lecturas, ya que los nuevos valores son almacenados en las mismas variables donde se habían leído los valores anteriores, que se pierden al ser reemplazados por los nuevos. | ||
| + | |||
| + | Cuando queremos **enviar** datos a la salida, utilizamos ''cout''. En este caso, ''cout'' se encarga de **escribir** en la pantalla el resultado de cualquier expresión que le indiquemos. Además, tenemos el elemento especial ''endl'', que sirve para indicar a ''cout'' que pase a escribir a la siguiente línea. Al elemento ''endl'' se lo suele denominar el //fin de línea//. | ||
| + | |||
| + | Por ejemplo, el siguiente fragmento de código: | ||
| + | |||
| + | <code cpp> | ||
| + | cout << "Mensaje1" << endl; | ||
| + | cout << "En la segunda linea " << "podemos enviar un texto en partes" << endl; | ||
| + | cout << "Sin endl, no se salta de linea."; | ||
| + | cout << "Por lo tanto esto se pega a la anterior."; | ||
| + | cout << endl; // Se puede enviar solamente el endl en una instruccion, para forzar el salto de linea. | ||
| + | cout << (1+2+3+4) << " " << (1+3)*10 << endl; // Se pueden enviar expresiones para que se escriban | ||
| + | int x = 42; | ||
| + | cout << x+10 << endl; // Las variables se pueden usar en cualquier expresion | ||
| + | </code> | ||
| + | |||
| + | Produciría por pantalla el siguiente resultado: | ||
| + | |||
| + | <code> | ||
| + | Mensaje1 | ||
| + | En la segunda linea podemos enviar un texto en partes | ||
| + | Sin endl, no se salta de linea.Por lo tanto esto se pega a la anterior. | ||
| + | 10 40 | ||
| + | 52 | ||
| + | </code> | ||
| ===== Const ===== | ===== Const ===== | ||
| + | A veces queremos tener variables que guarden un valor que nunca se va a modificar. Esto se hace por claridad y facilidad del programa: Por ejemplo, imaginemos que estamos haciendo un programa propio que calcula cuánto trabajo le toca hacer a cada uno de los integrantes de un grupo. Supongamos que nuestro grupo tiene 4 personas. Podríamos simplemente poner ''4'' en el código, cada vez que necesitemos utilizar la cantidad de personas. Sin embargo, esto no deja claro que ese ''4'' es la cantidad de personas, y no otra cosa que también sea 4 "de casualidad". Similarmente, si un día quisiéramos cambiar el programa para que trabaje con 5 personas... ¡Tendríamos que ir por todo el programa buscando todos los ''4'', para ver **cuáles** se refieren a la cantidad de personas, y **esos** cambiarlos por un 5! | ||
| + | |||
| + | En lugar de usar el valor directamente, entonces, conviene guardarlo en una variable al comienzo: | ||
| + | |||
| + | <code cpp> | ||
| + | int CANTIDAD_PERSONAS = 4; | ||
| + | </code> | ||
| + | |||
| + | Y luego utilizarlo cada vez que necesitemos hablar de la cantidad de personas en el programa: De esta forma, para cambiar la cantidad más adelante hay que cambiar un solo lugar, y el programa queda mucho más claro. | ||
| + | |||
| + | Como esta variable **no la vamos a modificar**, es muy recomendado declararla con ''const'': ''const'' es una palabra especial que indica al compilador que no vamos a modificar nunca esta variable: Queremos que sea en realidad una **constante**, y no una **variable** que realmente puede cambiar de valor. De esta forma si por accidente la modificamos, el compilador nos avisará. | ||
| + | |||
| + | La declaración se hace simplemente agregando ''const'' al comienzo: | ||
| + | |||
| + | <code cpp> | ||
| + | const int CANTIDAD_PERSONAS = 4; | ||
| + | </code> | ||
| + | |||
| + | Es una convención común (de muchas posibles) escribir las constantes en mayúsculas. | ||
| + | |||
| + | ===== Ámbito de una variable ===== | ||
| + | |||
| + | No se puede utilizar una variable en cualquier lugar del programa, sino que cada variable tiene un **ámbito**, y solo puede utilizarse dentro del mismo. | ||
| + | |||
| + | El ámbito de una variable es el **bloque** (conjunto de instrucciones delimitadas con **llaves** ''{'' y ''}'') que contiene la declaración de la variable. Más adelante veremos instrucciones como ''if'', ''while'' y ''for'' que contienen bloques de instrucciones, y una variable declarada **dentro** de uno de estos bloques, no puede utilizarse **fuera** de los mismos. | ||
curso-cpp/variables-valores-tipos.1475167430.txt.gz · Última modificación: 2016/09/29 16:43 por santo
Herramientas de la página
Excepto donde se indique lo contrario, el contenido de este wiki esta bajo la siguiente licencia: Public Domain
