Post on 22-Mar-2021
Datos de Identificación
Asignatura Programación I
Código 3154
Semestre Tercero
Área Programación
Programa Ingeniería en Informática
Departamento Sistemas
Fecha de Elaboración 08/03/2012
Fecha Última actualización 26/06/2014
Primera Parte (Preliminares del Aprendizaje)
Introducción
Objetivos
Objetivo General
Objetivo Específico
Fuentes de Información
Evaluación de los aprendizajes
Segunda Parte (Desarrollo del Aprendizaje)
Conocimientos Previos
Operadores y expresiones en C++
Operadores aritméticos
Operadores de incremento y decremento
Operadores relacionales
Operadores lógicos
Estructuras de flujo de control
Secuenciales
Condicionales
Repetitivas
Funciones
En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas cosas de C++ y añadiendo otras, que se utiliza para realizar aplicaciones en Internet.
C++ es a la vez un lenguaje procedural (orientado a algoritmos) y orientado a objetos. Como lenguaje orientado a objetos se basa en una filosofía completamente diferente, que exige del programador un completo cambio de mentalidad. Las características propias de la Programación Orientada a Objetos (Object Oriented Programming, u OOP) de C++ son modificaciones mayores que sí cambian radicalmente su naturaleza.
Implementar secuencia de instrucciones en un lenguaje de programación.
1. Identificar los componentes del lenguaje de programación.
2. Utilizar los componentes del lenguaje de programación en la elaboración de instrucciones de programación.
• Joyanes, L. 2006. Programación en C++. Algoritmos, estructuras de datos y objetos. 2a Edición. Mc Graw Hill, Interamericana de España, S.A.U.
En este texto se encuentra de forma detallada casi todo el contenido de la unidad.
• Pereira, M. 2010. Unidad didáctica en línea Elementos Básicos del Lenguaje para la enseñanza de la asignatura programación. Trabajo de ascenso. UCLA.
• Joyanes, L. 1998. Programación Orientada a Objetos. 2a Edición. Mc Graw Hill, Interamericana de España, S.A.U.
• Díaz, R. 2010. Lineamiento para la programación orientada a objetos, utilizando la arquitectura modelo vista controlador y el lenguaje C++
La evaluación de tu aprendizaje en esta unidad será de la siguiente manera:
Tendrás disponible una autoevaluación que podrás tomar en el momento que te sientas preparado mientras está disponible la Unidad.
Estarán disponibles un conjunto de ejercicios propuestos, para profundizar y reforzar el manejo de elementos básicos en C++.
Esta unidad se evaluará en la primera evaluación práctica de 5 pts
Esta unidad se evaluará en el primer parcial escrito de 25 pts.
Para el estudio exitoso de esta unidad requieres tener el dominio de:
Que es un programa y los elementos básicos que contiene un programa.
Como trabaja internamente el computador las operaciones aritméticas y las operaciones lógicas.
Cuales son las estructuras básicas de control que puede contener un programa.
Una expresión es una sucesión de operandos y operadores debidamente relacionados que especifican un cálculo, ejemplo:
Operador Binario
Operandos
5 + 10
Los programas en C++ constan de datos, sentencias de programas (if, while, …) y expresiones.
Otro tipo de operador es el unitario que actúa sobre un único valor. Como por ejemplo el valor de -10 .
Los operadores aritméticos sirven para realizar operaciones aritméticas básicas.
Operador Tipos enteros Tipos reales Ejemplo
+ Suma Suma x + y
- Resta Resta b – c
* Multiplicación Multiplicación y * z
/ División entera:
cociente
División en
coma flotante b / 10
% División entera:
resto No permitida a % 5
Al evaluar una expresión construida en C++, hay que considerar el orden de prioridad de los operadores.
Orden de Prioridad Operadores
1 *, /, %
2 +, -
El orden de prioridad es el orden en que la computadora ejecuta los operadores aritméticos, que se encuentran en una sola línea de instrucción.
El cuadro anterior indica que tiene mayor prioridad los operadores *, / y %, en relación a los operadores + y -.
Los operadores que tienen mayor prioridad son los que se ejecutan primero.
Es importante resaltar que los paréntesis se pueden usar para cambiar el orden usual de evaluación de una expresión.
En ausencia de los paréntesis, los operadores aritméticos contiguos que tienen la misma prioridad, se ejecutan de izquierda a derecha.
¿Cuál es el resultado de la siguiente expresión:
10 + (8 - 4) * (10 * (12 + 6) / 6)
10 + (8 - 4) * (10 * 18 / 6)
10 + 4 * (10 * 18 / 6)
10 + 4 * (180 / 6)
10 + 4 * 30
10 + 120
130
10 + (8 - 4) * (10 * (12 + 6) / 6) ?
Símbolo Uso Descripción Sentencia no
abreviada
= a = b Asigna el valor de b a a a = b
*= a *= b
Multiplica a por b y
asigna el resultado a la
variable a
a = a * b
/= a /= b
Divide a entre b y
asigna el resultado a la
variable a
a = a / b
%= a %= b Fija en a el resto de a/b a = a % b
+= a += b Suma b y a y asigna el
resultado a la variable a a = a + b
-= a -= b Resta b de a y asigna el
resultado a la variable a a = a - b
El lenguaje C++ incorpora los operadores de incremento ++ y decremento --
Estos operadores unitarios suman o restan 1 (uno), respectivamente, al valor de una variable.
Tienen la propiedad de que pueden utilizarse como sufijo o prefijo.
El resultado de la expresión puede ser distinto dependiendo del
contexto que se maneje.
Incremento Decremento
++n --n
n += 1 n -= 1
n = n +1 n = n -1
Si los operadores ++ ó -- están de sufijos, la asignación se efectúa en primer lugar y el incremento o decremento a continuación.
Si los operadores ++ ó -- están de prefijos, la operación de incremento o decremento se efectúa antes de la operación de asignación.
Ejemplo del operador de incremento
int a = 1, b;
b = a++ // b vale 1 y a vale 2
int a = 1, b;
b = ++a; // b vale 2 y a vale 2
¿Cuál es el valor de a y de b?
Son aquellos operadores que comprueban una relación entre dos operandos.
Se usan normalmente en sentencias de selección (if) y de iteración (while, do-while y for), para construir condiciones simples.
Cuando se utilizan los operadores relacionales en una expresión, la evaluación del operador produce un cero (0), o un uno (1).
El cero (0) lo devuelve para una condición falsa y el uno (1) lo devuelve para una condición verdadera.
Ejemplo: a = 7 > 3, la variable a toma el valor de 1.
Operador Significado Uso Ejemplo
== Igual a a == b 'A' == ' C'
falso
!= No igual a a != b 2 != 4
verdadero
> Mayor que a > b 7 > 9 falso
< Menor que a < b 'a' < 'd'
verdadero
>= Mayor o igual que
a >= b 'A' >= 'a'
falso
<= Menor o igual que
a <= b 4 <= 1 falso
Los operadores lógicos relacionan expresiones lógicas ya existentes, obteniéndose a su vez nuevas expresiones lógicas, que al ser evaluadas pueden devolver un valor verdadero (cualquier valor distinto de 0), o (un valor falso (0))
El operador ! tiene prioridad mas alta que &&, que a su vez tiene mayor prioridad que el ||.
El operador ! se evalúa de derecha a izquierda
Al evaluar una expresión que contiene operadores lógicos contiguos de igual prioridad, pero sin paréntesis que permitan cambiar el orden de ejecución, se cumple, que ambos operadores && y || se evalúan de izquierda a derecha
Operador Operación lógica Ejemplo Negación
(!, not) ! operando
not operando ! (x >= y) ó not (x >= y)
Y lógica (&&, and)
operando1 && operando 2 operando1 and operando 2
m < n && i > j
ó m < n and i > j
O lógica (||, or)
operando1 || operando 2 operando1 or operando 2
a = 10 || n != 5
ó a = 10 or n != 5
Los operadores aritméticos tienen prioridad sobre los operadores relacionales, y los operadores relacionales tienen prioridad sobre los operadores lógicos, excepto los operadores ! (negación lógica) y –,+ (menos y mas unitario) que tienen prioridad sobre todos los demás.
+ > &&
Las estructuras básicas son:
Secuenciales
Condicionales
Repetitivas
La ejecución comienza con la primera sentencia y luego se ejecutan las demás, una tras otra, hasta llegar al final del bloque.
El bloque de sentencias se define por el carácter llave de apertura ( { ) para marcar el inicio del mismo, y el carácter llave de cierre ( } ) para marcar el final, como se muestra a continuación:
{ sentencia1; sentencia2; ……… sentencian;
}
La sentencia if permite decidir, a partir del resultado de evaluar una expresión lógica, si se ejecuta o no una sentencia o un bloque de sentencias, según sea el caso.
if (expresión_lógica)
{
sentencia1;
:::
sentencian;
}
if (expresión_lógica)
sentencia;
Ejemplo: if (num1 % num2 == 0) cout << num1 << " es divisible por " << num2;
Formato 1
Formato 2
if expresión_lógica)
{
sentencia1;
:::
sentencian;
}
else
{
sentencia1;
:::
sentencian;
}
if (expresión_lógica)
sentencia1;
else
sentencia2;
Este formato permite ejecutar una sentencia o un bloque de sentencias (según sea el caso) cuando se evalúa una expresión lógica, ya sea que el resultado sea verdadero o falso.
Ejemplo Formato 2
if (annos > 3)
{
aumento = sueldo_base * 0.30;
bono = 3000 * nroh;
}
else
{
aumento = sueldo_base * 0.15;
bono = 1000 * nroh;
}
sueldo_neto = sueldo_base + aumento + bono;
Formato 3
if (expresión_lógica)
sentencia1;
else
if (expresión_lógica)
sentencia2;
else
:::
if (expresión_lógica)
sentencia3;
else
sentencian;
Este formato muestra como se puede utilizar la sentencia if para implementar decisiones que impliquen varias alternativas.
Ejemplo Formato 3
if (numero1 == numero2)
cadena = "Los dos números son iguales";
else
if (numero1 > numero2)
cadena = "El 1er número es mayor que el 2do";
else
cadena = "El 1er número es menor que el 2do";
La sentencia switch es una sentencia de C++ que se utiliza para seleccionar una alternativa entre varias disponibles y tiene el siguiente formato:
switch (expresion)
{
case etiqueta1 : sentencia1;
:::
break;
case etiqueta2 : sentencia2;
:::
break;
:::
case etiquetaN : sentencian;
:::
break;
default : sentenciad; :::
}
En el siguiente ejemplo se evalúa el dato que contiene edo_civil y dependiendo de su valor, se guarda un mensaje como una cadena de caracteres.
string mensaje;
char edo_civil;
:: /* de alguna manera
edo_civil toma un valor */
switch (edo_civil)
{
case 'S': case 's':
mensaje = "SOLTERO";
break;
case 'C': case 'c':
mensaje = "CASADO";
break;
case 'D': case 'd': …
case 'V': case 'v': …
default:
mensaje = "Estado Invalido";
}
La estructura repetitiva permite que una o varias sentencias se ejecuten un número determinado de veces. También conocidas como bucles, ciclos o lazos.
La sentencia o grupo de sentencias que se repiten se llaman cuerpo del bucle.
Cada repetición del cuerpo del bucle se llama iteración del bucle.
En C++ se dispone de las sentencias: while, do .. while y for, para construir los bucles o estructuras repetitivas.
Un bucle while tiene una condición del bucle (expresión lógica) que controla la secuencia de repetición. La ejecución de la(s) sentencia(s) se repite mientras la condición del bucle permanece verdadera y termina cuando es falsa.
Sintaxis:
while (condición)
{ sentencia 1; sentencia 2; ::: sentencia n; }
Primero se
chequea la
condición y luego
se ejecuta
sentencia(s)
Ciclo Pre test (0..n veces)
Es una expresión lógica o booleana
while (condición)
sentencia;
Cuerpo del
Bucle
Bucle controlado con contador
Ejemplo de un bucle o estructura repetitiva, que permite mostrar por pantalla los números enteros del 1 al 100.
int cont = 1; // Inicializa cont
while (cont <= 100) // Control del bucle
{
cout << cont << endl; /* Imprime el contenido
de cont */
++cont; /* Incrementa cont, cuando llegue
a 100 se saldrá del bucle */
}
Bucle controlado con valor centinela
Ejemplo que lee varias notas (no se saben cuentas) las acumula y cuenta dentro del bucle. Usa un valor centinela (-1) como último dato para salirse del ciclo y por último se calcula e imprime el promedio de notas.
float nota, suma = 0,
int cont = 0;
const int CENTINELA = -1;
cout<<"Ingrese la nota (-1) para finalizar : ";
cin>>nota;
while (nota != CENTINELA)
{
suma += nota;
++cont;
cout<<"Ingrese la nota (-1) para finalizar : ";
cin>>nota;
}
if cont != 0
cout << "El promedio de notas es : “ << suma/cont << endl;
else
cout << “No se procesaron datos para obtener el promedio” << endl;
Bucle controlado preguntando al usuario si desea la continuación del ciclo
Es el usuario el que tiene la potestad de continuar o no con el bucle, respondiendo a una pregunta que se le hace, relacionada con el control del mismo. A continuación se ilustra esta técnica con el ejemplo anterior.
float nota, suma = 0;
int resp, cont = 0;
cout<<"Existe alguna nota (1)SI (2)NO : ";
cin>>resp;
while (resp == 1)
{
cout<<"Ingrese la nota : ";
cin>>nota;
suma += nota;
++cont;
cout<<"Existe alguna nota (1)SI (2)NO : ";
cin>>resp;
}
if cont != 0
cout << "El promedio de notas es : “ << suma/cont << endl;
else
cout << “No se procesaron datos para obtener el promedio” << endl;
La sentencia do-while se utiliza para especificar un bucle condicional que se ejecuta al menos una vez. Si la condición es verdadera, entonces se repite la ejecución de la(s) sentencia(s), este proceso continúa hasta que la condición sea falsa.
Sintaxis: do sentencia; while (condición)
Cuerpo
del Bucle
Primero se ejecuta
sentencia(s) y luego
se chequea la
condición
Ciclo Post test
(1..n veces)
do
{ sentencia 1; sentencia 2; ::: sentencia n; } while (condición)
float nota, suma = 0;
int resp, cont = 0;
do
{
cout<<"Ingrese la nota : ";
cin>>nota;
suma += nota;
++cont;
cout<<"Existe alguna nota (1)SI (2)NO : ";
cin>>resp;
}
while (resp == 1);
cout << "El promedio de notas es : "
<< suma/cont << endl;
Si conocemos exactamente la cantidad de veces que necesitamos repetir un conjunto de sentencias, entonces podemos usar un bucle for. La sentencia for es un método para ejecutar un bloque de sentencias un número fijo de veces.
Sintaxis:
for (inicializacion; condicion iteración; incremento) { conjunto de sentencias }
Inicializa la variable de
control del bucle
Incrementa o Decrementa la
variable de control del bucle
Expresión lógica que
determina si las sentencias
se han de ejecutar, solo
ocurre si el resultado de
evaluar la condición es
verdadera
Ejemplo, donde se suman los 10 primeros números enteros y se imprime el resultado obtenido.
int suma = 0;
for (int n = 1; n <=10; n++)
suma += n;
cout << "La suma de los primeros 10 numeros es:”
<< suma << endl;
Una función contiene una o más sentencias que realizan una tarea específica.
Pueden retornar o no un valor y ser llamadas desde cualquier parte de un programa.
La función tiene un nombre, y cuando el control de la ejecución del programa consigue este nombre, inmediatamente es ejecutada, y se dice que la función fue invocada o llamada. Una vez que termina la ejecución de la función (finalizó con su tarea), el control de ejecución es devuelto al punto desde el cual la función fue llamada.
Las funciones pueden tener parámetros (son datos del exterior que la función necesita para poder realizar su tarea). Estos parámetros se suministran a la función cuando esta es invocada.
En la programación orientada a objetos, las funciones se utilizan para definir los métodos de las clases.
tipo_de_retorno: tipo del valor devuelto por la función, puede
ser de un tipo predefinido del C++, de un tipo definido por el
usuario, o de tipo void que indica que no retorna ningún valor.
nombre_función: cualquier identificador válido.
tipo param1, tipo param2 ... tipo paramn: tipos de valores que
se le deben suministrar a la función para que haga su trabajo;
estos valores se conocen como parámetros. Algunas funciones no
los requieren.
Parámetros
formales o
ficticios
(opcionales)
tipo_de_retorno nombre_función (tipo param1, tipo param2,
… , tipo paramn);
Una función no puede ser invocada (llamada) si no ha sido declarada previamente. La declaración de una función, llamada también prototipo de la función tiene el siguiente formato:
Los parámetros de una función pueden ser por valor y por referencia, o puede no tener parámetros.
Parámetros por valor (copia del dato): En C++ el paso por valor significa, que cuando el control pasa a la función, los valores de los parámetros en la llamada, se copian en los parámetros formales o ficticios de la función. Si en las instrucciones que contiene la función, se cambia el valor de un parámetro que fue pasado por valor, el cambio solo se refleja en la función y no tiene efecto fuera de esta.
Parámetros por referencia (dato original): Cuando se necesita que un parámetro pasado a la función, sea modificado por alguna de las instrucciones que esta contiene y su valor sea devuelto al punto donde fue invocada la función, se debe pasar el parámetro por referencia.
Para declarar un parámetro como paso por referencia, el símbolo & debe preceder al nombre del parámetro.
La definición de una función le indica al compilador como ésta trabaja. Incluye el encabezado y el cuerpo de la función.
El encabezado es igual al prototipo de la función, pero sin el punto y coma.
El cuerpo describe lo que hace la función y va encerrado entre llaves. La definición de una función tiene el siguiente formato:
tipo_de_retorno nombre_función (tipo param1,
tipo param2,
…
tipo paramn)
{
acciones //cuerpo de la función
}
Si una función tiene un tipo de retorno, ésta lo devuelve utilizando la sentencia return que normalmente aparece al final.
Una función puede tener más de una sentencia return.
A continuación se muestra la definición de la función LeerNombrePersona()
string LeerNombrePersona()
{
string nom; // variable local de la función
cout << "Ingrese nombre de la persona";
cin.sync(); /* limpia el Buffer antes de leer
el string nom*/
getline(cin,nom); // lee nom de tipo string
return nom; // retorna la variable nom
}
Las funciones para poder ser ejecutadas han de
ser llamadas o invocadas. Una función se invoca
por su nombre, y se le debe suministrar valores a
cada uno de los parámetros incluidos en su
definición (si los tiene).
Una función que es llamada, recibe el control del
programa, y comienza a ejecutarse desde el
principio (primera instrucción) y cuando termina
(se alcanza una sentencia return o la llave de
cierre ( } )) el control del programa vuelve y
retorna al punto desde el cual la función fue
llamada.
A continuación se muestra como invocar la función LeerNombrePersona definida anteriormente.
string nombre; /*declaración de la variable
que recibirá lo que retorna
la función*/
nombre = LeerNombrePersona(); /*llamada
de la
función*/