Muchas personas estarán de acuerdo con que habría sido mucho más fácil escribir la frase de salida nosotros mismos no?.
Sin embargo, la programación es mucho más que imprimir textos simples en pantalla señores.
Para ir un poco más allá y ser capaces de escribir programas que realicen tareas útiles y que realmente nos ahorren trabajo, necesitamos pues introducir el concepto de variables a nuestro estudio!.
Se lo explico de la siguiente manera: para comenzar, imaginemos que le pido que guarde en su mente el número 5 y luego pido que también memorice el número 2 al mismo tiempo. Usted acaba de almacenar 2 valores diferentes en su memória (el 5 y el 2), no es muy difícil. Ahora, si le pido que añada 1 al primer número que le dije, debería entonces, estar conservando los números 6(5+1) y el número 2 en su memória; ya la cosa cambia y usted comienza a trabajar como lo haría un programa en C++.
Entonces podríamos, por ejemplo, restar los dos valores y obtener 4 como resultado.
a = 5; b = 2; a = a + 1; resultado = a - b;Es obvio que este ejemplo es muy simple, ya que hemos utilizado tan sólo 2 pequeños valores enteros integer, pero considere que su computadora puede almacenar millones de números como estos al mismo tiempo y llevar a cabo sofisticadas operaciones matemáticas con ellos.
¿Entendió esto?,
Pues entonces ahora podremos definir a una variable como una porción de memória para almacenar un valor, perfecto?.
Cada variable necesita un nombre que la identifique y la distinga entre las demás. Por ejemplo, en el código anterior los nombres de ellas eran a, b y resultado; pero podríamos haberlas llamado de cualquier otra forma; siempre y cuando consigan ser identificadores C++ válidos. ¿Qué son identificadores C++ válidos?
Identificadores C++ válidos
Un identificador C++ válido es una secuencia de una o más letras, dígitos o carácteres de subrayados (_). Los espacios, los signos de puntuación y los símbolos no pueden formar parte de un identificador. Además, los identificadores siempre comenzarán con una letra o con un carácter de subrayado(_).Pero en la mayoría de los casos estos identificadores se consideran reservados para palabras claves específicas del compilador o identificadores externos, así como identificadores que contienen dos carácteres de subrayado sucesivos en cualquier lugar. En ningún caso pueden comenzar con un dígito.
C++ utiliza una serie de palabras claves para identificar operaciones y descripciones de datos; por lo tanto, los identificadores creados por un programador no pueden coincidir con estas palabras clave, que no se le olvide.
Las palabras clave estándar reservadas que no se pueden utilizar como identificadores creados por el programador son:
*alignas *alignof *and *and_eq *asm *auto *bitand *bitor *bool *break *case *catch *char *char 16_t *char 32_t *class *compl *const *constexpr *const_cast *continue *decltype *default *delete *do *double *long *mutable *namespace *new *noexcept *not *not_eq *null_ptr *operator *or *or_eq *private *protected *public *register *reinterpret_cast *return *short *signed *sizeof *static *static_assert *static_cast *struct *switch *this *template *thread_local *throw *true *try *typedef *typeid *typename *union *unsigned *using *virtual *void *volatile *wchar_t *while *xor *xor_eq
Los compiladores específicos también pueden tener palabras clave específicas adicionales.
Muy Importante: El lenguaje C++ es un lenguaje "sensible a mayúsculas y minúsculas". Esto significa que un identificador escrito en mayúsculas no es equivalente a otro con el mismo nombre, escrito en minúsculas. Así por ejemplo, la variable RESULT no es lo mismo que la variable Result o la variable result; estos son 3 identificadores diferentes que identifican 3 variables diferentes.
Tipos de Datos Fundamentales
Los valores de las variables se almacenan en algún lugar y en una ubicación que no es especificada, dentro de la memória del ordenador, todas ellas siendo ceros y unos.Nuestro programa no necesita saber la ubicación exacta donde se almacena una variable, este simplemente puede referirse a ella por su nombre y usarla como quiera.
Lo que el programa necesita realmente saber es el tipo de datos almacenados en la variable. No es lo mismo almacenar un entero simple que almacenar una letra o un número de punto flotante grande; a pesar de que todos están representados con ceros y unos, no se interpretan de la misma manera y en muchos casos, no ocupan la misma cantidad de memória.
Los tipos de datos fundamentales: son tipos básicos implementados directamente por el lenguaje, los cuales representan unidades de almacenamiento básicas soportadas nativamente por la mayoría de los sistemas.
Pueden clasificarse principalmente en:
- Primer Tipo: Caracteres: representan un solo carácter, como 'A' o '$'. El tipo más basico es char, que es un carácter de un byte. Otros tipos también se proporcionan para caracteres más amplios.
- Segundo Tipo: Enteros numéricos: Pueden almacenar un valor de número entero, como por ejemplo: 7 ó 1024. Estos existen en una variedad de tamaños y pueden ser asignados(con signo - o +) o no asignados(sin formato, osea sin - ó +), dependiendo si soportan valores negativos o no.
- Tercer Tipo: De punto Flotante: Pueden representar valores reales, como 3.14 ó 0.01; con diferentes niveles de precisión, dependiendo claro de cuál de los 3 tipos de punto flotante se utilize; que pueden ser: Float, Double ó Long Double.
- Cuarto Tipo: Booleano: conocido en C++ como bool, sólo puede representar uno de los 2 estados: True ("verdadero") y False ("Falso").
| Grupo | Nombres de Tipos | Notas sobre Tamaño/Precisión |
|---|---|---|
| Carácteres | ||
| char | Exactamente un byte en tamaño. Por lo menos 8 bits. | |
| char16_t | No puede ser más pequeño que char. Al menos 16 bits. | |
| char32_t | No es más pequeño que char16_t. Al menos 32 bits. | |
| wchart_t | Puede representar el mayor conjunto de caracteres admitidos en C++. | |
| Tipo Enteros (signed) | ||
| signed char | El mismo tamaño que char. Al menos 8 bits. . | |
| signed short int | No es más pequeño que char. Al menos 16 bits. | |
| signed int | No más pequeño que short. Al menos 16 bits. | |
| signed long int | No es menor que int. Al menos 32 bits. | |
| signed long long int | No más pequeño que long. Al menos 64 bits. | |
| Tipo Enteros (unsigned) | ||
| unsigned char | (El mismo tamaño que sus homólogos signed) | |
| unsigned short int | ||
| unsigned int | ||
| unsigned long int | ||
| unsigned long long int | ||
| Tipo de Puntos Flotantes | ||
| float | ||
| double | Precisión no inferior al float | |
| long double | Precisión no inferior al double | |
| Tipo Boolean | ||
| bool | ||
| Tipo Void | ||
| void | Sin Almacenamiento | |
| Puntero Nulo | ||
| decltype(nullptr) |
Por ejemplo, signed short int puede ser abreviado como signed short, short int ó simplemente short; todos identifican el mismo tipo fundamental.
Dentro de cada uno de los grupos anteriores, la diferencia entre tipos es sólo su tamaño (es decir, cuanto ocupan de memória):
- el primer tipo en cada grupo es el que menos memoria ocupa, osea es el más pequeño;
- mientras que el último de cada tipo corresponde al más grande por lo tanto el que ocupa más memoria. Siendo cada tipo mayor que el que lo precede en el mismo grupo.
- Además de eso tenemos que tener en cuenta que los tipos en un mismo grupo tienen las mismas propiedades.
Esto de ninguna manera significa que estos tipos son de un tamaño indeterminado, lo que pasa es que no hay un tamaño estándar en todos los compiladores y máquinas; cada implementación del compilador puede especificar los tamaños de estos tipos, los cuales se ajustan mejor a la arquitectura en la que se va a ejecutar el programa en desenvolvimiento.
Esta especificacion de tamaño bastante genérica para los tipos es que le da al lenguaje C++ mucha más flexibilidad para adaptarse a un trabajo extraordinario en todo tipo de plataformas, hasta en las más actuales.
Los tamaños de tipo anteriores se expresan en bits; cuanto más bits tenga un tipo, más valores distintos puede representar; pero al mismo tiempo, también consumirá más espacio en memória:
| Tamaño | Valores Representables Únicos | Observaciones |
|---|---|---|
| 8-bit | ||
| 256 | = 28 | |
| 16-bit | ||
| 65 536 | = 216 | |
| 32-bit | ||
| 4 294 967 296 | = 232 (~4 billones) | |
| 64-bit | ||
| 18 446 744 073 709 551 616 | = 264 (~18 billones de billones) |
Para los tipos de puntos flotantes, el tamaño afecta su precisión, por tener más o menos bits para su valor significativo y exponente.
Las propiedades de los tipos fundamentales en un sistema particular y la implementación del compilador: pueden ser obtenidos usando la class numeric_limits (esto lo veremos en un capítulo posterior). Si por alguna razón, se necesitan tipos de tamaños específicos, la biblioteca define ciertos alias del tipo de tamaño fijo en el encabezado <cstdint>.
Los tipos descritos anteriormente (carácteres, enteros, punto flotantes y booleano) se conocen colectivamente como tipos aritméticos. Pero existen dos tipos fundamentales adicionales: vacío void, que identifica la falta de tipo; y el tipo nullptr que es un tipo especial de puntero. Ambos tipos serán discutidos más adelante en un próximo capítulo donde trataremos especificamente sobre punteros.
C++ admite una amplia variedad de tipos basados en los tipos fundamentales discutidos anteriormente; estos otros tipos se conocen como tipos de datos compuestos y son una de las principales fortalezas del lenguaje C++; estos los veremos también con más detalles en capítulos posteriores.
Declaración de Variables:
C++ es un lenguaje fuertemente tipado, y requiere pues que cada variable sea declarada con su tipo antes de su primer uso. Esto informará al compilador dos cosas importantes:- el tamaño a reservar en memoria para esta variable y
- cómo interpretar su valor.
int a; float minumero;Estas son dos declaraciones de variables que son completamente válidas. La primera declara una variable del tipo int con el identificador a. El segundo declara una variable del tipo float con el identificador minumero. Una vez declaradas, las variables a y minumero se podran utilizar en el resto del ámbito scope del programa. En el caso de que usted quiera declarar más variables del mismo tipo, estas podrán escribirse separando sus identificadores con comas. Aquí un ejemplo:
int a, b, c;
Esto declara 3 variables (a, b y c), todas ellas de tipo int y tiene exactamente el mismo significado que: int a; int b; int c;Para ver cómo se ven las declaraciones de variables en acción dentro de un programa, echemos un vistazo a todo el código C++ del ejemplo sobre su memória mental propuesto al principio de este artículo:
//Operación con variables #include <iostream> using namespace std; int main () { // declarando variables int a, b; int resultado; // procesando: a = 5; b = 2; a = a + 1; resultado = a - b; // imprimiento el resultado en pantalla cout << resultado; // cerrando el programa return 0; }
No se preocupe si algo diferente a las declaraciones de las variables le parece extraño. La mayor parte se explicará con mayor profundidad en los próximos capítulos.
Inicialización de variables
Cuando se declararon las variables en el ejemplo anterior, estas tuvieron un valor indeterminado hasta que le asignamos un valor por primera vez.Pero, ¿es posible que una variable tenga un valor específico desde el momento en que se declara?, sí claro, a esto justamente se le llama inicialización de una variable!
En el lenguaje C++, hay tres maneras de inicializar una variable. Todas equivalentes y recuerdan la evolución del lenguaje a lo largo de los años:
- El primero, conocido como inicialización c-like (debido a que se hereda del lenguaje C), este consiste en anexar un signo igual seguido del valor desde el cual se inicia la variable:
tipo identificador = valor_inicial;Por ejemplo si queremos:
- declarar una variable del tipo int llamada x e inicializarla con un valor de 0 desde el mismo momento en que se declara, escribiremos esto:
int x = 0;
- Un segundo método, conocido como inicialización del constructor (introducido por el lenguaje C++), incluye el valor inicial entre paréntesis ().
tipo identificador (valor_inicial)
Por ejemplo:int x (0);
- Por último, tenemos un tercer método, conocido como Inicialización Uniforme, que es similar al anterior, pero con llaves en lugar de paréntesis (este fué introducido por la revisión de la norma C++, en 2011):
tipo identificador {valor_inicial};
Por ejemplo:int x {0};Las 3 formas de inicializar variables son válidas y equivalentes en C++, no se le olvide de aprenderlas de manera firme!:
Deducción de Tipos : auto y decltype
Cuando una nueva variable es inicializada, el compilador puede descubrir cual es el tipo de variable de forma automática, todo por medio del inicializador; ¿sabías? pues sí, así es.
Para esto, simplemente basta usar auto como el especificador del tipo para la variable Por ejemplo:
Para esto, simplemente basta usar auto como el especificador del tipo para la variable Por ejemplo:
int foo = 0; auto bar = foo; // esto es lo mismo que: int bar = foo;Aqui, la variable bar es declarada como teniendo un tipo auto; por lo tanto, el tipo de bar es el tipo de valor utilizado para iniciarla: en este caso utiliza el tipo de foo, que es int.
Las variables que no se inicializan también pueden hacer uso de la deducción de tipo, pero estas utilizaran el especificador decltype:
int foo = 0; decltype(foo) bar; // esto es lo mismo que: int bar;Aquí, se declara que bar tiene el mismo tipo que foo.
auto y decltype son potentes funciones que fueron recientemente agregadas al lenguaje C++.
Pero las características de deducción de tipo que introducen están destinadas a ser utilizadas cuando el tipo no se puede obtener por otros medios o cuando se utiliza para mejorar la legibilidad del código. Estos dos ejemplos encima indicados, no son probablemente ninguno de estos casos. De hecho, probablemente disminuyen la legibilidad, ya que al leer el código, uno tiene que buscar el tipo de foo para saber realmente el tipo de bar. Mas detalles de este tema los encontraremos en un capítulo posterior, donde iremos paso a paso aprofundandonos!.
Introducción a Strings
Los tipos fundamentales representan los tipos más básicos manejados por máquinas donde se puede ejecutar código. Pero uno de los principales puntos fuertes del lenguaje C++ es su rico conjunto de tipos compuestos, de los cuales los tipos fundamentales son simples bloques de construcción!Un ejemplo de tipo compuesto es la class string. Las variables de este tipo compuesto son capaces de almacenar secuencias de caracteres, tales como palabras u oraciones. Una característica muy útil!.
Una primera diferencia con los tipos de datos fundamentales es que para declarar y utilizar objetos (variables) de este tipo, el programa debe incluir el header(encabezado) donde se definirá el tipo dentro de la biblioteca estándar (header <string>: #include <string>), veamos un ejemplo práctico de esto:
string mistring = "Esta es una string"; string mistring ("Esta es una string"); string mistring {"Esta es una string"};¿Los strings pueden realizar todas las otras operaciones básicas que los tipos fundamentales?, claro que sí!, estos por ejemplo pueden ser declarados sin un valor inicial y cambiar su valor durante la ejecución:
Nota Importante:
Al insertar el manipulador endl se termina la línea (y lo que hace este es imprimir un carácter de nueva línea vaciando el búfer stream).Como antes afirmamos la class string es un tipo compuesto no lo olvidemos.
Como podemos ver en el ejemplo anterior, los tipos compuestos se utilizan de la misma manera que los tipos fundamentales: la misma sintaxis se utiliza para declarar variables y para inicializarlas.
Para obtener más detalles sobre strings de C++ estándar, consulte este site.
Culminado y entendido este paso, habremos llegado a una parte importante de conocimientos para empezar a trabajar con C++, no podemos desistir si queremos llegar a desenvolver cualquier cosa con este maravilloso lenguaje!, más adelante veremos lo que son las Constantes en este lenguaje con lo cual iremos practicando con varios programas más complejos. No deje de practicar, eso es vital!
Publicar un comentario