Upload
oscar-monzon
View
229
Download
0
Embed Size (px)
Citation preview
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
• 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
Presentación de la unidad:
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: +, -, *, /, %
• 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
Operadores y Expresiones
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 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.
Operadores y Expresiones
++c ó c++
• 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 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 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 &&.
Operadores y Expresiones
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 expr.1||expr.2
0 0 0 0
0 No 0 0 1
No 0 0 0 1
No 0 No 0 1 1
Operadores Lógicos – tabla de verdad
• Operadores Lógicos:– Ejemplo:
int n;
bool r;
r = (n> -100)&&(n<100);
Operadores y Expresiones
n = 100 => r = 0
n = 5 => r = 1
• 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:
Operadores y Expresiones
<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
0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0
• 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 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
• 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); cout << "Ingrese un numero (0-255): "; 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.
Operadores y Expresiones
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; expresión acciónverdadero
falso
• 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;
Estructuras de selección
expresión acción1
verd
ade
ro
falso
acción2
• If/else anidado:
if(promedio>=9 && sumParcialitos>=8)
cout<<“promocionó”;
else if(promedio>=4 && sumParcialitos>=8)
cout<<“regularizó”;
else
cout<<“repite”;
Estructuras de selección
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>;
break;default: <sentencia>:
break;}
– <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.
• 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.
Estructura de selección múltiple
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;}
• while– Diagrama de flujo
Estructuras de repetición
expresión1
expresion2
verdadera
falsa
• 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
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){
*****************
}
• for– Maneja de manera automática todos los
detalles de la repetición controlada por contador.
– Sintaxis:for(expr1; expr2; expr3)
Estructuras de repetición
Inicialización de la variable de control
Condición de iteración; valor final de la variable de control
Incrementa/decrementa la variable de control
• 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:
Estructuras de repetición
contador=1
contador<=10 cout<<contador; contador++
for (contador=1; contador<=10; contador++)
cout<<contador;
• 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
Estructuras de repetición
cout<<contador;
++contador;
contador<=10
int contador = 1;
do{
cout<<contador;
}while(++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.