1.

- El Proceso de Programacin:
-Comenzamos el estudio de la asignatura de Fundamentos de Programacin, en la
que utilizaremos el lenguaje de programacin C+ +, dando paso a este tema donde,
dejando a un lado la introduccin de conceptos bsicos como los de software, hardware,
compilador, etc. (que veremos en asignaturas pertenecientes a este grado), aprenderemos
los tipos de datos y sintaxis que sigue este lenguaje empezando por definir y explicar el
proceso a seguir para la correcta programacin de un programa. As, dicho proceso
consta de las siguientes partes:

Definicin: el 1er paso es analizar el problema que se nos presenta definiendo

adecuadamente su nombre y sus entradas y salidas, y estableciendo una relacin entre
ambas. Por ejemplo: Disear un programa que calcule el rea de un rectngulo:

// Programa Arearectangulo La relacin entre las entradas y las

// Entradas la base y la altura del rectngulo salidas sera la frmula del rea
// Salidas el rea del rectngulo del rectngulo: rea = base altura

Desarrollo: el siguiente paso es disear un algoritmo con las acciones necesarias

(comandos) para resolver dicho problema, las cuales, como sabemos, codificadas
(expresadas) en el lenguaje de programacin pertinente (en este caso C++).
Esta parte ser en la que nos centraremos en la asignatura.
Prueba: finalmente tan solo queda ejecutar el programa construido dndole valores
a los datos de entrada para ver si los valores de salida se devuelven correctamente,
comprobando as si se resuelve o no el problema. Aprenderemos + adelante
como se lleva a cabo esta parte.
-Bien, pues aclaradas las partes de la que consta nuestra construccin de un programa
para resolver el problema que nos plantean, a continuacin, pasaremos ya a estudiar y
analizar todo sobre el lenguaje que utilizaremos (C++), comenzando por conocer su
sintaxis, es decir, los tipos de datos, elementos, operadores y expresiones que usaremos
en este. De este modo, podemos recoger toda esta sintaxis en la siguiente tabla:
 Tipo Representacin Descripcin
se usa para variables cuyo
int [variable]=[valor]
valor es un n entero (1,2)
se usan para variables cuyo
valor es un n real (24, -12).
La diferencia entre ambos es
float, double [variable]= [valor] que con float trabajamos con
Datos una precisin simple (32 bits) y
con double con precisin
doble (64bits)
se usa para variables de tipo
char [variable] = [valor]
carcter (Ej: sexo (M o F))
se usa para variables de tipo
bool [variable] = [valor]
lgico (Ej: respuesta (V o F))
son los objetos (nombres) a los
cuales les asignamos un valor
[variables]
que podemos cambiar
(Ej: area = 8, )
Las constantes son y dan un valor
Elementos
const [dato] [identificador] = [valor] invariable (Ej: const int area = 8:
area se toma como una constante
son combinaciones de variables,
[expresiones] constantes, operadores, etc.
(Ej: 145*2, area/2, )
+ (suma de n), (resta de n),
* (producto de n), div (divisin
+, , *, div, /,% de 2 n enteros), / (divisin de 2
n reales) y % (da el resto de la
divisin de 2 n enteros)
Operadores < (menor que), > (mayor que),
<= (menor igual que), >=
<, >, <=, >=, ==, !=
(mayor igual que), == (igual que)
!= (distinto que)
!, &&, || ! (no), && (y), || (o)
Son datos punteros (la variable
asociada contiene la direccin
int*, float*, double*, char* de otra). Ej: int*suma = &area
(creamos la variable suma en la
posicin de memoria de area)
Variaciones Son datos arrays (vectores o
de Datos int[], float[], double[], char[] matrices). Ej: suponiendo que
area es un vector: int [area].
Son datos referencia (la variable
asociada es una etiqueta de otra).
int&, float&, double&, char&
Ej: int& n = m (n y m se refieren
a la misma variable)
 Se usa si la funcin no devuelve
Void [funcin] ningn valor (es decir, cuando las
salidas no tienen ningn valor)
Otros Son datos enumerados (asocia al
valor de las variables nombres).
enum {lista}
Ej: enum (a, b, c = 0, d = a+2): en
este caso a = 0, b=1, c = 0 y d = 2

-Bueno, pues citados y definidos los principales elementos de la sintaxis de C++,

pasaremos ahora a describir parte por parte el contenido (expresiones) que debe
presentar todo programa en C++:

1 lnea: esta contiene siempre la directiva include, que indica que se va a utiliza
una funcin o cdigo implementado (normalmente main) en una biblioteca
(fichero o conjunto de estos (mdulo)), la cual la utilizada por nuestro
programa (Codeblocks) es iostream. De este modo, la 1 lnea de nuestro
programa debe quedar del siguiente modo:
#include <iostream>
2 lnea: esta contiene siempre la expresin: using namespace std; con la cual
permitimos escribir de forma abreviada algunos nombres de la biblioteca iostream.
En caso contrario, instrucciones como cout (muestra un texto o valor de una variable
en pantalla) o endl (indica el final de la instruccin cout) tendran que escribirse
como std::cout y std::endl.
3 lnea: esta contiene el nombre del programa principal, que es la funcin main,
la cual introducida por el cdigo int: int main ( ).
Cuerpo del programa: a continuacin, se escriben las instrucciones que conformarn
nuestro programa (todas siempre entre {} para indicar que pertenecen al mismo
programa: main) cada una acabada en ; (para sealar que dicha instruccin ha acabado).
ltima lnea: en la ltima lnea del cuerpo del programa (antes de cerrarlo con }),
se escribe la instruccin: return 0; la cual indica que se termina la ejecucin del
programa maindevolviendo el valor 0. Cuando el programa no devuelve ningn
valor (caso en el que utilizamos la instruccin void) no se pone el 0: return;
-Dicho esto, estudiaremos finalmente varios ejemplos donde progresivamente iremos
comprendiendo y aprendiendo mejor la estructura y programacin en C++. Vemoslos:
(*) Disea un programa que muestre en pantalla Hola a todos:
// Programa: Saludo
// Entradas: --
*Como vemos, el programa tan solo nos
// Salidas: texto Hola a todos muestra en pantalla tras ejecutarlo el texto
Hola a todos sin requerir ninguna entrada
#include <iostream> (es por ello que no hay entradas (--)). De igual
using namespace std; forma, vemos como para mostrar un texto en
pantalla en C++ utilizamos la instruccin
int main ( ) cout << texto << endl; la cual mantiene
{ siempre dicha estructura (si queremos mostrar
cout <<Hola a todos<< endl; el valor de una variable o una operacin y no
return 0; un texto, omitimos las comillas ()).
}

(*) Disea un programa que lea datos tipo carcter y real y que los muestre clasificados:
// Programa: LeeDatos
// Entradas: datos de tipo carcter y real
// Salidas: clasificacin de los datos de entrada

#include <iostream>
using namespace std;

int main ( )
{
char c;
float f;
cout <<Introduzca un carcter: << endl;
cin >> c;
cout <<Introduzca un numero real: << endl;
cin >> f;
cout <<Carcter: << c << Numero real: << f << endl;
return 0;
}

*Como vemos, en este caso como el programa si tiene valores de entrada, la 1

instruccin que debemos hacer es definir los tipos de datos que vamos a introducir
(en este caso char (carcter) y float o double (real)). Despus pedimos que se
introduzca cada tipo de dato (mostrndolo en pantalla con cout (como sabemos))
para posteriormente leerlo con la instruccin cin >> variable; para que as se
guarde el valor de entrada introducido en dicha variable. Finalmente, mostramos
la clasificacin de dichos datos mediante la escritura de su nombre y seguidamente
su valor (variable sin ).
(*) Disea un programa que calcule el cuadrado de un nmero dado previamente:
// Programa: CalculaCuadrados
// Entradas: un nmero real
// Salidas: cuadrado del nmero dado

#include <iostream>
using namespace std;

int main ( )
{
float f;
cout <<Introduzca un nmero: << endl;
cin >> f;
cout <<Su cuadrado es: << f*f << endl;
return 0;
}

*El uso de float o double para el trabajo con nmeros reales es indiferente,
a no ser que nos pidan simple precisin (float) o doble precisin (double).
Por otra parte, vemos como la operacin para obtener el cuadrado del
nmero introducido y guardado en la variable f (podra haber sido cualquier
letra o palabra), se realiza en la misma instruccin cout, aunque se podra
realizar y guardar previamente en otra variable para despus mostrar dicha
variable (n = f*f cout<< n <<).
(*) Disea un programa que lea de la entrada estndar dos nmeros y muestre
en la salida estndar su suma, resta multiplicacin y divisin:
// Programa: OperaNumeros
// Entradas: dos nmeros reales
// Salidas: la suma, resta, producto y divisin de los nmeros introducidos

#include <iostream>
using namespace std;

int main ( )
{
float x, y;
cout <<Introduzca el primer nmero: << endl;
cin >> x;
cout <<Introduzca el segundo nmero: << endl;
cin >> y;
cout <<Su suma es: << x+y << Su resta es: << x-y<< Su producto es: << x*y
<< Su divisin es: << x/y << endl;
return 0;
}

*Como vemos, en este caso como las dos entradas son nmeros reales, las
introducimos separadas con coma con la instruccin float. Seguidamente tan
solo solicitamos el valor de cada nmero y lo leemos con cin para as
guardarlo y poder ms adelante operar con ellos. Finalmente mostramos
en pantalla con cout las operaciones que nos piden.

(*) Disea un programa que lea de la entrada estndar el precio de un producto y

muestre en la salida estndar el precio del producto al aplicarle el IVA (suponga el 21%):
// Programa: PrecioIVA
// Entradas: el precio de un producto
*En este caso, lo tenemos ms
// Salidas: el precio con IVA fcil que el ejercicio anterior,
ya que solo hay una entrada.
#include <iostream> As, en el clculo del IVA, 1.21
using namespace std; se obtiene de sumar al100% del
valor del precio el 21%: 100 +
int main ( ) 21 = 121% = 1.21.
{
float x;
cout <<Introduzca el precio del producto: << endl;
cin >> x;
cout <<Su precio con IVA es: << x*1.21 << endl;
return 0;
}
(*) Disea un programa que lea de la entrada estndar los siguientes datos de una
persona y los muestre en la salida estndar:
Edad (tipo de dato entero)
Sexo (tipo de dato carcter)
Altura en metros (tipo de dato real)
// Programa: DatosPersona
// Entradas: sexo, edad y altura (en m) de una persona
// Salidas: ()

#include <iostream>
using namespace std;

int main ( )
{
int e;
char s;
float h;
cout <<Introduzca su edad: << endl;
cin >> e;
cout <<Introduzca su sexo (M si es hombre o F si es mujer): << endl;
cin >> s;
cout <<Introduzca su altura (en metros): << endl;
cin >> h;
cout <<Edad: << e << Sexo: << s << Altura (en m): << h << endl;
return 0;
}

*En este caso a diferencia de los ejercicios anteriores trabajamos con ms

tipos de datos, aunque como vemos, la programacin sigue siendo la misma.
(*) Disea un programa que lea de la entrada dos nmeros y en la salida muestre
del 1 el incremento en su valor y del 2 el incremento de su valor en 1 unidad:
// Programa: Incrementos
// Entradas: dos nmeros reales
// Salidas: el incremento de un nmero en su valor y de un nmero en una unidad

#include <iostream>
using namespace std;

int main ( )
{
float x, y;
cout <<Introduzca el primer nmero: << endl;
cin >> x;
x += x;
cout <<Introduzca el segundo nmero: << endl;
cin >> y;
++y;
cout <<El incremento del primer nmero es: << x << El incremento
del segundo nmero es: << y << endl;
return 0;
}

*En este caso debemos explicar algunos nuevos conceptos. Cuando queremos
incrementar el valor de una variable debemos tener clara la siguiente tabla:

Expresin
[variable]++;
++[variable];
[variable]+=[n o variable];
[variable] =[n o variable];
[variable]*=[n o variable];
[variable]/ =[n o variable];
[variable]% =[n o variable];
Descripcin
Incremento posfijo: da el valor de la
variable antes del incremento en 1
unidad (Ej: si x = 8 x++ nos dar
como resultado 8).
Incremento prefijo: da el valor de la
variable despus del incremento en 1
unidad (Ej: si x = 8 ++x nos dar
como resultado 9 (8+1)).
Incrementa el valor de la variable en
el nmero tras el += o si es una
variable su valor (Ej: si x = 8
x += 5 dar a x el valor 13 (8+5) y
x += x dar a x el valor 16 (8 + 8(x))
Disminuye ()
Multiplica ()
Divide ()
Halla el resto de la divisin ()

Asimismo, para que el programa nos compile sin errores dichos incrementos,
debemos escribirlos preferiblemente en la posicin dada en el ejercicio u otra pero no
dentro del cout. En este solo escribimos las variables con su valor ya incrementado.
(*) Disea un programa que lea de la entrada dos nmeros y en la salida muestre
el resultado de las siguientes operaciones matemticas:
a) (x/x+1) +x2
b) 3
c) (x+1)/x2
// Programa: CalculaOperaciones
// Entradas: dos nmeros reales
// Salidas: el resultado matemtico de las expresiones matemticas dadas

#include <iostream>
#include <cmath>
using namespace std;

int main ( )
{
double x, a, b, c;
cout <<Introduzca el valor de x: << endl;
cin >> x;
a = x/(x+1) + pow(x,2);
b = sqrt (pow (x,3));
c = (x+1)/pow (x,2);
cout << El resultado de a) es: << a << endl;
cout << El resultado de a) es: << b << endl;
cout << El resultado de a) es: << c << endl;
return 0;
}

*En este caso cuando nuestro programa utiliza operaciones matemticas

avanzadas (races, potencias), debemos incluir al principio la instruccin
#include <cmath>, ya que incluye comandos para estas operaciones, entre los cuales,
como hemos visto, se suelen utilizar:

Expresiones Descripcin
halla la raz cuadrada de una
sqrt (expresin);
variable o expresin matemticas
calcula potencias a partir de su
pow (base, exponente);
base y exponente

De igual forma, debemos incluir dentro de la funcin double las variables

donde recogeremos los resultados de cada apartado (a, b y c).
(*) La calificacin de un estudiante es la media ponderada de 3 notas: la nota de
prcticas que cuenta un 30% del total, la nota terica que cuenta un 60% del total y
la nota de participacin que cuenta el 10% restante. Disea un programa que lea de la
entrada estndar las 3 notas de un alumno y escriba en la salida estndar su nota final:
// Programa: CalculaNota
// Entradas: nota de prcticas, teora y participacin
// Salidas: nota final

#include <iostream>
using namespace std;

int main ( )
{
double prac, teor, part, nota;
cout <<Introduzca su nota de prcticas: << endl;
cin >> prac;
cout <<Introduzca su nota de teora: << endl;
cin >> teor;
cout <<Introduzca su nota de participacin: << endl;
cin >> part;
nota = (prac*0.3)+(teor*0.6)+(part*0.1)
cout << Su nota final es: << nota << endl;
return 0;
}

*Al igual que en el ejercicio anterior, incluimos dentro del double todas las
variables de tipo real que vamos a utilizar y finalmente, tras calcular el valor
de la variable pedida (nota) la incluimos en el cout.

(*) Cuando se compra una cajetilla de tabaco en una mquina y no se introduce el importe
exacto, la mquina utiliza un programa para devolver el mnimo nmero de monedas.
Disea un programa (considerando solo monedas de 5, 10, 20, 50 cent) que lea de la
entrada estndar el importe de una cajetilla de tabaco y la cantidad de dinero
introducida por el comprador en la mquina y escriba en la salida estndar las
monedas devueltas por la mquina:
// Programa: DevuelveMonedas
// Entradas: precio de la cajetilla de tabaco y cantidad introducida por el comprador
// Salidas: monedas devueltas por la mquina
#include <iostream>
using namespace std;

int main ( )
{
int precio, pago, cant_devol, resto, mon_50, mon_20, mon_10, mon_5;
cout << Introduzca el precio de la cajetilla de tabaco (en cent): << endl;
cin >> precio;
cout << Introduzca la cantidad del pago (en cent): << endl;
cin >> pago;
cant_devol = pago precio;
mon_50 = cant_devol/50;
resto = cant_devol (50*mon_50);
mon_20 = resto/20;
resto = resto (20*mon_20);
mon_10 = resto/10;
resto = resto (10*mon_10);
mon_5 = resto/5;
cout << Monedas de 50 cent: << mon_50 << endl;
cout << Monedas de 20 cent: << mon_20 << endl;
cout << Monedas de 10 cent: << mon_10 << endl;
cout << Monedas de 5 cent: << mon_5 << endl;
return 0;
}

*Explicaremos a continuacin los pasos seguidos para el diseo de este programa:

1) Como trabajamos en cent, todas las variables sern de tipo entero, por lo que
las definimos con la funcin int.
2) Solicitamos (con cout) y leemos (con cin) como siempre el valor de las
entradas (en este caso precio y pago).
3) Para saber las monedas a devolver, recogemos la diferencia entre el pago y el
precio de la cajetilla en una variable (cant_devol) y a continuacin vamos
dividiendo esa cantidad entre el valor de cada moneda (en orden siempre de
> a <, en este caso: 50, 20, 10 y 5 cent) para obtener el n de unidades de esa
moneda a devolver; es decir, 1 dividimos la diferencia inicial (cant_devol)
entre la 1 moneda (50) para obtener el n de unidades de esa moneda a devolver
que recogeremos en otra variable (mon_50) y seguido recogemos el resto por
determinar en una variable (resto) y as hasta llegar a la ltima moneda (5 cent).
4) Finalmente, mostramos en pantalla con la funcin cout el n de unidades
de cada moneda a devolver como nos piden.
Asimismo, cabe mencionar el definir las variables con la funcin int nos ha
permitido obtener como resultado de las divisiones el cociente de estas
(ya que al definir las variables como n enteros, muestra solo la parte entera
de las operaciones realizadas), que es lo que nos interesaba para poder
determinar el n de unidades de las siguientes monedas.