Documento De Word

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 C++ + * / %

Objetivo Suma Resta Multiplicació n División Modulo

Tipo de dato Numérico Numérico Numérico

Ejempl o z=y+x; z=y-x z=y*x

Numérico Entero

z=y/x 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 asignación x+=y x -=y x *=y x /=y x %=y

de Forma larga x=x+y x=x-y x=x*y x=x/y x=x%y

Ejemplo x +=12; x -=34+y; escala*=1 0; z/=34*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 C++ && II ! < <= > >= == !=

Significado

Ejemplo

AND lógico

If(i > 1 && i<10) 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.