computación ii 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

• 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


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 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 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 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 &&.


Aunque C defina como verdadero 1 aceptara como verdadero cualquier valor distinto de 0.


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);


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 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 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 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";

}


• 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.


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;}


#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() {…………………….}


• 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 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.


• 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.


• 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


• 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";

}


• 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; 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;


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”;


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


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.



• 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)


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)


• 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;

• 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>);


• do/while


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.

computación ii unidad iii elementos del lenguaje c++

Documents