ESTRUCTURA DE DATOS EXTRACLASE # 8

ESTRUCTURA DE DATOS EXTRACLASE # 7

INSTITUTO TECNOLÓGICO HUAQUILLAS

ESTRUCTURA DE DATOS EXTRACLASE # 7

Nombre          : Gregorio Toledo

Curso             : Segundo Nivel

Profesor         : Ing. Robin Zamora

Fecha            : 27 de Diciembre del 2012

ESTRUCTURA DE DATOS EXTRACLASE # 6

INSTITUTO TECNOLÓGICO HUAQUILLAS

ESTRUCTURA DE DATOS EXTRACLASE # 6

Nombre          : Gregorio Toledo

Curso               : Segundo Nivel

Profesor          : Ing. Robin Zamora

Fecha              : 21 de Diciembre del 2012

OPERADORES, EXPRESIONES Y SENTENCIAS EN C++

OPERADORES ARITMÉTICOS

Los operadores aritméticos nos permiten, básicamente, hacer cualquier operación aritmética, que necesitemos (ejemplo: suma, resta, multiplicación, etc). En la siguiente tabla se muestran los operadores de los que disponemos en C y su función asociada.

Operador Acción Ejemplo Resta x = 5 3; // x vale 2 Suma x = 2 3; // x vale 5 Multiplicación x = 2 3; // x vale 6 División x = 6 2; // x vale 3 Módulo x = 5 % 2; // x vale 1 Decremento x = 1; x; // x vale 0 Incremento x = 1; x; // x vale 2

OPERACIONES INCREMENTALES

Los  operadores incrementales (++) y (--) son operadores unarios que incrementan o disminuyen en una unidad  el valor de la variable a la que afectan. Estos operadores pueden ir inmediatamente delante o detrás de la variable. Si preceden a la variable, ésta es incrementada antes de que el valor de dicha variable sea utilizado en la expresión en la que aparece. Si es la variable la que precede al operador, la variable es incrementada después de ser utilizada en la expresión. A continuación se presenta un ejemplo de estos operadores:

i = 2;

j = 2;

m = i++;          /* después de ejecutarse esta sentencia m=2 e i=3 */

n = ++j;            /* después de ejecutarse esta sentencia n=3 y j=3 */

OPERADORES DE ASIGNACIÓN

Los  operadores de asignación atribuyen a una variable –es decir, depositan en la zona de memoria correspondiente a dicha variable– el resultado de una expresión o el valor de otra variable (en realidad, una variable es un caso particular de una expresión).El operador de asignación más utilizado es el operador de igualdad  (=), que no debe ser confundido con la igualdad matemática. Su forma general es:

nombre_de_variable = expresion;

Cuyo funcionamiento es como sigue: se evalúa expresión y el resultado se deposita en

nombre_de_variable, sustituyendo cualquier otro valor que hubiera en esa posición de memoria anteriormente. Una posible utilización de este operador es como sigue:

variable = variable + 1;

OPERADORES RELACIONALES

Este es un apartado especialmente importante para todas aquellas personas sin experiencia en programación. Una característica imprescindible de cualquier lenguaje de programación es la de considerar alternativas, esto es, la de proceder de un modo u otro según se cumplan o no ciertas condiciones. Los operadores relacionales permiten estudiar si se cumplen o no esas condiciones. Así pues, estos operadores producen un resultado u otro según se cumplan o no algunas condiciones que se verán a continuación. En el lenguaje natural, existen varias palabras o formas de indicar si se cumple o no una determinada condición. En inglés estas formas son (yes, no), (on, off), (true, false), etc. En Informática se ha hecho bastante general el utilizar la última de las formas citadas: (true, false). Si una condición se cumple, el resultado es true; en caso contrario, el resultado es false.

OPERADORES LÓGICOS

Los  operadores lógicos son operadores binarios que permiten combinar los resultados de los operadores relacionales, comprobando que se cumplen simultáneamente varias condiciones, que se cumple una u otra, etc. El lenguaje C++ tiene dos operadores lógicos: el operador Y (&&) y el operador O (||). En inglés son los operadores and y or. Su forma general es la siguiente:

expresion1      ||        expresión        2

expresion1      &&      expresión        2

El operador && devuelve un 1 si tanto expresion1 como expresion2 son verdaderas (o iguales a 1), y 0 en caso contrario, es decir si una de las dos expresiones o las dos son falsas (iguales a 0); por otra parte, el operador || devuelve 1 si al menos una de las expresiones es cierta. Es importante tener en cuenta que los compiladores de C++ tratan de optimizar la ejecución de estas expresiones, lo cual puede tener a veces efectos no deseados. Por ejemplo: para que el resultado del operador && sea verdadero, ambas expresiones tienen que ser verdaderas; si se evalúa expresion1 y es falsa, ya no hace falta evaluar  expresion2, y de hecho no se evalúa. Algo parecido pasa con el operador ||: si expresion1 es verdadera, ya no hace falta evaluar expresion2. Los operadores && y || se pueden combinar entre sí, agrupados entre paréntesis, dando a veces un código de más difícil interpretación. Por ejemplo:

(2==1) || (-1==-1)                                                                 /* el resultado es 1 */

(2==2) && (3==-1)                                                                /* el resultado es 0 */

((2==2) && (3==3)) || (4==0)                                               /* el resultado es 1 */

((6==6) || (8==0)) && ((5==5) && (3==2))                           /* el resultado es 0 */

OTROS OPERADORES

Además de los operadores vistos hasta ahora, el lenguaje C++ dispone de otros operadores. En esta sección se describen algunos operadores unarios adicionales.

      Operador menos (–).

El efecto de este operador en una expresión es cambiar el signo de la variable o expresión que le sigue. Recuérdese que en C++ no hay constantes numéricas negativas. La forma general de este operador es:         - expresión

      Operador más (+).

Este es un operador unario de C++, y que tiene como finalidad la de servir de complemento al operador (–) visto anteriormente. Se puede anteponer a una variable o expresión como operador unario, pero en realidad no hace nada.

      Operador sizeof ().

Este operador de C++ puede parecer una función, pero en realidad es un operador. La finalidad del operador sizeof() es devolver el tamaño, en bytes, del tipo de variable introducida entre los paréntesis.

           

var_1 = sizeof(double)                                   /* var_1 contiene el tamaño

de una variable double */

      Operador negación lógica (!).

Este operador devuelve un cero (false) si se aplica a un valor distinto de cero (true), y devuelve un 1 (true) si se aplica a un valor cero (false). Su forma general es: !expresion

      Operador coma (,).

Los operandos de este operador son expresiones, y tiene la forma general:

expresion = expresion_1, expresion_2

En este caso, expresion_1 se evalúa primero, y luego se evalúa expresion_2. El resultado global es el valor de la segunda expresión, es decir de expresion_2. Este es el operador de menos precedencia de todos los operadores de C++.

      Operadores dirección (&) e indirección (*).

Aunque estos operadores se introduzcan aquí de modo circunstancial, su importancia en el lenguaje C++ es absolutamente esencial, resultando uno de los puntos más fuertes –y quizás más difíciles de dominar– de este lenguaje. La forma general de estos operadores es la siguiente:

*expresion;

&variable;

El operador dirección & devuelve la dirección de memoria de la variable que le sigue. Por ejemplo: variable_1 = &variable_2;

      Operadores new y delete.

Hasta ahora sólo se han visto dos posibles tipos de duración de las variables: static, las cuales existen durante toda la ejecución del programa, y automatic, que existen desde que son declaradas hasta que finaliza el bloque donde han sido declaradas.

      Operador de resolución de visibilidad (::).

Este operador permite acceder a una variable global cuando ésta se encuentra oculta por otra variable local del mismo nombre. Considérese el siguiente ejemplo:

int a=2;

void main(void){

int a =10;

cout << a << endl;                                         //muestra en pantalla 10

cout << ::a << endl;                                        //muestra en pantalla 2

      Operador opcional (?:).

Este operador permite controlar el flujo de ejecución del programa. Se ampliarán detalles en el apartado de las bifurcaciones.

EXPRESIONES

      Aritméticas

Están formadas por variables y/o constantes, y distintos operadores aritméticos e incrementales (+,-, *, /, %, ++, --). Como se ha dicho, también se pueden emplear paréntesis de tantos niveles como se desee, y su interpretación sigue las normas aritméticas convencionales. Por ejemplo, la solución de la ecuación de segundo grado:

se escribe, en C++ en la forma:

x= (-b+sqrt((b*b)-(4*a*c)))/(2*a);

donde, estrictamente hablando, sólo lo que está a la derecha del operador de asignación (=) es una expresión aritmética. El conjunto de la variable que está a la izquierda del signo (=), el operador de asignación, la expresión aritmética y el carácter (;) constituyen una sentencia. En la expresión anterior aparece la llamada a la función de librería sqrt(), que tiene como valor de retorno la raíz cuadrada de su único argumento. En las expresiones se pueden introducir espacios en blanco entre operandos y operadores; por ejemplo, la expresión anterior se puede escribir también de la forma:

x = (-b + sqrt((b * b) - (4 * a * c)))/(2 * a);

      Lógicas

Los elementos con los que se forman estas expresiones son valores lógicos; verdaderos

(true, o distintos de 0) y falsos (false, o iguales a 0), y los operadores lógicos||, && y!. También se pueden emplear los operadores relacionales (<, >, <=, >=, ==,!=) para producir estos valores lógicos a partir de valores numéricos. Estas expresiones equivalen siempre a un valor 1 (true) o a un valor 0 (false). Por ejemplo:

a = ((b>c)&&(c>d))||((c==e)||(e==b));

donde de nuevo la expresión lógica es lo que está entre el operador de asignación (=) y el (;). La variable a valdrá 1 si b es mayor que c y c mayor que d, ó si c es igual a e ó e es igual a b.

      Generales

Una de las características más importantes (y en ocasiones más difíciles de manejar) del C++ es su flexibilidad para combinar expresiones y operadores de distintos tipos en una expresión que se podría llamar general, aunque es una expresión absolutamente ordinaria de C++.

Recuérdese que el resultado de una expresión lógica es siempre un valor numérico (un 1 ó un0); esto permite que cualquier expresión lógica pueda aparecer como sub-expresión en una expresión aritmética. Recíprocamente, cualquier valor numérico puede ser considerado como un valor lógico: true si es distinto de 0 y false si es igual a 0. Esto permite introducir cualquier expresión aritmética como sub-expresión de una expresión lógica. Por ejemplo:             (a - b*2.0) && (c != d)

SENTENCIAS

Las expresiones de C++ son unidades o componentes elementales de unas entidades de rango superior que son las sentencias. Las sentencias son unidades completas, ejecutables en sí mismas. Ya se verá que muchos tipos de sentencias incorporan expresiones aritméticas, lógicas o general es como componentes de dichas sentencias.

      Sentencias Simples

Una sentencia simple es una expresión de algún tipo terminada con un carácter (;). Un caso típico son las declaraciones o las sentencias aritméticas. Por ejemplo:

float real;espacio = espacio_inicial + velocidad * tiempo;

      Sentencia Vacía o Nula

En algunas ocasiones es necesario introducir en el programa una sentencia que ocupe un lugar, pero que no realice ninguna tarea. A esta sentencia se le denomina sentencia vacía y consta de un simple carácter (;).

      Sentencias Compuestas o Bloques

Muchas veces es necesario poner varias sentencias en un lugar del programa donde debería haber una sola. Esto se realiza por medio de sentencias compuestas. Una sentencia compuesta es un conjunto de declaraciones y de sentencias agrupadas dentro de llaves {...}. También se conocen con el nombre de bloques. Una sentencia compuesta puede incluir otras sentencias, simples y compuestas. Un ejemplo de sentencia compuesta es el siguiente:

{

int i = 1, j = 3, k;

double masa;

masa = 3.0;

k = y + j;

}

ESTRUCTURA DE DATOS EXTRACLASE # 2

ESTRUCTURA DE DATOS EXTRACLASE # 3