Existen tres estructuras en C que no tienen sentido cuando se ven por primera vez, ya que no son intuitivas, pero al contrario, son extremadamente útiles para incrementar la eficiencia del código compilado y las usan muchos programadores expertos en C.
El programa 14CRIPTICA.CPP es un ejemplo de 3 nuevas construcciones.
# include <iostream.h>
main()
{
int x = 0,y = 2,z = 1025;
float a = 0.0,b = 3.14159,c = -37.234;
// incrementando
x = x + 1; // Incrementa x
x++; // Incrementa x
++x; // Incrementa x
z = y++; // z = 2, y = 3
z = ++y; // z = 4, y = 4
// decrementando
y = y - 1; // Decrementa y
y--; // Decrementa y
--y; // Decrementa y
y = 3;
z = y--; // z = 3, y = 2
z = --y; // z = 1, y = 1
// operador aritmético
a = a + 12; // Añade 12 a a
a += 12; // Añade 12 más a a
a *= 3.2; // Multiplica a por 3.2
a -= b; // Resta b a a
a /= 10.0; // Divide a entre 10.0
// expresión condicional
a = (b >= 3.0 ? 2.0 : 10.5 ); // Esta expresión
if (b >= 3.0) // Y esta expresión
a = 2.0; // son idénticas, ambas
else // producen el mismo
a = 10.5; // resultado.
c = (a > b?a:b); // c tendrá el máximo de a o b
c = (a > b?b:a); // c tendrá el mínimo de a o b
}
En este programa algunas variables son definidas e inicializadas en el mismo mandato, para su uso posterior.
El primer mandato ejecutable, simplemente suma 1 al valor de “x”. Los dos siguientes mandatos también añaden 1 al valor de “x”, pero utilizando el operador de incremento de C++, un doble signo más (++) antes o después de una variable, incrementa su valor en 1.
Si el signo está antes de la variable, es incrementada antes de su uso: z = ++y, incrementa “y” para después asignar su valor a “z”.
Si el signo está después de la variable, ésta es usada e incrementada posteriormente: z = y++, asigna a “z” el valor de “y”, luego incrementa esta última variable.
El siguiente grupo de mandatos ilustran el decremento en 1 de una variable, utilizando el operador de decremento, el doble signo menos (—). Funciona igual que el incremento excepto, obviamente, en que en este caso se resta 1 a la variable.
Otros operadores se usan para modificar una variable en algún valor constante. El primer mandato del grupo del operador aritmético sencillamente suma 12 al valor de “a”. El segundo hace lo mismo, pero utilizando la expresión “+=“. Algunas de las funciones aritméticas básicas, +, – ,*,/, pueden tratarse de esta manera, poniendo la función deseada delante del signo igual, y eliminando la segunda referencia al nombre de la variable. Nótese que la expresión a la derecha del operador aritmético puede ser expresión válida.
Al igual que el incremento/decremento, el operador aritmético es una de las herramientas habituales de un buen programador.
LA EXPRESIÓN CONDICIONAL
La expresión condicional es, al igual que los dos anteriores, un críptico. Consiste en 3 expresiones entre paréntesis, separadas por un signo de interrogación y dos puntos. La expresión prioritaria en el interrogante es evaluada para determinar si es verdad o falso. Si es verdad, la expresión entre interrogantes y dos puntos es evaluada y, si es “no verdad”, la expresión que sigue a los dos puntos se evalúa. El resultado de la evaluación se usa en la asignación. El resultado final es idéntico que un if con else.
a = (b >= 3.0 ? 2.0 : 10.5 ) Si b >=3.0 “a” será igual a 2.0 sino, “a” se igualará a 10.5
Esto viene ilustrado en el segundo ejemplo de este grupo. La expresión condicional tiene la ventaja añadida de un código más compacto, el cual compilará la máquina en pocas instrucciones en el programa.
Las dos líneas finales del programa ejemplo ilustran una manera muy compacta de asignar la mayor de 2 variables, “a” o “b” a “c” y, de asignar la menor de esas variables a “c”.
Las palabras const y volatile
En el programa 15CONS_VOL.CPP vemos la utilización de estas nuevas palabras en C++.
#include <iostream.h>
main()
{
const int FIN = 9; // El valor de FIN no podrá cambiarseconst int PRINCIPIO = 3; // El valor de PRINCIPIO no podrá cambiarse
volatile int CENTRO = 6; // El valor de CENTRO podrá ser cambiado
// por algo externo a este programa.
int indice; // Una variable normal de C
for (indice = PRINCIPIO ; indice < FIN ; indice++)
cout << "El valor del índice es " << indice << "\n";
}
La palabra const se usa para definir una constante.
En la línea 5 la constante es de tipo int (entero), se llama PRINCIPIO, y se le asigna el valor 3. El compilador no permitirá que accidentalmente, o aún queriéndolo, se cambie el valor de PRINCIPIO porque se ha declarado como constante. Si existiera una variable llamada PRINCIPIOS, el sistema no permitiría que accidentalmente se cambiara el valor de PRINCIPIO. El compilador daría un mensaje de error, ya que no está permitido cambiar el valor de una constante.
La palabra volatile indica que podrá cambiarse el valor de la variable así declarada. Aunque el valor de una variable volátil puede ser cambiado por el programador, puede haber otro mecanismo para que el valor pueda cambiarse, tal como por un procedimiento que ocasione su incremento. El compilador necesita saber que este valor puede ser cambiado por alguna fuerza externa al avanzar el programa.
EL OPERADOR DE ALCANCE
El programa llamado 16OP_ALCAN.CPP ilustra otra construcción que es nueva en C++.
Esto permite acceso al índice declarado como variable global, (declarada antes del main) aunque hay una variable local del mismo nombre dentro de la función principal.
El uso del doble dos puntos (::) antes del nombre de la variable, en las líneas 10, 12 y 15, indica que estamos interesados en usar el índice global, definido en la línea 3, y no en el índice local definido en la línea 7.
#include <iostream.h>
int indice = 13;
main()
{
float indice = 3.1415;
cout << "El valor del índice local es " << indice << "\n";
cout << "El valor del índice global es " << ::indice << "\n";
::indice = indice + 7; // 3 + 7 resultará en 10
cout << "El valor del índice local es " << indice << "\n";
cout << "El valor del índice global es " << ::indice << "\n";
}
El uso de esta técnica permite acceso a la variable global para cualquier uso. Podría usarse en cálculos, como un parámetro de función, o para cualquier otro propósito.
En la práctica realmente buena de un programador no se debe abusar de esto, porque podría hacer que el código sea difícil de leer. Sería mejor usar un nombre diferente para cada variable, en vez de repetir uno solo, pero esta construcción está disponible si se la necesita alguna vez.
