Antes de continuar presentando estructuras de control resulta conveniente ampliar nuestro conocimiento de operadores que tenemos hasta el momento.
Hay un grupo de operadores muy utilizados en C++ que nos permiten incrementar o decrementar el valor de una variable. En esta sección los presentamos con amplitud, recuerda que éste es un curso para usuario nuevos sin conocimientos previos en programación. Si ya tienes conocimientos probablemente encuentres redundante esta sección.
Analiza el siguiente código.
int i = 4; i = i + 1; cout << "i vale : " >> i;
Si ejecutas este código, obtendrás como salida:
i vale: 5
Lo que ocurre en la expresión i = i + 1; es,
A la variable i (que en nuestro caso en un principio tiene un valor de 4) se le asignará el valor de i (que es 4) y se le sumará 1, reemplazando el valor original de i, de esta forma el valor final de i será 5 (i + 1) = (4 + 1).
En la expresión indicada puedes considerar que la variable i es “reciclada” y se reutiliza tomando el nuevo valor a partir del valor original más el incremento indicado en la misma expresión.
Este tipo de expresiones son ampliamente utilizadas en estructuras de control y arreglos,
Veamos un ejemplo en una estructura while.
// eb30_incremento1.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Este programa presenta el cuadrado de los números del 1 al 10 // Se ilustra el uso de incrementos // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 1; //La inicialización de variables es muy importante. while (i <= 10) { cout<<"El cuadrado de : " << i << " es " << (i * i) << endl; i = i + 1; //Prueba poniendo esta sentencia antes de cout } return 0; }
Aunque es un programa trivial, ilustra muchos aspectos importantes:
Otro uso muy amplio del incremento de variables es su uso como contadores, un uso típico es a la hora de verificar el número de entradas por parte de un usuario.
// eb31_incremento2.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Se utiliza un contador para verificar las veces que se introduce una contraseña // Se ilustra el uso de incrementos // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 1; //La inicialización de variables es muy importante. string contrasena = "1234"; //Establecemos la contraseña válida string contrauser; //Almacena la contraseña que escrie el usuario int intentosmax = 3; //Establecemos la cantidad máxima de intentos permitidos cout << "Escribe la contraseña de acceso, solo tienes " << intentosmax; cout << " intentos, para escribir la contraseña correcta" << endl << endl; while (i <= intentosmax) { cout << "Escribe la contraseña de acceso, intento " << i << " de " << intentosmax << endl; cin >> contrauser; if (contrauser == contrasena) { cout << "Contraseña correcta, acceso otorgado!" << endl; break; } else { cout << "***Contraseña incorrecta, acceso denegado!" << ", intento " << i << " ***" << endl; i = i + 1; if (i == intentosmax) { cout << "Has excedido la cantidad de intentos permitidos, el programa explotará!" << endl; } } } cout <<"El programa ha terminado" << endl; return 0; }
El programa utiliza elementos que ya hemos revisado, por lo que no debe representar dificultad para que lo comprendas, la única novedad es el uso de variables para determinar los límites del programa, en lugar de escribir estos valores directamente en el programa.
También observa el uso de la estructura if / else para evaluar si la contraseña introducida es la correcta y otro if para mostrar un mensaje si excedemos el límite de intentos permitidos.
int intentosmax = 3;Haz clic en la imagen para ver una salida del programa:
Un acumulador es una variable que se utiliza para almacenar en ella el resultado de una operación cíclica, tomando como base a la misma variable, en términos estrictos es el mismo concepto de un contador, pero se diferencia de este porque en lugar de sufrir incrementos constantes, los valores pueden ser muy dispares.
El siguiente ejemplo muestra el uso de un contador de forma “tradicional” en incrementos de 1 y otro acumulador que cambia dependiendo de las entradas que hace el usuario.
// eb33_incremento3.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Se utiliza un contador y un acumulador para registra el promedio de los valores introducidos // Se ilustra el uso de incrementos // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 0; //La inicialización de variables es muy importante. double total = 0; //Acumulador para la suma de valores double entrada; int valorTerminar = -9999; //valor para indicar el fin de entradas bool terminar = false; cout << "Este programa promedia los valores que escribas " << endl; cout << "utiliza sólo números, escribe " << valorTerminar << " para terminar" << endl << endl; while (!terminar) { cout << "Escribe el valor " << endl; cin >> entrada; if (entrada == valorTerminar) { terminar = true; } else { terminar = false; i = i + 1; total = total + entrada; } } cout << "El total es: " << total << endl; cout << "El total de valores introducidos es: " << i << endl; cout << "El promedio es: " << (total / i) << endl; return 0; }Haz clic en la imagen para ver una salida del programa:
En ocasiones será necesario realizar decrementos, es decir, disminuir el valor de nuestro contador, para lograr este efecto será necesario restar en lugar de sumar.
Analiza el siguiente ejemplo.
// cpp_35_decremento1.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Se utiliza un contador para contar las palabras introducidas // Se ilustra el uso de DECREMENTOS // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 1; string palabra; string texto; int numPalabras; //valor para indicar el fin de entradas bool terminar = false; cout << "Este programa mostrará en una línea las palabras que escribas " << endl; cout << "Primero indicarás cuántas palabras vas a introducir" << endl << endl; cout << "¿Cuántas palabras escribirás?" << endl; cin >> numPalabras; while (numPalabras > 0) { cout << "Escribe la pabra " << i << endl; cin >> palabra; i = i + 1; // No es indispensable pero lo utilizamos para mejorar la presentación texto = texto + palabra; //Concatenamos las palabras introducidas numPalabras = numPalabras - 1; } cout << "La cadena de texto es " << texto << endl; return 0; }
Puedes observar que no representa muchos cambios en relación a los aspectos que hemos revisado, analiza el código, los comentarios explican los puntos que podrían causar ciertas dudas.
Ahora sí podemos revisar la parte central de la lección.
La forma como se han construido las operaciones anteriores son propias de la mayoría de los lenguajes de programación que no son de la familia de C/C++. C/C++ ofrecen un grupo de operadores que simplifican las expresiones que requieren contadores y acumuladores.
Para los incrementos y decrementos expuestos párrafos atrás C++ ofrece un par de operadores que simplifican la implementación de los incrementos y decrementos de variable.
Nota: Los operadores de incremento y decremento funcionan en variables de tipo entero y de punto flotante.
Para incrementar una variable, C++ nos ofrece la siguiente notación:
++expresión
Para decrementar una variable C++ nos ofrece la siguiente notación:
--expresión
Reescribiendo el código para calcular el cuadrado de los números 1 a 10 tenemos:
// cpp_36_incremento4.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Este programa presenta el cuadrado de los números del 1 al 10 // Se ilustra el uso de operadores de incremento // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 1; //La inicialización de variables es muy importante. while (i <= 10) { cout<<"El cuadrado de : " << i << " es " << (i * i) << endl; ++i; //reemplaza a la expresión i = i + 1; } return 0; }
Es importante que te familiarices con la notación ++i y –i, debido a que todos los lenguajes derivados de C la utilizan (C++, Java, PHP, Python y un largo etcétera).
No te quedes con la idea de que i++ es una forma simplificada de i = i + 1 dado que es eso y mucho más.
|
---|
*En este tutorial queda fuera de alcance el tema de la sobrecarga del operadores. En este momento únicamente se menciona con el fin que tengas presente que la notación “pre” y “post” van más allá de una simplificación de algo del tipo i = i + 1 y i = i – 1
Si ++ precede a la variable, por ejemplo. ++a, el valor devuelto es el valor en el contador después que se ha incrementado. Si ++ sigue a la variable, por ejemplo. a++, el valor devuelto es el valor en el contador antes que se haya incrementado.
La mejor forma de comprender como funciona cada notación es, como siempre, con un programa.
// cpp_37_incremento5.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Se ilustra cómo se evalúa ++i, i++, --i, i-- // Se ilustra el uso de operadores de incremento // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 1; //La inicialización de variables es muy importante. int j = 1; cout << "El operador ++expresión y --expresión en acción" << endl; cout << "Valores iniciales i = " << i << ", j = " << j << endl; //Si ++ precede a la variable, por ejemplo. ++a, el valor devuelto es //el valor en el contador después que se ha incrementado. cout << "++i =" << ++i << endl; //Si ++ sigue a la variable, por ejemplo. a++, el valor devuelto es //el valor en el contador antes que se haya incrementado. cout << "j++ =" << j++ << endl; i = 1; //"reseteamos" valores j = 1; cout << "--i =" << --i << endl; //Decrementa i y lo devuelve en i cout << "j-- =" << j-- << endl; //Devuelve j antes que se incremente return 0; }
Dicho de forma simple:
++i incrementa la variable, después la devuelve.
i++ se crea una copia de la variable, la variable original se incrementa, y la copia se devuelve.
El tema de cuándo utilizar una forma y otra lo reservamos para el siguiente curso, cuando ya te sea familiar la estructura y la lógica del lenguaje, por lo pronto basta con señalar que la forma que se sugiere es es la notación precedente:
++expresión
Los operadores de asignación compuesta modifican el valor actual de una variable realizando una operación sobre la misma. Esto equivale a asignar el resultado de una operación al primer operando.
Los operadores de asignación compuesta definidos son:
Todos ellos operan como se muestra en la siguiente tabla.
Expresión | Equivale a… |
---|---|
y += x; | y = y + x; |
x -= 5; | x = x – 5; |
x /= y; | x = x / y; |
precio *= unidades + 1; | precio = precio * (unidades +1); |
x >>= y; | x = x >> y; |
x <<= y; | x = x << y; |
x >>>= y + 1; | x = x >>> (y + ); |
x &= y; | x = x & y; |
x ^= y; | x = x ^ y; |
x |= y; | x = x | y; |
Puedes notar que los operadores de asignación compuesta son una generalización de los operadores incrementales y decrementales
Considera las siguientes expresiones:
int i = 5; int j = 1;Para sumar i + j podemos expresar:
i += j; // i = 6, Equivale a i = i + j;
Para restar i – j podemos expresar:
i -= j; // i = 4 Equivale a i = i - j;
// cpp_38_OperadoresCompuestos1.cpp // Este programa forma parte del tutorial de introducción al lenguaje C++ // http://a.ehack.info/leguaje-c-introduccion/ // Este programa presenta el uso de los operadores de asignación compuesta // 2017, Por http://about.me/carlosgbr // Versión 1 // Compilado en https://www.onlinegdb.com/online_c++_compiler #include <iostream> using namespace std; int main() { int i = 10; int j = 2; i += j; //i = 12, equivale a i = i + j cout << i << endl; i = 10; j = 2; i -= j; //i = 8, equivale a i = i - j cout << i << endl; i = 10; j = 2; i *= j; //i = 20, equivale a i = i * j cout << i << endl; i = 10; j = 2; i /= j; //i = 5, equivale a i = i / j cout << i << endl; i = 10; j = 2; i %= j; //i = 0, equivale a i = i % j cout << i << endl; return 0; }
Aunque son simples los conceptos descritos en esta lección, si eres nuevo programando, es probable que te cueste un poco de trabajo familiarizarte con ellos, no te desesperes, practica y trata de entenderlo. Se utilizan ampliamente al momento de programar, casi todos los tutoriales se dedican a poner una tabla y 3 ejemplos, creo que el tema bien vale ser más amplios como se ha hecho.
Practica, solo así dominarás el tema.
Referencias
Incremento y decrementos de variable: contadores y acumuladores by Roberto C. González is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
El comando dnsenum es una herramienta de línea de comandos para realizar enumeración de DNS…
En esta entrada te presento 24 de las listas negras más comunes que los servidores…
ZoomIt es una herramienta de anotación y zoom de pantalla para presentaciones técnicas que incluyen…
WinObj es el visor de espacios de nombres de Object Manager definitivo. Es la primera…
Whois realiza el registro de registro para el nombre de dominio o la dirección IP…
VolumeID – Esta utilidad, le permite cambiar los identificadores de los discos FAT y NTFS…