------------------------------------------------------------------------------------

---------------

Precedencia de los operadores

Una expresión está compuesta por operadores, variables y constantes. Para simplificar,
podemos pensar que la forma en la que C evalúa esta expresión es dividiendo el todo en
subexpresiones. Las reglas que definen que subexpresión evaluar primero, se
denominan reglas de precedencia. Aunque siempre podemos alterar dichas reglas
mediante la utilización de paréntesis. En la siguiente tabla detallamos la precedencia
entre los operadores de C.
Capítulo 6:

Operadores
Enlaces patrocinadosDiplomado En Coaching Ont
Conviertete En Coach Internacional Avalado por la U.N.A.M. y Flapco.
www.cocrear.com.mx

OPERADORES

C es un lenguaje muy rico en operadores. Se definen seis tipos de operadores

aritméticos, relacionales, de asignación, lógicos, de dirección y de movimiento.

Existe otro tipo de operador denominado molde que su función es hacer posible que una
expresión sea de un tipo determinado utilizando la sintaxis (tipo) expresión;

Siendo tipo uno de los tipos estándar de C (ver capítulo 4). Por ejemplo, si se quiere
asegurar que la expresión x/2 se evalúe de tipo float, se puede escribir: (float) x/2;.
6.1 Operadores aritméticos

Lista de operadores aritméticos con su significado

+ Suma
- Resta
* Producto
/ Cociente de una división
% Resto de una división

6.2 Operadores lógicos

! Not (no lógico)

&& And (y lógico)
|| Or (ó lógico)

6.3 Operadores relacionales

== Igual a
!= No igual a
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que

6.4 Operadores de asignación

===
++ m++ m=m+1
-- m-- m=m-1
+= m+=n m=m+n
-= m-=n m=m-n
*= m*=n m=m*n
/= m/=n m=m/n
%= m%=n m=m%n

• Curso ITIL® v3 Foundation The ITIL Experience ¡ Certificación Garantizada !

Próximas Fechas DF
www.inteli.com.mxEnlaces patrocinados

Los operadores de asignación ++ y ¿ pueden ir antes o delante de una expresión

formando una nueva expresión. Estas expresiones se denominan post-incrementos o
pre-incrementos (decrementos si el operador es --) y son expresiones compuestas,
normalmente son del tipo y=x++; (y=++x;).

Existen una diferencia entre el post-incremento y el pre-incremento. El post-incremento

primero suma uno a la variable (x en el ejemplo) y luego asigna ese valor (y en el
ejemplo), mientras con el pre-incremento, la asignación es anterior.

Por ejemplo: y=x++; (y=++x;).

Existen una diferencia entre el post-incremento y el pre-incremento. El post-incremento
primero suma uno a la variable (x en el ejemplo) y luego asigna ese valor (y en el
ejemplo), mientras con el pre-incremento, la asignación es anterior.

Por ejemplo:
int x=1, y;
y=x++; /* y es 1 y x vale 2 */
int x=1, y;
y=++x; /* x vale 2 e y también vale 2 */

6.5 Operadores de dirección

* Operador de contenido de apuntado u operador de indirección & Operador de

dirección

6.6 Operadores de movimiento

Existe un último tipo de operadores, no comentado hasta el momento, los operadores de

movimiento (<<, movimiento a la izquierda y >>, a la derecha). Su función es desplazar
los bits de la palabra de memoria dada tantos espacios como se le indiquen a derecha o
izquierda. La forma general es: expresion1<< expresion2

Los dos operandos deben ser del tipo entero, y mueve los bits de la expresion1 tantas
posiciones como se lo indique la expresion2 (en este caso hacia la izquierda).

Por ejemplo, sea x un entero con representación interna:

00010001110011000101010111111111x<<4; da como resultado:
00011100110001010101111111110000 da como resultado:
00011100110001010101111111110000

da como resultado: 00011100110001010101111111110000

6.7 Prioridad y asociatividad de los operadores

Lista en la que se muestra el Operador y la Asociatividad

() [] De izquierda a derecha
- ++ -- ! ~ * & sizeof(tipo) De derecha a izquierda
* / % De izquierda a derecha
+ - De izquierda a derecha
<< >> De izquierda a derecha
< <= > >= De izquierda a derecha
== != De izquierda a derecha
& De izquierda a derecha
&& De izquierda a derecha
|| De izquierda a derecha
?: De derecha a izquierda
= *= /= %= += -= &= <<= >>= De derecha a izquierda
, De izquierda a derecha
Tabla 3.5: Operadores a nivel de bit
Operador Acción
& AND a nivel de bit.

OR a nivel de bit.

XOR a nivel de bit.

Complemento.

Desplazamiento a la izquierda.

Desplazamiento a la derecha.

Tabla 3.6: Precedencia de operadores

Mayor precedencia

()[]- .
! ++ * & sizeof (operadores unarios)
*/%
+-

== !=
&

&&

?:
= += -= *= /= %=
,
Menor precedencia
2.2.3 Modificadores de tipo

§1 Sinopsis

Hemos señalado ( 2.2.1) que los modificadores opcionales que pueden acompañar a
los tipos básicos son: con signo, sin signo, largo y corto; y que se aplican con las
palabras clave. long, short, signed, unsigned. Por otra parte, la creciente
implementación de procesadores con longitud de palabra de 64 bits, hace suponer que
pronto se extenderán los tipos actuales incluyendo versiones extra-largas de los enteros
( Tipos extendidos).

§2 long

Sintaxis:

long [int] <identificador> ;

[long] double <identificador> ;

Descripción:

Cuando se utiliza este modificador sobre un int, crea un tipo que dobla el espacio de
almacenamiento utilizado para almacenar un int [1]. Cuando se utiliza para modificar
un double, define un tipo de dato de coma flotante, long double, con 80 bits de
precisión, no los 128 (2x64) que cabría esperar ( 2.2.4 Representación interna y
precisión).

Existen los siguientes tipos de long:

long x; // x es signed long int

long int x; // x es signed long int
signed long x; // x es signed long int
signed long int x; // x es signed long int
unsigned long x; // x es unsigned long int
unsigned long int x; // x es unsigned long int

§3 short

Sintaxis:

short int <identificador> ;

Descripción:

El modificador short se utiliza cuando se desea una variable menor que un int. Este
modificador solo puede aplicarse al tipo base int (si se omite el tipo base, se asume int
por defecto).

Existen los siguientes tipos:

short x; // x es signed short int

short int x; // x es signed short int

signed short x; // x es signed short int

signed short int x; // x es signed short int

unsigned short x; // x es unsigned short int

unsigned short int x; // x es unsigned short int

Ejemplos:

short int i;
short i; // equivale a: "short int i;"

§4 signed

Sintaxis:

signed <tipo> <identificador> ;

Descripción:

El modificador de tipo signed define que el valor de una variable numérica puede ser
positivo o negativo. Este modificador puede ser aplicado a los tipos básicos int, char,
long, short y __int64. Según se indica en el ejemplo, si no se indica el tipo básico, el
modificador por si solo supone signed int.

El efecto que tiene este modificador, es que parte de la capacidad de almacenamiento

del tipo base al que se aplica, se utiliza para especificar el signo, por lo que el máximo
valor absoluto que es posible guardar es menor que el correspondiente valor unsigned
del mismo tipo base ( 2.2.4 Tipos de datos y representación interna).

Ejemplos:

signed int i; // signed es valor por defecto (no es preciso)

int i; // equivalente al anterior

signed i; // equivalente al anterior

unsigned long int l; // Ok

unsigned long l; // equivale al anterior

signed char ch; // Ok

unsigned char ch; // Ok

§5 unsigned

Sintaxis:

unsigned <tipo> <identificador> ;

Descripción:

Este modificador se utiliza cuando la variable sea siempre positiva. Puesto que no es
necesario almacenar el signo, el valor absoluto puede ser mayor que en las versiones
con signo. Puede aplicarse a los tipos base int, char, long, short e __int64. Cuando no
se indica tipo base, por defecto se supone que se trata de un int (ver los ejemplos).

Ejemplos:

unsigned int i;

unsigned i; // equivale al anterior

unsigned long int l; // Ok

unsigned long l; // Equivale al anterior

unsigned char ch; // Ok

char ch; // Equivale al anterior

§6 Tipos enteros extendidos

La progresiva utilización de procesadores de 64 bits, de los que pronto existirán

versiones para ordenadores de sobremesa, junto con el crecimiento espectacular de la
memoria disponible, tanto en RAM como en disco, hace que sea razonable esperar
versiones de C++ que permitan utilizar enteros con más de 32 bits. Entre otras razones,
porque rápidamente serán normales almacenamientos de disco con más capacidad de la
que puede direccionarse directamente con palabras de 32 bits.

En la actualidad se está trabajando en un estándar, conocido como C9x que se espera

sea adoptado oficialmente en breve (2001). Esta versión incluye nuevos especificadores
opcionales long long en versiones con y sin signo [2].

El cuadro adjunto muestra la propuesta existente para los citados modificadores. Como
puede verse, siguiendo la tradición, se supone int si no se indica otro tipo base. Además
por defecto long long se supone con signo.

long long x; // x es signed long long int

long long int x; // x es signed long long int
signed long long x; // x es signed long long int
signed long long int x; // x es signed long long int
unsigned long long x; // x es unsigned long long int
unsigned long long int x; // x es unsigned long long int
§7 Extensiones C++Builder

Este compilador C++ de Borland permite especificadores opcionales para los enteros,
más allá de lo especificado en el estándar (alguno en línea de los nuevos tipos que se
esperan). Estos modificadores opcionales permiten definir el tipo de almacenamiento
que se utilizará para el entero. Para utilizarlos es preciso usar también los sufijos que se
indican en cada caso:

Sufi Almacenami
Tipo Ejemplo
jo ento

__int8 i8 __int8 c = 127i8; 8 bits

__int16 i16 __int16 s = 32767i16; 16 bits

__int32 i =
__int32 i32 32 bits
123456789i32;

__int64 big =
__int64 i64 64 bits
12345654321i64;
unsigned
__int64
ui64 unsigned __int64