[Tutorial C++] II.2 - Variables y operadores

Ver el tema anterior Ver el tema siguiente Ir abajo

[Tutorial C++] II.2 - Variables y operadores

Mensaje  HarZe el Vie Jul 02, 2010 10:04 pm

Antes de empezar recomiendo leer los tutoriales de C al respecto de este tema, sobre variables y operadores. Considéralos una introducción, ahora al tema:

Variables

Las variables, que constan de dirección (nombre), valor contenido y tipo de valor, se declaran así:
Código:
tipo nombre;
En el que se le asigna por defecto el valor 0. Para declararlas y darles un valor, es decir, definirlas:
Código:
tipo nombre = valor;

El nombre es libre, simplemente no debe coincidir con el nombre de otra variables que no este en su ámbito, y no debe empezar por un número. El valor corresponde al que le asignemos con el operador = o a través de una función. En una mezcla de código y explicación, aquí tienes los tipos de variable heredados de C:
Código:
char c = 'p';
short s = 324;
int i = -1098;
long l = 341343;
float f = -9.87f;
double d = 342.34521234
Provienen de C, pero hay una nueva en C++, relacionada directamente con los valores lógicos (que solo admiten cierto: TRUE, o falso: FALSE). Es decir, un tipo de variable que solo admite dos valores: 0 y 1 (FALSE o TRUE respectivamente, tomados como macros de 0 y 1). Antes había que usar algún tipo de variable y tomar por valor lógico falso el valor 0, y por valor lógico cierto cualquiera distinto de 0. Esto podemos seguir usándolo como en C, pero el atajo que propone C++ es un nuevo tipo exclusivo para TRUE/FALSE: bool.
Código:
bool interruptor = TRUE;
interruptor = FALSE;
interruptor = 1;
Ahora hay que hablar de prefijos, de los cuales algunos como auto han perdido su sentido en C++. Estos prefijos son:
Código:
unsigned char c = 198;
long double d = -37.234;
static unsigned int = 49999;
Estos eran ejemplos, pero los prefijos como tal son: signed o unsigned, que quiere decir si tienes signo o no, si no tiene signo, permite el doble de números de valores positivo y ninguno negativo. El prefijo short y el long, son tanto tipos de datos enteros, como prefijo para disminuir o aumentar el tamaño del valor que soportan tipos decimales como double. El prefijo static hace que una variable privada no se elimine de la memoria cuando se deja de ejecutar la parte del código a cuyo ámbito pertenece. Se puede poner tantos prefijos como quieras siempre que no se anulen (como signed o unsigned) y procedan, es decir, esto es válido:
Código:
static unsigned long int decimal = 92342;

Una vez declaradas, las variables pueden cambiar su valor si están en un ámbito al que puedas acceder. Excepto si quieres crear un constante, es decir, un valor para usar, pero no para modificar. Esto se consigue con el prefijo const. Y volviendo al ejemplo de antes, esto es un valor que no podrá cambiar:
Código:
const static unsigned long int decimal = 92342;

Las variables tienen más características, en relación con los punteros, que se tratará más adelante.

Operadores aritméticos

Toca hablar de los operadores, pero a fondo. Hay que distinguir tres tipos de operaciones y operadores: los que modifican una variable, los que modifican dos y los que modifican tres. Por mas o menos ese orden, explicaré todos los operadores:

El operador clave para asignar valor a una variable es =. La única novedad que puedo dar respecto a este operador es la asignación múltiple:
Código:
int a, b, c;
a = b = c = 4;
Las tres variables han tomado el valor de 5, fuese cual fuese su valor previo. Es lo mismo que poner:
Código:
int a, b, c;
a = (b = (c = 4));
Es decir, el operador = tiene asociatividad D-I, de Derecha a Izquierda. El valor a asignar es el de la derecha, y a la izquierda las variables que toman ese valor. Por otro lado este operador tiene evoluciones de atajo, es decir, a menudo nos encontramos con que queremos sumar a una misma variable, un valor, es decir:
Código:
i = i + 4;
Esto es lo mismo que decir:
Código:
i += 4;
Por el mismo sistema tenemos 10 atajos:
Código:
+=  -=  *=  /=  %=  //como operadores aritméticos
<<=  >>=  &=  ^=  |=  //como operadores de bits

Hablemos ahora de los operadores aritméticos, es decir, las operaciones clásicas: suma (+), resta (-), multiplicación (*), división (/) y resto de la división de enteros (%). Pero hay que indicar que tienen niveles de prioridad, es decir:
Código:
9 * 4 + 12 / -4 = 33
Esto es porque los operadores + y - unitarios (es decir, que indican el signo del número) tienen máxima prioridad entre los operadores aritméticos. Después les siguen en prioridad *, / y %, y por último + y - cuando actúan para sumar y restar. Por pasos:
Código:
9 * 4 + 12 / -4 = 33
9 * 4 - 12 / 4 = 33 //Aplicado el 1er nivel de prioridad
36 - 3 = 33 //Aplicado el 2º nivel de prioridad
33 = 33 // Aplicado el 3er nivel de prioridad

Pero siempre puedes forzar la prioridad de las operaciones a tu gusto, yo por mi parte recomiendo usar paréntesis ante la duda de cuál es la prioridad, ya que poseen la máxima prioridad de entre todos los operadores, veamos:
Código:
(9 * (4 + 12)) / -4 = -(9 * 16)/4 = -36

Por otro lado tenemos otro "atajo" relacionado con los operadores aritméticos. En el caso de los bucles sobre todo usaremos mucho este atajo. Consiste en hacer que una variable aumente a disminuya su valor en un número entero. Es decir:
Código:
int a = 2, b = 3;
a++; //a pasa a valer 3
b--; //b pasa a valer 2
Pero este formato puede ser usado también como ++m o --m, que son lo mismo, excepto antes un operador de asignación, es decir:
Código:
int a = 1, b;
b = a++; //b valdrá 1 (valor inicial de a) y a valdrá desde ahora 2
Código:
int a = 1, b;
b = ++a; //b valdrá 2 (valor nuevo de a) y a valdrá 2
A estos operadores unitarios les podemos llamar de incremento y decremento.

Operadores lógicos

Con los operadores anteriores y las funciones de math.h, ya podemos hacer cualquier cálculo matemático convencional. Pero C++ no está limitado a eso, y al igual que en C, tenemos condiciones para que se ejecuten ciertas cosas. Y si tenemos una condición, o varias, debemos estudiar la lógica, si los valores son ciertos o falsos. Para acumular datos de tipo cierto/falso, ya he explicado las variables bool, y que VERDADERO (TRUE) es cualquier valor distinto de 0, y FALSO (FALSE) es 0.
Partiendo de aquí podemos operar valores lógicos (TRUE y FALSE) con estos operadores:
Código:
 a == b //Es TRUE si a y b son iguales
a != b //Es TRUE si a y b son distintos
a > b //Es TRUE si a es mayor que b
a < b //Es TRUE si a es menor que b
a >= b //Es TRUE si a es mayor o igual que b
a <= b //Es TRUE si a es menor o igual que b
Y si no es TRUE, a la fuerza es FALSE. Estos operadores lógicos son relacionales entre dos variables, consiguen que dos variables constituyan un único valor lógico, TRUE o FALSE.

Pero aparte, podemos manejar valores lógicos ya obtenidos, y operarlos entre si:
Código:
!condicion  //Si es TRUE, lo convierte en FALSE y viceversa
condicion1 && condicion2  //Devuelve TRUE si las dos condiciones son TRUE, sino devuelve FALSE
condicion1 || condicion2  //Devuelve TRUE si alguna, o ambas, de las dos condiciones son TRUE, sino devuelve FALSE
Podemos decir que ! significa lo invertir su valor lógico, && solo es TRUE cuando todos los valores lógicos que relaciona lo son; y || solo es FALSE cuando todos los valores lógicos que relaciona son FALSE. Dentro de los valores lógicos, también puedes usar paréntesis para aclarar la prioridad en caso de que haya variedad de operadores lógicos y condiciones complejas.

Operadores de bits

Esta orientado a la programación a bajo nivel, y no me voy a entretener mucho. Sólo diré que los números, y cualquier dato informático está escrito en bits o código binario (ceros y unos). Y que los operadores primarios son los que operan bits. Son: &, |, ^, ~, <<, >>. Aquí una sencilla tabla para entenderlo:
A&B == CA|B == CA^B == CA != ~A == B
0&0 == 00|0 == 00^0 == 00 != ~0 == 1
0&1 == 00|1 == 10^1 == 11 != ~1 == 0
1&0 == 01|0 == 11^0 == 1
1&1 == 11|1 == 11^1 == 0

Los operadores >> y <<, desplazan los bits de un número tanto lugares como indiques:
Código:
int a = 25;  //00011001
int num = a << 3;  //11001000

Operador condicionales

Es más bien una forma de condición, pero a su vez es un operador ternario. Ahora no me entretengo mucho, lo explicaré en Condiciones en C++. Simplemente:
Código:
valor_logico ? sentencia_si_es_TRUE : sentencia_si_es_FALSE;

Operador coma

Más que un operador, es un agrupador. Permite ejecutar varias sentencias en la misma línea. Por ejemplo para definir variables del mismo tipo:
Código:
int a = 1, b = 2, c = 3;
O cosas más raras como esta:
Código:
int a = 5;
int b = (a = 6, a + 2); //b finalmente vale 8

Operadores especiales

Ya hemos hablado de ellos, el primero es el paréntesis () que permiten alterar la prioridad de otros operadores, de lo que ya he dado muchos ejemplos.
Por otro lado están los corchetes [] que sirven para definir arrays o tablas, un tema que trataré mas adelante.
También he hablado ya del el operador de enlace, o de ámbito, ::, que permite usar o aclarar el ámbito de una función o variable que este asignada a un namespace o a una clase. Es un operador propio de C++ e inexistente en C que ya trataremos.
También tenemos el operador sizeof, que devuelve el tamaño en bytes de una tabla, una variable, etc... Un ejemplo sencillo:
Código:
int k = 500;
int tamanno = sizeof k; //tamanno será igual a 2, que es el tamaño en bytes de int

Por último, y por meterlo en algún sitio, como operadores unitarios, podemos hablar de la conversión de tipos de variables. Es decir, pasar de entero a decimal por ejemplo:
Código:
variable = (tipo_nuevo) variable_de_otro_tipo;
int a = 5;
float b = (float) a; //b será 5.0f
Solo debes tener en cuenta que no puedes convertir de una variable superior a una inferior, en tamaño o complejidad. Es decir, no puedes pasar de decimal a entero (hay funciones que quitan la parte decimal a los numeros, que es la forma correcta de hacer esto), ni puedes pasar un entero enorme a int o char, ni un negativo a una variable unsigned, ni otras cosas que creo que responden al sentido común.

HarZe
WebMaster & Desarrollador

Cantidad de envíos : 58
Fecha de inscripción : 21/06/2009
Edad : 24

Ver perfil de usuario http://opengl-esp.superforo.net

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.