Español 
Contadores y acumuladores
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.
Incrementar el valor de una variable.
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,
Ejemplo de incremento
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:
- El valor de inicialización es fundamental, prueba quitando el valor de inicialización, analiza la conveniencia o no de la inicialización de la variable.
- El signo de comparación utilizado, utilizamos <= como signo de comparación, si hubiéramos utilizado únicamente <, nuestro programa debe ser retocado, prueba usando < en lugar de <=, modifica el código para obtener el mismo resultado.
- La reutilización de una variable solo hay que saber que se quiere obtener y ser cuidadoso en cómo se utilizan y puedes obtener resultados muy interesantes.
- La posición de la expresión de incremento, ponerla después de cout no es algo al azar, cambia su posición antes de cout y observa el resultado, déjalo ahí y ajusta el programa para que siga mostrando los cuadrados del 1 al 10.
Contadores
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:
Acumuladores
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:
Decrementos
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.
Operadores de incremento y decremento
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.
Incremento
Para incrementar una variable, C++ nos ofrece la siguiente notación:
++expresión
- en donde expresión es un valor entero o real.
- ++expresión es equivalente a expresión = expresión + 1
Decremento
Para decrementar una variable C++ nos ofrece la siguiente notación:
--expresión
- en donde expresión es un valor entero o real.
- –expresión es equivalente a expresión = expresión – 1
Ejemplo
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
Cómo funciona a nivel interno el incremento y decremento de variables
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
Uso de Operadores de asignación compuesta
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;
Finalmente mostramos un programa de muestra que cubre varios de estos ejemplos.
// 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;
}
Conclusión
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
Fuente Imágenes
- Portada: Operadores de Asignación compuesta»: by Daniel Álvarez
- «Todas las demás imágenes de esta sección»: by Nala Systems
Código Fuente
- El código fuente de toda la serie lo puedes descargar en nuestro repositorio en github busca los programas con el nombre del encabezado de cada programa.
- Código de esta sección
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.
