UNIVERSIDAD AUTONOMA DE

CHIAPAS (UNACH)
FACULTAD DE CONTADURIA Y
ADMINISTRACION C-1

LICENCIATURA EN SISTEMAS COMPUTACIONALES

ASIGNATURA: HERRAMIENTAS DE LA COMPUTACION

TEMA: OPERADORES E IDENTIFICADORES

SEMESTRE Y GRUPO: 1RO C

CATEDRATICO: LIC.CHAMBE MORALES PEDRO ANTONIO

ALUMNA:

KAREN MANUEL ALEGRIA

TUXTLA GUTIERREZ, CHIAPAS; MAYO, 2009

OPERADORES E IDENTIFICADORES
El manejo de los datos comprende expresiones compuestas de operandos y
operadores. C++ soporta varios tipos de operadores y expresiones.

Los operadores son símbolos especiales que toman los valores de los
operandos y producen un nuevo valor. También se puede definir como un
símbolo especial que indica al compilador que debe efectuar una operación
matemática o lógica.

Operadores aritméticos
Los operadores aritméticos se usan en expresiones aritméticas, como
“z=y+x”. Las variables y y x son operandos y el + es un operador. El
resultado de la expresión depende de los tipos de datos de los operandosy
se guarda en z. Si ambos operandos son expresiones de enteros, el
compilador produce el código para una división de enteros.

Estos operadores permiten escribir expresiones cuya evaluación es

precisamente el tratamiento de información que efectúa el ordenador. Los
operadores aritméticos, junto con una amplia gama de funciones residentes
en la biblioteca del lenguaje empleado, hacen posible realizar cálculos de
todo tipo.

Operadores aritméticos de C++

Operador Objetivo Tipo de Ejempl

C++ dato o
+ Suma Numérico z=y+x;
- Resta Numérico z=y-x
* Multiplicació Numérico z=y*x
n
/ División Numérico z=y/x
% Modulo Entero z=y%x

Ejemplo:

En enteros En fracciones

10+5=15 1.25+2.58=3.83

10-5=5 1.25-2.58=-1.33

10*5=50 1.25*2.58=3.225

10/5=2 1.25/2.58=0.484496

10 mod 5=0
Operadores de incremento y decremento
C++ soporta los operadores especiales de incremento y decremento.

Los operadores de incremento (++) y decremento (--) le permiten

incrementar y decrementar en 1, respectivamente, el valor que se guarda
en una variable.

Los operadores unitarios ++ (incremento) y -- (decremento), suman y

restan respectivamente una unidad al valor de la expresión. Existen dos
variedades "Pre" y "Post" para cada uno de ellos.

En los ejemplos que siguen suponemos que originariamente n == 5.

El postincremento añade uno a la expresión después de que se ha

evaluado:

x = n++ ; // -> x == 5 y n == 6

El preincremento añade uno antes de que sea evaluada la expresión.

x = ++n ; // -> x == 6 y n == 6

El postdecremento resta uno del valor de la expresión después de que sea

evaluada.

x = n-- ; // -> x == 5 y n == 4

El predecremento resta uno antes de la evaluación de la expresión.

x = --n ; // -> x == 4 y n == 4

Operadores de incremento
La sintaxis general para los operadores de incremento es:

variable++ // posincremento

++variable // preincremento

Ejemplos:

LineNumber++;

++index;

Operadores de decremento
La sintaxis general para los operadores de decremento es:

variable-- // posdecremento

--variable // predecremento
Ejemplos:

LineNumber--;

--index;

Esta sintaxis general demuestra que hay dos formas de aplicar los
operadores ++ y --. Poner estos operadores a la izquierda de sus operandos,
cambia el valor del operando antes de que este contribuya con su valor a
una expresión. De la misma forma, poner estos operadores a la derecha de
sus operandos, altera el valor del operando después de que este contribuye
con su valor a una expresión. Si los operadores ++ o – son los únicos en un
enunciado, no hay distinción practica entre el uso de las formas pre y pos.

A continuación se muestra unos cuantos ejemplos sencillos:

Int n, m, t=5

t++; // t es ahora 6, el mismo efecto que ++t

--t; // t es ahora 5, el mismo efecto que t—

n=4*t++; // t es ahora 6 y n es 20

t=5;
m=4*++t; // t es ahora 6 y m es 24

El primer enunciado usa el operador ++ de posincremento para incrementar

el valor de la variable t. Si en lugar de ello escribe ++t, obtendrá el mismo
resultado cuando el enunciado termine su ejecución. El segundo enunciado
usa el operador de predecremento. Nuevamente, si en lugar de ello escribe
t--, obtendrá el mismo resultado. El siguiente enunciado usa el operador ++
de posincremento en una expresión matemática sencilla. Este enunciado
multiplica 4 por el valor actual de t (esto es, 5), asigna el resultado 20 a la
variable n y luego incrementa el valor de la variable t a 6. Los últimos dos
enunciados muestran un resultado diferente. El enunciado incrementa
primero el valor de la variable t (este valor se convierte en 6), luego realiza
la multiplicación y, por ultimo, asigna el resultado de 24 a la variable m.

Operadores de asignación
La asignación es una operación consistente en calcular el valor de una
expresión y copiar ese valor en algún lugar, que se indicará en la propia
expresión de asignación.

Ejemplo:
x = 3;
x = 4;
x = 5;

Las expresiones de asignación producen un resultado.

C++ proporciona operadores de asignación especiales que se combinan con

operadores matemáticos sencillos. Estos le permiten usar una notación
abreviada para afectar un solo operando.

Operadores aritméticos de asignación

Operadores de Forma Ejemplo

asignación larga
x+=y x=x+y x +=12;
x -=y x=x-y x -=34+y;
x *=y x=x*y escala*=1
0;
x /=y x=x/y z/=34*y;
x %=y x=x%y z%=2;

Operadores relacionales y lógicos

C++ no deletrea los operadores AND, OR y NOT. En su lugar, usa símbolos
de uno y dos caracteres. También C++ no soporta el operador relacional
XOR.

Los operadores relacionales (menor que, mayor que o igual a) y los

operadores lógicos (AND, OR y NOT) son los bloques de construcción
básicos en las construcciones de toma de decisiones de cualquier lenguaje
de programación.

Los operadores lógicos sirven para calcular el valor de expresiones lógicas,

esto es, de expresiones en que los únicos valores que pueden tomar los
operandos son Verdadero o Falso.

Los operadores lógicos producen un resultado booleano, y sus operandos

son también valores lógicos o asimilables a ellos (los valores numéricos son
asimilados a cierto o falso según su valor sea cero o distinto de cero).

Las expresiones conectadas con los operadores && y || se evalúan de

izquierda a derecha, y la evaluación se detiene tan pronto como el resultado
verdadero o falso es conocido.

Los operadores relacionales son adecuados para comparar valores

numéricos u ordinales (caracteres individuales o valores enumerados), pero
no para comparar cadenas o listas de cualquier tipo.
Los operadores relacionales, también denominados operadores binarios
lógicos y de comparación, se utilizan para comprobar la veracidad o
falsedad de determinadas propuestas de relación (en realidad se trata
respuestas a preguntas). Las expresiones que los contienen se denominan
expresiones relacionales. Aceptan diversos tipos de argumentos, y el
resultado, que es la respuesta a la pregunta, es siempre del tipo cierto/falso,
es decir, producen un resultado booleano.
Si la propuesta es cierta, el resultado es true (un valor distinto de cero), si
es falsa false (cero).

Operadores relacionales y lógicos de C++.

Operador Significado Ejemplo

C++
&& AND lógico If(i > 1 &&
i<10)
II OR lógico If(c==0 I I
c==9)
! NOT lógico If(!(>1 &&
c<9))
< Menor que If(i<0)
<= Menor que o igual If(i<=0)
a
> Mayor que If(j>10)
>= Mayor que o igual If(x>=8.2)
a
== Igual a If(c==0)
!= No igual a If(c != n)

Precedencia
La precedencia es una regla de orden que se asocia con los
operadores para establecer cual se aplicará primero en caso de
aparecer varios en una misma expresión (una especie de "orden de
importancia" de los operadores). Por ejemplo:
x = 2 + 3 * 4;
¿Cual será el resultado, 20 o 14?

La primera regla en este sentido es que las expresiones se evalúan de

izquierda a derecha, aunque no siempre. Por ejemplo, la regla
izquierda → derecha nos conduciría a que en la expresión anterior, el
valor de x es 20, lo cual no es cierto, ya que en C++ la multiplicación
tiene mayor precedencia que la suma, así que el resultado es 14.
En C++ existen 16 niveles de precedencia, de modo que la regla
izquierda → derecha solo se aplica en caso de operadores del mismo
nivel.
El operador de jerarquía más alta es el paréntesis, lo que aclara y
justificada la tradicional costumbre algebraica de utilizar paréntesis
para forzar el orden de las operaciones. Por ejemplo, si queremos que
en la expresión anterior se ejecute primero el operador suma:
x = (2 + 3) * 4; // el resultado es 20
Aunque las reglas de precedencia se suponen conocidas por los
programadores C++, aconsejamos generosidad a la hora de utilizar
paréntesis en las expresiones. Además de facilitar la legibilidad evitan
posibles errores. Así, aunque las dos sentencias que siguen son
equivalentes, la segunda es de lectura más "relajante".
x = 2 + 3 * 4;
x = 2 + (3 * 4);
En síntesis los operadores aritméticos incluyen +, -, *, / y %(modulo).
Los operadores de incremento y decremento se presentan en formas
pre y pos. C++ permite aplicar estos operadores a las variables que
almacenan caracteres, enteros y hasta números de punto flotante.
Los operadores aritméticos de asignación le permiten escribir
expresiones aritméticas mas cortas, donde el operando principal
también es la variable que recibe el resultado de la expresión.
Los operadores relacionales y lógicos permiten que se construyan
expresiones lógicas.
Los caracteres subsecuentes de un identificador pueden ser letras,
dígitos o subrayados. Los identificadores de C++ son sensibles a
mayúsculas y minúsculas. Sin embargo, este límite puede cambiarse
manejando las opciones del compilador.

IDENTIFICADORES
 Un identificador es una secuencia de caracteres, letras, dígitos y
subrayados (_). El primer carácter debe ser una letra (no
subrayado). Las letras mayúsculas y minúsculas son diferentes
EJEMPLOS:
nombre_clase Índice Dia_Mes_Año
elemento_mayor Cantidad_Total
a Habitación_

C++ es sensible a las mayúsculas. Por consiguiente, C++

reconoce como distintos los identificadores, ALFA Y alfa. Le
recomendamos que utilice el mismo estilo al escribir sus
identificadores. Un consejo de posible regla puede ser:

1.-Escribir identificadores de variables con letras minúsculas.

2.- Constantes en mayúsculas.
3.-Funciones con tipo de letra mixto: mayúscula/minúsculas.

Identificadores C++
Los identificadores C++ pueden contener las letras a a z y A a Z,
el guión bajo "_" y los dígitos 0 a 9.

Caracteres permitidos:
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXY
Z
_

Dígitos permitidos
0123456789

Solo hay dos restricciones en cuanto a la composición:

• El primer carácter debe ser una letra o el guión bajo. El
estándar establece que los identificadores comenzando con
guión bajo y mayúscula no deben ser utilizados. Este tipo de
nombres se reserva para los compiladores y las Librerías
Estándar. Tampoco se permite la utilización de nombres que
contengan dos guiones bajos seguidos.
 • El estándar ANSI establece que como mínimo serán
significativos los 31 primeros caracteres, aunque pueden ser
más, según la implementación. Es decir, para que un
compilador se adhiera al estándar ANSI, debe considerar como
significativos, al menos, los 31 primeros caracteres.

Los identificadores distinguen mayúsculas y minúsculas, así que Sum,

sum y suM son distintos para el compilador. Sin embargo, C++
Builder ofrece la opción de suspender la sensibilidad a mayúsculas /
minúsculas, lo que permite la compatibilidad con lenguajes
insensibles a esta cuestión, en este caso, las variables globales Sum,
sum y suM serían consideradas idénticas, aunque podría resultar un
mensaje de aviso "Duplicate symbol" durante el enlazado.
Nombres: Identificadores
El nombre de una variable (o cualquier otra cosa que definamos en un
programa) es un identificador, el cual debe empezar con una letra o
con el símbolo de subrayado.

BIBLIOGRAFIA CONSULTADA
• Arnush, Craig, “Aprendiendo Borland C++ 5 en 21 días”, edit.
Prentice-Hall Hispanoamericana, S.A, 1997, México.
• Savitch, Walter, “Resolución de Problemas con C++”, edit.
Prentice Hall, Segunda Edición, 2000, México.