Unidad III Elementos del lenguaje C++ Computación II Unidad III Elementos del lenguaje C++

Presentación de la unidad: Objetivos Ser capaces de utilizar distintos operadores. Tener la capacidad de utilizar las estructuras de selección if/if-else. Ser capaces de utilizar las estructuras de repeticion for/do/while Comprensión de la selección múltiple switch

Presentación de la unidad: Contenidos Operadores y Expresiones Operadores de asignación Operadores aritméticos Operadores incrementales y decrementales Operadores relacionales Operadores lógicos Operadores de manipulación de bits Operador condicional Operadores de dirección Operador de resolución y alcance Operador sizeof() Estructuras de selección (if/if-else) Estructuras de repetición (for/do/while) Estructura de selección múltiple

Operadores y Expresiones Expresión: sucesión de operadores y operandos debidamente relacionados que especifican un cálculo. expresión = variable operador expresión Operador es uno de los siguientes operadores binarios: +, -, *, /, %

Operadores y Expresiones Operador de Asignación: C++ dispone de varios operadores de asignación para la abreviatura de las expresiones de asignación. Sintaxis: variable = expresión Enunciados de asignación: sum = integer1 + integer2; total += integer1; // total = total + integer Una expresión con un operador de asignación c +=3 se compila mas rápido que la versión expandida c = c+3.

Operadores y Expresiones Operadores Aritméticos: Son todos operadores binarios. Las expresiones aritméticas en C++ deben ser escritas en forma continua. C++ calcula las expresiones en una secuencia determinada por reglas de precedencia de operadores: Los paréntesis se calculan primero. Nivel de precedencia mas alto. La división, multiplicación y modulo se evalúan en segundo lugar. Ultimo: suma y resta.

Operadores y Expresiones Operadores Incrementales y Decrementales Operador incremental unitario ++ Operador decremental unitario - - Si la variable c es incrementada en 1 entonces: c = c + 1; c += 1; ++c: preincremento. La variable se incrementa antes de su uso en un enunciado. c++: postincremento. La variable se incrementa luego de su uso en un enunciado. El incrementar o decrementar una variable es un enunciado en si mismo; por lo tanto, tienen el mismo efecto. Sólo cuando aparece en una expresión más grande es cuando tiene efectos distintos. ++c ó c++

Operadores y Expresiones Operadores Relacionales: Comprueban una relación entre dos operandos. Tienen un mismo nivel de precedencia y se asocian de izquierda a derecha. C++ utiliza el tipo int para representar los valores verdadero y falso. Falso se representa por el 0.

Operadores y Expresiones Operadores Relacionales: operador significado expresión == Igual a a==b != Distinto a!=b > mayor a>b < Menor a<b >= Mayor o igual a>=b <= Menor o igual a<=b

Operadores y Expresiones Operadores Lógicos: Se utilizan con expresiones para devolver un valor verdadero o falso. Operadores:! (not), &&(and), ||(or) && tiene mayor precedencia que ||; el operador ! tiene mayor precedencia que &&. Aunque C defina como verdadero 1 aceptara como verdadero cualquier valor distinto de 0.

Operadores y Expresiones expr.1&&expr.2 expr.1||expr.2 No 0 1 Operadores Lógicos – tabla de verdad

Operadores y Expresiones Operadores Lógicos: Ejemplo: int n; bool r; r = (n> -100)&&(n<100); n = 100 => r = 0 n = 5 => r = 1

Operadores y Expresiones Operadores de manipulación de bits Los operadores a nivel de bits son: & (AND) | (OR inclusivo) ^ (OR exclusivo) << (Desplazamiento hacia la izquierda) >> (Desplazamiento hacia la derecha) ~ (NOT) &, | y ^ son operadores que comparan sus dos operandos bit por bit. Los operadores se utilizan para manipular los bits de operandos integrales (char, short, int, long)

Operadores y Expresiones Operadores de manipulación de bits Sintaxis: <expresión> & <expresión> <expresión> ^ <expresión> <expresión> | <expresión> ~<expresión> <expresión> << <expresión> <expresión> >> <expresión>

Operadores y Expresiones Operadores de manipulación de bits: bit1 bit2 bit1&bit2 bit1|bit2 bit1^bit2 ~bit1 1

Operadores y Expresiones Operadores de manipulación de bits El operador de desplazamiento hacia la izquierda desplaza los bits de su operando izquierdo hacia la izquierda, el número de bits especificado por su operando derecho. El operando de desplazamiento hacia la derecha desplaza los bits de su operando izquierdo hacia la derecha, el número de bits especificado por su operando derecho.

Operadores y Expresiones Operadores de manipulación de bits Cada operador a nivel de bits (excepto el complemento ~) tiene su operador de asignación correspondiente: Símbolo Uso Descripción <<= a<<=b Desplaza a la izq. b bits y le asigna el resultado a a >>= a>>=b Desplaza a la derecha b bits y le asigna el resultado a a &= a&=b Asigna a a el valor de a&b ^= a^=b Establece a a a^b |= a|=b Establece a a a|b

Operadores y Expresiones Ejemplo: Función de propósito general que imprime un byte en formato binario: void printBinary(const unsigned char val) { for(int i = 7; i >= 0; i--) if(val & (1 << i)) std::cout << "1"; else std::cout << "0"; }

Operadores y Expresiones Ejemplo: La función printBinary() toma un único byte y lo muestra bit a bit. La expresión: (1 << i) produce un uno en cada posición sucesiva de bit; en binario: 00000001, 00000010, etc. Si se hace and a este bit con val y el resultado es diferente de cero, significa que había un uno en esa posición de val.

Operadores y Expresiones int main() { unsigned int getval; unsigned char a, b; cout << "Ingrese un numero (0-255): "; cin >> getval; a = getval; PR("a en binario: ", a); cin >> getval; b = getval; PR("b en binario: ", b); PR("a | b = ", a | b); PR("a & b = ", a & b); PR("a ^ b = ", a ^ b); PR("~a = ", ~a); PR("~b = ", ~b); system("PAUSE"); return 0; }

Operadores y Expresiones #include <iostream> #include <cstdlib> #define PR(STR, EXPR) \ cout << STR; printBinary(EXPR); cout << endl; using namespace std; void printBinary(const unsigned char val) { ……………………… } int main() { …………………….

Operadores y Expresiones Operador condicional: ?:, operador ternario. Sintaxis: <expresión lógica> ? <expresión> : <expresión> E1 ? E2 : E3 primero se evalúa la expresión E1, si el valor es verdadero, se evaluará la expresión E2 y E3 será ignorada, si es falso, se evaluará E3 y E2 será ignorada. Ejemplo: #define max(a,b) (((a) > (b)) ? (a) : (b))

Operadores y Expresiones Operadores de dirección Son operadores que permiten manipular direcciones de objetos. &: operador de dirección; *: operador de indirección; .: permite acceder a un miembro de un objeto agregado. ->: accede a un miembro de un objeto agregado apuntado por el operando de la izquierda.

Operadores y Expresiones Punteros: Variables que contienen direcciones de memoria como sus valores. Los punteros deben ser declarados antes que puedan ser utilizados. <tipo>* <identificador>; Los punteros pueden ser declarados para apuntar a objetos de cualquier tipo de datos.

Operadores y Expresiones Punteros &: operador de dirección; operador unitario que regresa la dirección de su operando. int *yPtr, y=5; yPtr = &y *: operador de indirección; regresa el valor del objeto hacia el cual apunta. cout << “y=”<<*yPtr<<endl; Asigna la dirección de la variable y a la variable puntero yPtr

Operadores y Expresiones Operador de Resolución de alcance :: se utiliza para acceder a un elemento oculto en el ámbito actual. Sintaxis es :: <variable> Ejemplo: #include <iostream> int a; void main() { float a; a=1.5; ::a=2; cout << "a local " << a << "\n"; cout << "a global " << ::a << "\n"; }

Operadores y Expresiones Operador sizeof() Sintaxis: sizeof (<expresión>) sizeof (nombre_de_tipo) Resultado es una constante entera que da el tamaño en bytes del espacio de memoria usada por el operando, que es determinado por su tipo.

Estructuras de selección If (estructura de selección única) Ejecuta una acción, si la condición es verdadera, o pasa por alto la acción, si la condición es falsa. Sintaxis: If (<expresión lógica>) acción; verdadero expresión acción falso

Estructuras de selección If/else (estructura de doble selección) Selecciona entre dos acciones distintas (verdadera o falsa) Las estructuras if/else pueden anidarse; una sentencia if anidada es cuando la sentencia de la rama verdadera o la rama falsa es a su vez un if. Sintaxis: If(<expresión lógica>) acción1; else acción2; verdadero acción2 expresión acción1 falso

Estructuras de selección If/else anidado: if(promedio>=9 && sumParcialitos>=8) cout<<“promocionó”; else if(promedio>=4 && sumParcialitos>=8) cout<<“regularizó”; else cout<<“repite”;

Estructura de selección múltiple switch Se utiliza para hacer selección entre múltiples alternativas. Sintaxis: switch (<selector>){ case <etiqueta1>: <sentencia>; break; case <etiqueta2>: <sentencia>; default: <sentencia>: } <selector>: expresión de control; es comparado con cada una de las etiquetas. <etiqueta>: expresión integral constante. Es cualquier combinación de constantes de carácter y de constantes entera.

Estructura de selección múltiple switch Si no existe coincidencia entre el selector y alguna de las etiquetas, el caso default es ejecutado. El enunciado break causa que el control del programa continua con el primer enunciado después del switch.

Estructuras de repetición while Permite especificar que se repita una acción en tanto esta se mantenga verdadera. El cuerpo de la estructura while puede ser un enunciado sencillo o un enunciado compuesto. sintaxis;: while(<expresión 1>){ expresión 2; }

Estructuras de repetición while Diagrama de flujo verdadera expresión1 falsa expresion2

Estructuras de repetición While Las repeticiones pueden ser controladas por: Contador: repetición definida. Usa variable de control que es incrementada normalmente en 1 cada vez que se repite el ciclo. Centinela: repetición indefinida. Los valores centinela se usan para controlar la repetición cuando: El número preciso de repeticiones no es conocido con anticipación. El ciclo incluye enunciados que deben obtener datos cada vez que se ejecuta. Bandera: condición verdadera o falsa. Similar a centinela.

Estructuras de repetición while Repetición controlada por contador Repetición controlada por centinela int contador = 1; while(contador <=10){ cout<<“contador”<<contador; contador ++; } -------------------------------------------------- int contador=0; while(++contador<=10) cout<<“contador”<<contador; const int centinela=-1; int nota; while(nota!=centinela){ *****************

Estructuras de repetición for Maneja de manera automática todos los detalles de la repetición controlada por contador. Sintaxis: for(expr1; expr2; expr3) Incrementa/decrementa la variable de control Condición de iteración; valor final de la variable de control Inicialización de la variable de control

Estructuras de repetición for Las tres expresiones en la estructura for son opcionales: Si se omite la expr2, se supondrá que la condición es verdadera, por lo tanto un ciclo infinito. Si se omite la expr1; entonces la variable de control se inicializo en otro lado del programa. Si se omite la expr3, es porque no se necesita calcular el incremento o se calcula mediante enunciados en el cuerpo del for. Todas las expresiones dentro del for pueden ser aritméticas: for(j=x; j<=4*x*y; y+=x/y)

Estructuras de repetición for El incremento del contador puede ser negativo. Diagrama de flujo: contador=1 contador<=10 cout<<contador; contador++ for (contador=1; contador<=10; contador++) cout<<contador;

Estructuras de repetición do/while Similar a la estructura del while. La condición de continuación del ciclo se prueba después de ejecutar el cuerpo del ciclo y, por lo tanto, el cuerpo del ciclo se ejecuta una vez más. Sintaxis: do{ <enunciado>; }while (<condición>);

Estructuras de repetición do/while int contador = 1; do{ cout<<contador; }while(++contador<=10); cout<<contador; ++contador; contador<=10

break/continue: Se utilizan para modificar el flujo de control. break: causa una salida inmediata de la estructura donde se encuentra. La ejecución del programa continua con el primer enunciado después de la estructura. continue: salta los enunciados restantes del cuerpo de dicha estructura y ejecuta la siguiente iteración del ciclo.