Lenguaje C

Fundamentos de la programación
2
Grado en Ingeniería Informática
Grado en Ingeniería del Software
Grado en Ingeniería de Computadores
Luis Hernández Yáñez
Facultad de Informática
Universidad Complutense

Un ejemplo de programación 3
El primer programa en C++ 18
Las líneas de código del programa 35
Cálculos en los programas 42
Variables 48
Expresiones 54
Lectura de datos desde el teclado 64
Resolución de problemas 79
Algoritmo 84
Programación 87
Los datos de los programas 91
Identificadores 93
Tipos de datos 97
Declaración de variables 106
Constantes 111
Operadores 115
Más sobre expresiones 124
Fundamentos de la programación: Primeros pasos
Instrucciones de asignación 132
La biblioteca cmath 137
Operaciones con caracteres 141
Operadores relacionales 145
Toma de decisiones (if) 148
Bloques de código 151
Bucles (while) 155
Entrada/salida por consola 159

Programar
Actividad de escribir y probar programas.
Programa
Código que indica a la computadora exactamente lo que tiene
que hacer: secuencia de instrucciones.
La computadora sólo entiende un conjunto de instrucciones.
Lenguaje de programación
Describe cómo es el conjunto de instrucciones que se pueden
usar en los programas.
Reglas sintácticas que el código debe respetar.
Fundamentos de la programación: Primeros pasos Página 2

Sintaxis del lenguaje de programación
instrucción
Start
Stop ;
avanzar
avanzar Go dirección num Blocks
dirección
North
num
= Literales
East
South
West
1
2
3
4
5

El problema a resolver
Estando el coche en la posición A,
conseguir llegar al Cine Tívoli (B).
¿Cuáles son los pasos que hay
que seguir para llegar al destino?
Arrancar
Ir un bloque al Norte
Ir dos bloques al Este
Ir cinco bloques al Norte
Ir dos bloques al Este
Parar
B
A
N
Bloque:

El algoritmo
Secuencia de pasos que hay que
seguir para resolver el problema.
1.- Arrancar
N
2.- Ir un bloque al Norte
3.- Ir dos bloques al Este
4.- Ir cinco bloques al Norte
5.- Ir dos bloques al Este
6.- Parar
Esos pasos sirven tanto para
una persona como para una computadora.


El programa
Para cada paso, una instrucción.
Escrita en el lenguaje
de programación.
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Go North 5 Blocks;
Go East 2 Blocks;
Stop;
B
A
N

El programa
Escribimos el código del programa
en un editor y lo guardamos
en un documento programa.prg.
Stat;
Go North 1 Blocks
Go East Blocks;
Go Noth 5 Blocks;
Go West 2 Blocks;
Stop;
Copiamos el archivo
en una llave USB
y lo llevamos al coche.

La compilación
Introducimos la llave USB en el coche y pulsamos el botón
de ejecutar el programa en programa.prg.
Se compila el programa (comprobación sintáctica):
Stat;
----^ Unknown word.
Go North 1 Blocks
-----------------^ ; missing.
Go East Blocks;
--------^ Number missing.
Go Noth 5 Blocks;
-------^ Unknown word.
Go West 2 Blocks;
Stop;
There are errors. Impossible to run the program.
Errores
de sintaxis

Depuración
Editamos el código para arreglar los errores de sintaxis.
Stat;
Go North 1 Blocks
Go East Blocks;
Go Noth 5 Blocks;
Go West 2 Blocks;
Stop;
Start;
Go North 1 Blocks;
Go East 3 Blocks;
Go North 5 Blocks;
Go West 2 Blocks;
Stop;

La ejecución
Se realiza lo que pide
cada instrucción.
B
¡No se puede seguir
ejecutando el programa!
N
Start;
Go North 1 Blocks;
Go East 3 Blocks;
!
Error de ejecución:
¡Una instrucción no se puede ejecutar!

Depuración
Editamos el código para arreglar el error de ejecución.
Start;
Go North 1 Blocks;
Go East 3 Blocks;
Go North 5 Blocks;
Go West 2 Blocks;
Stop;
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Go North 5 Blocks;
Go West 2 Blocks;
Stop;

La ejecución
cada instrucción.
B
Go North 5 Blocks;
Go West 2 Blocks;
Stop;
?
N
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Errores lógicos:
El programa se ejecuta, pero no obtiene el resultado deseado.

Depuración
Editamos el código para arreglar el error lógico.
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Go North 5 Blocks;
Go West 2 Blocks;
Stop;
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Go North 5 Blocks;
Go East 2 Blocks;
Stop;

La ejecución
cada instrucción.
N
Start;
Go North 1 Blocks;
Go East 2 Blocks;
Go North 5 Blocks;
Go East 2 Blocks;
Stop;

¡Conseguido!

Muchas instrucciones
Instrucciones para...
 Mostrar textos en la pantalla
 Leer datos del usuario
 Realizar cálculos
 Tomar decisiones
 Repetir operaciones
 Etcétera...

Hola Mundo!
De vuelta en el programa que muestra un saludo en la pantalla:
#include <iostream>
using namespace std;
int main() // main() es donde empieza la ejecución
{
cout << "Hola Mundo!" << endl;
return 0;
}

Hola Mundo!
La única instrucción que produce algo tangible:
#include <iostream>
{
return 0;
}

cout
Visualización en la pantalla:
character output stream
cout
<< "Hola Mundo!" << endl;
Hola Mundo!
_
_
endl  end line

Pantalla en modo texto
En este primer curso, toda la salida se va a realizar en pantallas
en modo texto. Las interfaces gráficas se verán en 2º curso.
 Líneas de 80 caracteres. Se pueden mostrar textos en ellas.
Aplicación con interfaz gráfica
Aplicación en modo texto
80 caracteres

Ventanas de consola o terminal
Sistema operativo: con interfaz gráfica de usuario (GUI).
Las aplicaciones en modo texto se ejecutan dentro de ventanas:
 Windows: ventanas de consola (Símbolo del sistema).
 Linux: ventanas de terminal.
H o l a M u n d o !
...
Cursor parpadeante: Donde se colocará el siguiente carácter.
...

El insertor <<
<< Envía info a un dispositivo de salida.
cout << ...;
Inserta textos en la pantalla de modo texto
La representación textual de los datos enviados
aparecerá en el dispositivo de salida,
a partir de la posición del cursor.
Si se llega al final de una línea se sigue al principio de la siguiente.
cout representa la ventana de consola/terminal.
Las operaciones de inserción se pueden encadenar:
cout << ... << ... << ...;
Se mostrarán todos los datos que haya a continuación de <<.
Las instrucciones terminan en ;.

El insertor <<
¿Qué podemos mostrar?
 Cadenas de caracteres literales.
Textos encerrados entre comillas dobles: "..."
cout << "Hola Mundo!";
Se muestran los caracteres dentro de las comillas.
 Números literales.
Con o sin decimales, con signo o no: 123, -37, 3.1416, ...
cout << "Pi = " << 3.1416;
Se muestran los caracteres que representan el número.
 endl
El cursor pasa al principio de la siguiente línea.

El programa principal
La función main():
#include <iostream>
{
return 0;
}
Las instrucciones están dentro de funciones.
main() es donde comienza la ejecución.

El programa principal
La función main():
Tipo de la función (int = entero): Tipo de valor que devuelve.
int main()
{
Nombre de la función.
return 0;
}
Cuerpo de la función (bloque de código).
¡Es una función!
return 0; Devuelve el resultado (0) de la función.

Documentando el código
Los comentarios (se ignoran durante la compilación):
#include <iostream>
{
return 0;
}
Hasta el final de la línea: // ...
De varias líneas: /* ...
... */

La infraestructura
C++ nos proporciona mucho código para reutilizar:
#include <iostream>
Es una directiva: empieza por #
{
return 0;
}
Bibliotecas de funciones a nuestra disposición.
Al incluirlas podemos usar lo que contienen.

Bibliotecas
Se incluyen con la directiva #include:
#include <biblioteca>
#include <iostream>
Biblioteca iostream: utilidades de entrada/salida por consola.
Donde, por ejemplo, está declarado cout o se encuentra
el código del insertor.
Cualquier programa que quiera mostrar en la pantalla (consola)
o leer datos del usuario, debe incluir la biblioteca iostream.

Espacios de nombres
Si hay espacios de nombres en la biblioteca hay que elegir uno:
#include <iostream>
Es una instrucción: termina en ;
{
return 0;
}
Siempre vamos a usar el espacio de nombres estándar (std).
Muchas bibliotecas no crean espacios de nombres.

Compilación y enlace
Página 32
hola.cpp
(código fuente)
Compilador hola.obj
(código objeto)
Enlazador
hola.exe
(ejecutable)
Código objeto de
la biblioteca iostream
Hola Mundo!
Cargador
A menudo el compilador y el enlazador están integrados.

Elementos del programa
#include <iostream>
int main()
{
Cabecera de la función
Variable
return 0;
}
Página 33
Las instrucciones terminan en ;
Directiva
Instrucción
Declaración
Instrucción
Instrucción
Biblioteca
Espacio de nombres
Tipo Palabras reservadas
Datos literales
Cuerpo de la función
Bloque de código
Cadena de caracteres Constante
Operador Operador
Número
Coloreado sintáctico:
Directivas Tipos
Palabras reservadas generales
Datos literales Comentarios

Uso de espacio en blanco
Los elementos del lenguaje se pueden separar por uno o más espacios en blanco
(espacios, tabuladores y saltos de línea).
El compilador los ignora. Deben usarse para mejorar la legibilidad.
También deben usarse comentarios para aclarar aspectos del código.
Página 34
#include <iostream>
int main()
{
return 0;
}
#include <iostream> using namespace std;
int main(){cout<<"Hola Mundo!"<<endl;
return 0;}
¿Cuál se lee mejor?

Programa con E/S por consola
Una plantilla para empezar:
#include <iostream>
int main()
{
return 0;
}
¡Tu código aquí!

... recitado en la consola
Mostrar los textos con cout <<:
#include <iostream>
int main()
{
cout << "En un lugar de la Mancha," << endl;
cout << "de cuyo nombre no quiero acordarme," << endl;
cout << "no ha mucho tiempo que vivía un hidalgo de los de
lanza en astillero, ..." << endl;
return 0;
}

Introducción del código del programa
Terminamos cada línea de código con un salto de línea (↲):
#include <iostream> ↲
using namespace std; ↲
↲
int main() ↲
{↲
cout << "En un lugar de la Mancha," << endl; ↲
cout << "de cuyo nombre no quiero acordarme," << endl; ↲
lanza en astillero, ..." << endl; ↲
return 0; ↲
} ↲

Introducción del código del programa
No hay que partir una cadena literal entre dos líneas:
lanza en astillero, ..." << endl; ↲
Si se llega al final de la línea en el editor, se deja que continúe
en la siguiente.
Sólo se pulsa Intro (↲) al terminar cada instrucción.
cout << "no ha mucho tiempo que vivía un hidalgo de los ↲
de lanza en astillero, ..." << endl; ↲
Errores:
La cadena no termina (1ª línea); no se entiende de (2ª línea).

Notepad++ y G++
D:FPTema2quijote.cpp

Mantenimiento y reusabilidad
El código debe ser lo más legible posible.
 Usar espacio en blanco para separar elementos del código:
mejor que
cout<<"En un lugar de la Mancha,"<<endl;
 Usar sangría (indentación) para el código de un bloque:
{
...
return 0;
}
Tab / 2 ó 3
espacios
Cuanto más legible, más fácil de mantener y reutilizar.
¡El estilo importa!

Operadores aritméticos
En los programas podemos realizar operaciones aritméticas.
Para cada operación utilizamos un símbolo concreto:
+ Suma
- Resta
* Multiplicación
/ División
Los cuatro son operadores binarios:
operando_izquierdo operador operando_derecho
Por ejemplo:
3 + 4 Resultado: 7
2.56 – 3 Resultado: -0.44
143 * 2 Resultado: 286
45.45 / 3 Resultado: 15.15

Cómo escribir operandos numéricos
Las cantidades pueden ser:
Valores literales
 Enteras: sin parte decimal
 Reales: con parte decimal
Cantidades enteras (sin decimales):
Signo negativo (opcional) seguido de una secuencia de dígitos.
3 143 -12 67321 -1234
No se usan puntos de millares
Cantidades reales (con decimales):
Signo negativo (opcional) seguido de una secuencia de dígitos,
un punto decimal y otra secuencia de dígitos.
3.1416 357.5 -1.333 2345.6789 -404.1
Punto decimal (3.1415), NO coma decimal (3,1415)

Ejemplo
#include <iostream>
int main()
{
calculos.cpp
cout << "133 + 1234 = " << 133 + 1234 << endl;
cout << "1234 - 111.5 = " << 1234 - 111.5 << endl;
cout << "34 * 59 = " << 34 * 59 << endl;
cout << "3.4 * 5.93 = " << 3.4 * 5.93 << endl;
cout << "500 / 3 = " << 500 / 3 << endl; // División entera
cout << "500.0 / 3 = " << 500.0 / 3 << endl; // División real
return 0;
}

#include <iostream>
int main()
{
cout << "133 + 1234 = " << 133 + 1234 << endl;
cout << "1234 - 111.5 = " << 1234 - 111.5 << endl;
cout << "34 * 59 = " << 34 * 59 << endl;
cout << "3.4 * 5.93 = " << 3.4 * 5.93 << endl;
cout << "500 / 3 = " << 500 / 3 << endl; // División entera
cout << "500.0 / 3 = " << 500.0 / 3 << endl; // División real
return 0;
}
División entera/real

¿División entera o división real?
El operador división (/) hace una división entera
(despreciando los decimales) si ambos operandos son enteros
y hace una división real (con decimales) si alguno es real.
500 / 3 Resultado: 166
500.0 / 3 Resultado: 166.667
500 / 3.0 Resultado: 166.667
500.0 / 3.0 Resultado: 166.667
Hay que usar algún operando real siempre que se quiera que
la división sea una división real.
Comprueba siempre si la división que se va a realizar es la que quieres.

Datos que se mantienen en memoria
Una variable es un dato que se accede por medio de un nombre.
Un valor literal es un valor concreto que se escribe tal cual.
Una variable puede cambiar de valor siempre que se quiera.
edad = 19; // edad es una variable y 19 es un literal
Las variables deben ser declaradas antes de poder utilizarlas.
Cuando se declaran se reserva espacio suficiente en memoria
para el dato que se quiere almacenar.
¿Qué tipo de dato queremos mantener?
 Un valor numérico sin decimales (entero): int
 Un valor numérico con decimales (real): double
Declaración: tipo nombre;

Declaración
Al declarar una variable establecemos el tipo de dato que puede
contener y el nombre que usaremos para acceder a ese dato.
int cantidad;
double precio;
Para cada variable se reserva espacio
suficiente en memoria para el tipo de valor.
Unos tipos de datos requieren más bytes que otros.
LAS VARIABLES NO SE INICIALIZAN
No se deben usar hasta que se les haya dado algún valor.
¿Dónde colocamos las declaraciones?
Siempre, antes del primer uso.
Normalmente, al principio de la función.
Memoria
cantidad ?
precio ?
...

Declaración
#include <iostream>
int main()
{
int cantidad;
double precio, total;
return 0;
}
Memoria
cantidad ?
precio ?
total ?
...
Podemos declarar varias del mismo tipo
separando los nombres con comas.

Capacidad de las variables
¿Qué valores podemos guardar en una variable int?
Cualquier entero entre -2.147.483.648 y 2.147.483.647.
Intervalo de valores del tipo int: -2147483648 .. 2147483647
¿Y en una variable double?
Números reales entre 2,23 x 10-308 y 1,79 x 10+308
y sus negativos -2,23 x 10-308 y -1,79 x 10+308
Intervalo de valores del tipo double:
+/- 2.23e-308 .. 1.79e+308
Con los números reales podemos experimentar
problemas de precisión.
Notación científica en C++

Asignación de valores a las variables (operador =)
Instrucciones de asignación:
variable = expresión;
Instrucción: termina en ;
Se evalúa la expresión y se asigna el resultado a la variable:
cantidad = 12;
precio = 39.95;
total = cantidad * precio; // Toma el valor 479.4
Piensa en el = como en :
cantidad  12
La variable recibe el valor 12.
Ese valor se guarda en la memoria de la variable.
¡¡¡A la izquierda del = debe ir siempre una variable!!!

Expresiones
Secuencias de operandos y operadores:
operando operador operando operador operando ...
Las expresiones se evalúan de izquierda a derecha.
Podemos usar paréntesis para forzar que se realicen unas
operaciones antes que otras:
total = cantidad * precio * 1.18; // +18% de IVA
total = (cantidad1 + cantidad2) * precio;
(Suponiendo que se han declarado las variables cantidad1 y
cantidad2.)
Con el nombre de una variable accedemos a su valor.
Unos operadores se evalúan antes que otros.

Precedencia de los operadores
cantidad1 = 10;
cantidad2 = 2;
precio = 40.0;
* y / tienen mayor precedencia que + y - (se evalúan antes).
total = cantidad1 + cantidad2 * precio;
Se evalúa antes * que +  10 + 2 * 40,0  10 + 80,0  90,0
Los paréntesis fuerzan a que se evalúe su contenido primero:
total = (cantidad1 + cantidad2) * precio;
Se evalúa antes + que *  (10 + 2) * 40,0  12 * 40,0  480,0
Hay que tener cuidado al escribir las expresiones,
de forma que el cálculo sea exactamente el que se requiere.

Ejemplo de uso de variables y expresiones
#include <iostream>
int main()
{
int cantidad;
cantidad = 12;
precio = 39.95;
total = cantidad * precio;
cout << cantidad << " x " << precio << " = "
<< total << endl;
return 0;
}
variables.cpp

Ejemplo de uso de variables
#include <iostream>
int main()
{
int cantidad;
Memoria
cantidad ?
precio ?
total ?
...

#include <iostream>
int main()
{
int cantidad;
cantidad = 12;
Memoria
cantidad 12
precio ?
total ?
...

#include <iostream>
int main()
{
int cantidad;
cantidad = 12;
precio = 39.95;
Memoria
cantidad 12
precio 39.95
total ?
...

#include <iostream>
int main()
{
int cantidad;
cantidad = 12;
precio = 39.95;
Memoria
cantidad 12
precio 39.95
total 479.4
...

#include <iostream>
int main()
{
cantidad 12
precio 39.95
total 479.4
int cantidad;
cantidad = 12;
precio = 39.95;
<< total << endl;
Memoria
...

#include <iostream>
int main()
{
int cantidad;
cantidad = 12;
precio = 39.95;
<< total << endl;
return 0;
}

cin
Lectura de valores para las variables:
character input stream
cin >> cantidad;
cin
>> cantidad;
_
Memoria
cantidad ?
...
_
12
1 2 ↲
1 2_ _

El extractor >>
>> Lee datos de un dispositivo de entrada.
cin >> var;
Transforma los caracteres introducidos por el usuario en datos
A medida que el usuario pulsa teclas, se muestra su carácter
correspondiente en la pantalla, en la posición del cursor,
avanzando éste a la siguiente posición.
La entrada termina con la tecla Intro (el cursor para a la siguiente línea).
El operando derecho del extractor debe ser SIEMPRE una variable.
cin representa el teclado (declarada en la biblioteca iostream).
Las operaciones de extracción se pueden encadenar:
cin >> var1 >> var2 >> var3;
Se leerán los datos de todas esas variables.

El extractor >>
¿Cómo se leen los distintos tipos de datos?
 Valores enteros (int):
Se leen dígitos hasta encontrar un carácter que no lo sea.
cin >> cantidad;
Si se teclean los siguientes caracteres:
12abc↲
Se leen sólo los dos primeros caracteres, asignando el valor
12 a la variable cantidad, y el resto de los caracteres quedan
pendientes para la siguiente operación de extracción.
Es recomendable leer cada dato en una línea:
12↲
La tecla Intro termina la entrada.

El extractor >>
¿Cómo se leen los distintos tipos de datos?
 Valores reales (double):
Se leen dígitos/punto hasta encontrar un carácter que no lo
sea o no se pueda interpretar lo leído como un número real.
cin >> precio;
Si se teclean los siguientes caracteres:
39.95.5abc↲
Se leen sólo los cinco primeros caracteres, asignando el valor
39,95 a la variable precio, y el resto de los caracteres
quedan pendientes para la siguiente operación de extracción.
Es recomendable leer cada dato en una línea:
39.95↲

El extractor >>
¿Qué pasa si el usuario se equivoca?
La lectura no será correcta... y eso puede hacer que
el programa no funcione como debe.
Una aplicación profesional dispondría de código
de comprobación de las entradas por teclado, ayudando
al usuario a corregir sus errores de tecleo.
En esta asignatura supondremos que los usuarios no se
equivocan al teclear.
En ocasiones añadiremos código de comprobación sencillo.
Para evitar errores, lee cada dato en una instrucción aparte.

El extractor >>
int cantidad;
cout << "Introduce la cantidad: ";
cin >> cantidad;
cout << "Introduce el precio: ";
cin >> precio;
cout << "Cantidad: " << cantidad << endl;
cout << "Precio: " << precio << endl;
Indica al usuario qué es lo que
se le pide que introduzca cada vez.
No se puede leer un entero  0 para cantidad y Error
La lectura del precio falla: precio no toma valor (basura)
La ejecución del programa sigue de forma anómala.

El extractor >>
int cantidad;
cin >> cantidad;
cin >> precio;
Se leen dos dígitos  12 para cantidad
No se puede leer un real  0 para precio y Error
La ejecución del programa sigue de forma anómala.

El extractor >>
int cantidad;
cin >> cantidad;
cin >> precio;
Se leen dos dígitos  12 para cantidad
Se lee .5  0,5 para precio y lo demás queda pendiente

El extractor >>
int cantidad;
cin >> cantidad;
cin >> precio;
¡¡¡Lectura correcta!!!

División de dos números:
Pedir al usuario dos números y mostrarle el resultado de dividir el primero
entre el segundo.
Análisis del problema y solución propuesta.-
1. Pedir el numerador
2. Pedir el denominador
3. Realizar la división, guardando el resultado
4. Mostrar el resultado
Datos / cálculos
Variable numerador (double)
Variable denominador (double)
Variable resultado (double)
resultado = numerador / denominador

Entrada-Proceso-Salida
Muchos programas se ajustan a un sencillo esquema:
Declaraciones Entrada Procesamiento Salida
1. Leer numerador
2. Leer denominador
3. Calcular división en resultado
4. Mostrar resultado

División de dos números
entre el segundo.
1. Leer numerador
2. Leer denominador
cin >> numerador;
cin >> denominador;
3. Calcular división en resultado
4. Mostrar resultado
resultado = numerador / denominador;
cout << resultado;

division.cpp
entre el segundo.
Declaraciones
Entrada
Procesamiento
Salida
#include <iostream>
int main()
{
double numerador, denominador, resultado;
cout << "Numerador: "; cin >> numerador;
cout << "Denominador: "; cin >> denominador;
cout << "Resultado: " << resultado << endl;
return 0;
}
Se pueden
declarar varias
variables de un
mismo tipo
separándolas
con comas.

entre el segundo.
#include <iostream>
int main()
{
double numerador, denominador, resultado;
cout << "Numerador: "; cin >> numerador;
cout << "Denominador: "; cin >> denominador;
cout << "Resultado: " << resultado << endl;
return 0;
}
Numerador: _129
_
Denominador: 2
_Resultado: 64.5
_

Problema
Dadas la base y la altura de un triángulo, calcular el área del triángulo.
El comportamiento deseado
Explicación detallada de lo que queremos que haga el programa:
Mostrar en la pantalla un texto que pida la base del triángulo. El usuario
introducirá el valor con el teclado. Mostrar en la pantalla un texto que pida la
altura del triángulo. El usuario introducirá el valor con el teclado. Se calculará el
área del triángulo y se mostrará en la pantalla.
Comenzaremos identificando los objetos que maneja el programa,
fijándonos en los sustantivos; nos indicarán los datos a manejar.
Luego nos fijaremos en las acciones (verbos);
nos indicarán las operaciones a realizar.

Datos que maneja el programa
introducirá la base con el teclado. Mostrar en la pantalla un texto que pida la
altura del triángulo. El usuario introducirá la altura con el teclado. Se calculará
el área del triángulo y se mostrará en la pantalla.
El usuario no es un dato que maneje el programa: es quien maneja
el programa. Por eso no lo tenemos en cuenta.
— pantalla: ya sabemos que se corresponde con cout.
— texto que pida la base del triángulo: una cadena de caracteres literal como
"Introduzca la base del triángulo: ".
— base: un número variable que debe recoger el valor introducido por el
usuario. Ha de indicarse cuál es su tipo: por ejemplo, double.
— teclado: ya sabemos que se corresponde con cin.
. . .
— área del triángulo: otro número variable que debe recoger el resultado.
Ha de indicarse cuál es su tipo: por ejemplo, double.

Datos que maneja el programa: tipos
Cada dato es de un determinado tipo, puede ser constante o variar, y si
varía ha de tener un nombre (estándar o elegido por nosotros):
Objeto Tipo ¿Varía? Nombre
Pantalla Variable cout
"Introduzca la base del triángulo: " Constante ninguno
Base del triángulo double Variable base
Teclado Variable cin
"Introduzca la altura del triángulo: " Constante ninguno
Altura del triángulo double Variable altura
Área del triángulo double Variable area
Se han obviado los tipos de los objetos del sistema y los literales.
Los valores literales son constantes, no se pueden cambiar.
Para que un dato pueda variar se necesita una variable con nombre.

Operaciones (acciones)
introducirá la base con el teclado. Mostrar en la pantalla un texto que
pida la altura del triángulo. El usuario introducirá la altura con el
teclado. Se calculará el área del triángulo y se mostrará en la pantalla.
Las operaciones se realizan por medio de operadores:
— mostrar en la pantalla: se envía algo a la pantalla con el insertor <<.
cout << …
— introducir por el teclado: se lee algo del teclado con el extractor >>.
cin >> …
— calcular el área del triángulo: área = base por altura entre dos
area = base * altura / 2

Algoritmo
Secuencia de acciones que ha de realizar el programa
para conseguir resolver el problema:
1. Mostrar en la pantalla el texto que pida la base del triángulo.
2. Leer del teclado el valor para la base del triángulo.
3. Mostrar en la pantalla el texto que pida la altura del triángulo.
4. Leer del teclado el valor para la altura del triángulo.
5. Calcular el área del triángulo.
6. Mostrar el área del triángulo.

El programa como transformador de entrada en salida
Programa
Datos
de entrada
Datos
de salida
El estado inicial viene dado por los datos de entrada
y el estado final por los datos de salida:
Algoritmo
Estado
inicial
Estado
final

El programa
...
int main()
{
Declaraciones
Algoritmo
traducido
a código
en C++
return 0;
}
1. Mostrar en la pantalla el texto que pida la base del triángulo.
2. Leer del teclado el valor para la base del triángulo.
3. Mostrar en la pantalla el texto que pida la altura del triángulo.
4. Leer del teclado el valor para la altura del triángulo.
5. Calcular el área del triángulo.
6. Mostrar el área del triángulo.

El programa: implementación
#include <iostream>
int main()
{
triangulo.cpp
Las instrucciones terminan en ;
double base, altura, area; // 1. Declarar...
cout << "Introduzca la base del triángulo: "; // 2. Mostrar ...
cin >> base; // 3. Leer del...
cout << "Introduzca la altura del triángulo: "; // 4. Mostrar ...
cin >> altura; // 5. Leer del...
area = base * altura / 2; // 6. Calcular...
cout << "El área de un triángulo de base " << base << " y altura "
<< altura << " es: " << area << endl; // 7. Mostrar...
return 0;
}

Ejecución
#include <iostream>
int main()
{
¿¿¿triβngulo???
Problemas con
los juegos de
double base, altura, area;
cout << "Introduzca la base del triángulo: ";
cin >> base;
cout << "Introduzca la altura del triángulo: ";
cin >> altura;
area = base * altura / 2;
cout << "El área de un triángulo de base " << base << " y altura "
<< altura << " es: " << area << endl;
return 0;
}
caracteres

Variabilidad de los datos
Datos
Constantes
"Introduzca la base del triángulo: "
3.141592653589
Literales
Con nombre
Variables
base, altura, area
Pi = 3.141592653589
Identificadores

Identificadores Distintos de las palabras reservadas del lenguaje
Las variables y las constantes con nombre tienen un identificador
asociado que se usa para obtener su valor
(o para modificar su valor, en el caso de las variables).
— Un identificador es el nombre de un dato concreto.
— Se debe usar nombres descriptivos (autoexplicativos).
Sintaxis de los identificadores:
Al menos
32 caracteres
significativos
(longitud mínima
para diferenciar
dos nombres).
0..9, a..z, A..Z, _
a..z, A..Z, _
¡No se admiten ni eñes ni vocales acentuadas!
No pueden repetirse identificadores en un mismo ámbito (bloque).

Palabras reservadas del lenguaje C++
asm auto bool break case catch char class const
const_cast continue default delete do double
dynamic_cast else enum explicit extern false
float for friend goto if inline int long
mutable namespace new operator private protected
public register reinterpret_cast return short
signed sizeof static static_cast struct switch
template this throw true try typedef typeid
typename union unsigned using virtual void
volatile while

¿Qué identificadores son válidos y cuáles no?

balance interesAnual

_base_imponible años



EDAD12 salario_1_mes
__edad cálculoNómina

valor%100 AlgunValor
 
100caracteres valor?
 
_12_meses ____valor





Tipos
Cada dato del programa es de un tipo concreto.
Cada tipo establece:
— El conjunto (intervalo) de valores válidos.
true
3.14159
"Hola"
Las variables del tipo tomarán uno de esos valores cada vez.
125
'a'
— El conjunto de operaciones que se pueden realizar sobre los valores
del tipo. Los operadores que se pueden aplicar en las expresiones.
En las expresiones con datos de distintos tipos compatibles
se llevan a cabo transformaciones automáticas de tipos
(promoción de tipo).
Para consultar los detalles técnicos de los tipos de datos,
accede al Anexo de este Tema 2 que también se ha publicado.

Tipos de datos básicos
— int: para números enteros (sin parte decimal).
1363, -12, 49

— float: para números reales (con parte –punto– decimal).
12.45, -3.1932, 1.16E+02
— double: para números reales; mayores intervalo y precisión.
(Usaremos habitualmente el tipo double para los números reales.)
— char: para caracteres.
'a' , '{', 't'
— bool: para valores lógicos (verdadero/falso, sí/no).
true, false
— string: para cadenas de caracteres.
"Hola Mundo!"
(Requiere incluir la biblioteca string con espacio de nombres std.)
— void: nada, ausencia de tipo, ausencia de dato (funciones).


char Caracteres
Intervalo de valores: Juego de caracteres (ASCII)
Literales:
'a', '%', 't'
Constantes de barra invertida (o secuencias de escape):
Caracteres de control.
't' = tabulador, 'n' = salto de línea, …
Juego de caracteres:
ASCII (códigos 32..127)
ISO-8859-1
1 byte
(ASCII extendido: códigos 128..255)

bool Valores lógicos
Sólo dos valores posibles:
— Verdadero (true)
— Falso (false)
Literales:
true, false
En realidad, cualquier número distinto de 0 es equivalente a true
y el número 0 es equivalente a false.

string Cadenas de caracteres
"Hola", "Introduce el numerador: ", "X142FG5TX?%A"
" char "
Son secuencias de caracteres.
Se asigna la memoria que se necesita para la secuencia concreta.
Requieren incluir la biblioteca string con el espacio de nombres std:
#include <string>
¡Ojo!
Las comillas tipográficas (apertura/cierre) “…” te darán problemas
al compilar. Asegúrate de utilizar comillas rectas: "…"

Recuerda: C++ distingue entre mayúsculas y minúsculas
int es la palabra reservada de C++ que permite declarar
datos enteros.
Int, INT o inT no son palabras reservadas de C++.
true es la palabra reservada de C++ que representa
el valor lógico verdadero.
True o TRUE no son palabras reservadas de C++.

Ejemplo de tipos de datos
tipos.cpp
#include <iostream>
#include <string>
using namespace std; // Un solo using... para las dos bibliotecas
int main()
{
int entero = 3; // Podemos asignar (inicializar) al declarar
double real = 2.153;
char caracter = 'a';
bool cierto = true;
string cadena = "Hola";
cout << "Entero: " << entero << endl;
cout << "Real: " << real << endl;
cout << "Caracter: " << caracter << endl;
cout << "Booleano: " << cierto << endl;
cout << "Cadena: " << cadena << endl;
return 0;
}
¿Cuántos números hay en total en el programa?
¿Y caracteres? ¿Y cadenas? ¿Y booleanos?

Modificadores de tipos
Permiten modificar el significado de los tipos base.
— signed / unsigned : con signo (por defecto) / sin signo.
— short / long : reduce/amplía el intervalo de valores posibles.
Tipo Intervalo
int -2147483648 .. 2147483647
unsigned int 0 .. 4294967295
short int -32768 .. 32768
unsigned short int 0 .. 65535
long int -2147483648 .. 2147483647
unsigned long int 0 .. 4294967295
double +/- 2.23e-308 .. 1.79e+308
long double +/- 3.37E-4932 .. 1.18E+4932

Declaración de variables
[modificadores] tipo lista_de_variables;
[ … ] indica que eso es opcional.
lista_de_variables
Identificador
int i, j, l;
short int unidades;
unsigned short int monedas;
double balance, beneficio, perdida;
Termina en ;
,
Programación con buen estilo:
Utiliza identificadores descriptivos. Un espacio tras cada coma.
Los nombres de las variables, en minúsculas.
Si se compone de varias palabras, capitaliza cada inicial
de las sucesivas palabras (balanceAnual, interesPorMes).

Datos y memoria
Cuando se declara una variable se le reserva suficiente memoria.
int inicio;
short int unidades;
double balance;
Al explicar la ejecución
de los programas
no distinguiremos
entre los tamaños de
las distintas variables.
Memoria
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
. . .
inicio
unidades
balance

Inicialización de variables
¡En C++ las variables no toman automáticamente un valor inicial!
Al declarar una variable, ésta toma un valor desconocido
que no es válido y no debe ser utilizado.
¡Toda variable debe ser inicializada antes de ser accedida por primera vez!
¿Cómo se inicializa una variable?
Error común de programación:
Acceder a variables no inicializadas.
— Al declararla
— Al leer su valor (cin >>)
— Al asignarle un valor (instrucción de asignación)
Inicialización en la propia declaración, a continuación del identificador:
El resultado de la expresión
debe ser un valor compatible.
… Identificador = Expresión
En particular, una expresión
puede ser un literal
int i = 0, j, l = 26;
short int unidades = 100;

Uso de las variables
Obtención del valor de la variable:
 Aparición del nombre de la variable en una expresión.
cout << balance;
cout << interesPorMes * meses / 100;
Modificación del valor de la variable:
 Aparición del nombre de la variable a la izquierda
del operador de asignación (=).
balance = 1214;
porcentaje = valor / 30;
Toda variable ha de haber sido previamente declarada
en el ámbito del código (función) en el que se utiliza.

Declaración de constantes Modificador de acceso const
Declaramos variables inicializadas a las que no dejamos variar:
Declaración de variable con inicializador
Un nombre de constante no puede
aparecer a la izquierda del =
en una asignación,
más allá de en su declaración.
const
const short int Meses = 12;
const double Pi = 3.141592,
RATIO = 2.179 * Pi;
Pon en mayúscula la primera letra de una constante o todo su nombre.

¿Por qué utilizar constantes con nombre?
 Aumentan la legibilidad del código:
cambioPoblacion = (0.1758 - 0.1257) * poblacion; versus
cambioPoblacion = (RatioNacimientos – RatioMuertes) * poblacion;
 Facilitan la modificación del código:
...
double compra1 = bruto1 * 16 / 100;
double compra2 = bruto2 * 16 / 100;
double total = compra1 + compra2;
cout << total << " (IVA: " << 16 << "%)" << endl;
3 cambios
¿Cambio del IVA al 18%?
...
const int IVA = 16;
double compra1 = bruto1 * IVA / 100;
double compra2 = bruto2 * IVA / 100;
double total = compra1 + compra2;
cout << total << " (IVA: " << IVA << "%)" << endl;
1 cambio

Ejemplo de uso de constantes
constantes.cpp
#include <iostream>
int main()
{
const double Pi = 3.141592;
double radio = 12.2, circunferencia;
circunferencia = 2 * Pi * radio;
cout << "Circunferencia de un circulo de radio "
<< radio << ": " << circunferencia << endl;
const double Euler = 2.718281828459; // Número e
cout << "Numero e al cuadrado: " << Euler * Euler << endl;
const int IVA = 18;
int cantidad = 12;
double precio = 39.95, neto, porIVA, total;
neto = cantidad * precio;
porIVA = neto * IVA / 100;
total = neto + porIVA;
cout << "Total compra: " << total << endl;
return 0;
}

Operaciones sobre valores de los tipos
Las operaciones que se pueden realizar sobre valores de
un determinado tipo vienen dadas por los operadores definidos
para ese tipo de datos.
Tipos de datos numéricos (int, float y double, con sus variantes):
— Asignación
— Operadores aritméticos
— Operadores relacionales
Tipo de datos bool:
— Asignación
— Operadores lógicos
Tipo de datos char:
— Asignación, ++/--
— Operadores relacionales

Operadores para tipos de datos numéricos
Operador Operandos Posición int float / double
- 1 (monario) Prefijo Cambio de signo
+ 2 (binario) Infijo Suma
- 2 (binario) Infijo Resta
* 2 (binario) Infijo Producto
/ 2 (binario) Infijo División entera División real
% 2 (binario) Infijo Módulo No aplicable
++ 1 (monario) Prefijo / postfijo Incremento
-- 1 (monario) Prefijo / postfijo Decremento
Operadores binarios: Operando_izquierdo Operador Operando_derecho
Operadores monarios:
Prefijo: Operador Operando
Postfijo: Operando Operador
a + b
-a --a ++a
a-- a++

Operadores monarios y operadores binarios
Operadores monarios (o unarios)
— El cambio de signo se puede aplicar a una variable, una constante
o una expresión entre paréntesis (en seguida hablamos de expresiones):
-saldo -RATIO -(3 * a – b)
— Los operadores de incremento y decremento sólo se aplican a variables:
++interes --meses j++
Operadores binarios
— Un operador binario se aplica entre un operando izquierdo y un operando
derecho. Los operandos pueden ser literales, constantes, variables o
expresiones:
2 + 3 a * RATIO -a + b 3 * a++
(a % b) * (c / d)

¿División entera o división real?
Si ambos operandos son enteros, / hace un división entera:
int i = 23, j = 2;
cout << i / j; // Muestra 11
Si alguno de los operandos es real, / hace una división real:
int i = 23;
double j = 2;
cout << i / j; // Muestra 11.5
/

Módulo (resto de la división entera)
Ambos operandos han de ser enteros:
int i = 23, j = 2;
cout << i % j; // Muestra 1
División entera:
No se obtienen decimales  Queda un resto
%
123 5
3 24
123 % 5

Operadores de incremento y decremento
Se incrementa/decrementa el operando numérico en una unidad.
Forma prefija: Se incrementa/decrementa antes de acceder.
int i = 10, j;
j = ++i; // Se incrementa antes de copiar el valor de i en j
cout << i << " - " << j; // Muestra 11 - 11
Forma postfija: Se incrementa/decrementa después de acceder.
int i = 10, j;
j = i++; // Se incrementa después de copiar el valor de i en j
cout << i << " - " << j; // Muestra 11 – 10
Sólo se pueden aplicar sobre variables (modifican el operando).
++/--
i=i+1;
j=i;
j=i;
i=i+1;
Es preferible NO utilizar los operadores ++ y –
en expresiones con otros operandos/operadores.

Ejemplo de uso de operadores
operadores.cpp
#include <iostream>
int main()
{
int entero1 = 15, entero2 = 4;
double real1 = 15.0, real2 = 4.0;
cout << "Operaciones entre los numeros 15 y 4:" << endl;
cout << "Division entera (/): " << entero1 / entero2 << endl;
cout << "Resto de la division (%): " << entero1 % entero2 << endl;
cout << "Division real (/): " << real1 / real2 << endl;
(sigue)

Ejemplo de uso de operadores
cout << "Num = " << real1 << endl;
real1 = -real1;
cout << "Cambia de signo (-): " << real1 << endl;
real1 = -real1;
cout << "Vuelve a cambiar (-): " << real1 << endl;
cout << "Se incrementa antes (++ prefijo): " << ++real1 << endl;
cout << "Se muestra antes de incrementar (posfijo ++): "
<< real1++ << endl;
cout << "Ya incrementado: " << real1 << endl;
return 0;
}

Evaluación de expresiones
¿Cómo evaluamos una expresión como 3 + 5 * 2 / 2 – 1 ?
¿En qué orden se aplican los distintos operadores?
¿De izquierda a derecha?
¿De derecha a izquierda?
¿Unos operadores antes que otros?
Resolución de ambigüedades:
— Precedencia de los operadores (prioridad):
Unos operadores se han de evaluar antes que otros (mayor precedencia).
— Asociatividad de los operadores (orden a igual prioridad):
Los operadores de igual prioridad se evalúan de izquierda a derecha
o de derecha a izquierda de acuerdo con su asociatividad.
Paréntesis: rompen la precedencia y asociatividad
Siempre se evalúan en primer lugar las subexpresiones parentizadas.

Precedencia y asociatividad de los operadores
Precedencia Operadores Asociatividad
Mayor prioridad ++ -- (postfijos) Izquierda a derecha
++ -- (prefijos) Derecha a izquierda
- (cambio de signo)
* / % Izquierda a derecha
Menor prioridad + - Izquierda a derecha
3 + 5 * 2 / 2 – 1
Misma precedencia:
Izquierda antes.
 3 + 10 / 2 – 1  3 + 5 – 1  8 – 1  7
Misma precedencia:
Izquierda antes.
Mayor
precedencia

Evaluación de expresiones
Suponiendo que la variable entera a
contiene en este momento el valor 3…
(3 + 5) * a++ + 12 / a++ – (a * 2)
Primero, los paréntesis...
Ahora, los ++ (mayor prioridad)
8 * 3 + 12 / 3 – 6 a pasa a valer 5
Evita usar los operadores ++
y -- en expresiones compuestas.
8 * a++ + 12 / a++ – (3 * 2)
8 * a++ + 12 / a++ – 6
24 + 4 – 6
28 – 6
22

Una fórmula
#include <iostream>
int main()
{
double x, f;
cout << "Introduce el valor de X: ";
cin >> x;
f = 3 * x * x / 5 + 6 * x / 7 - 3;
cout << "f(x) = " << f << endl;
return 0;
}
x 6
x
3
3
7
5
( )
2
  
f x
formula.cpp

Abreviaturas aritméticas
Cuando una expresión tiene la forma:
variable = variable operador op_derecho;
La misma
Se puede abreviar como: variable operador= op_derecho;
Ejemplos:
a = a + 12; a += 12;
a = a * 3; a *= 3;
a = a - 5; a -= 5;
a = a / 37; a /= 37;
a = a % b; a %= b;
Operadores (prioridad) Asociatividad
++ -- (postfijos)
Izda. a dcha.
Llamadas a funciones
++ -- (prefijos) Dcha. a izda.
- (cambio de signo)
* / % Izda. a dcha.
+ - Izda. a dcha.
= += -= *= /= %= Dcha. a izda.

Igual precedencia que la asignación.

Desbordamiento
Si una expresión produce un valor mayor del máximo permitido por el
tipo correspondiente (o menor del mínimo), habrá desbordamiento.
¡El resultado no será válido!
short int i = 32767; // Valor máximo para short int
cout << ++i; // Muestra -32768
Los valores short int se codifican en memoria (2 bytes)
en Complemento a 2 (FC); al incrementar se pasa al valor mínimo.
Bit de signo
0 = positivo
1 = negativo
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
32767
+ 1
-32768
Debemos asegurarnos de utilizar tipos que contengan
todo el conjunto de valores posibles para nuestros datos.

Espaciado y paréntesis
 Se deben usar espacios en el código para facilitar la legibilidad.
f = 3*x*x/5+6*x/7-3;
f = 3 * x * x / 5 + 6 * x / 7 - 3;
Un espacio antes y después de cada operador binario.
 Se pueden usar paréntesis, aunque resulten redundantes,
para dejar patentes las prioridades de las operaciones.
f = (3 * x * x) / 5 + (6 * x) / 7 - 3;
O si no se está seguro de la precedencia.
Los paréntesis no afectan a la velocidad del programa.

El operador =
Operador para asignaciones:
Variable Expresión
++ -- (postfijos) Izda. a dcha.
- (cambio de signo)
* / % Izda. a dcha.
+ - Izda. a dcha.
= Dcha. a izda.
= ;
El operando izquierdo debe ser
siempre una variable, que recibe el valor
resultante de evaluar la expresión.
int i, j = 2;
i = 23 + j * 5; // i toma el valor 33
Mínima precedencia
Se evalúa de derecha a izquierda (asociatividad):
int a, b, c;
a = b = c = 5; // Las tres variables reciben el valor 5
Las instrucciones de asignación terminan en ;

El operador =
El operando izquierdo ha de ser siempre una variable.
Posibles errores:
int a, b, c;
const int cte = 1;
5 = a; // ERROR: un literal no puede recibir un valor
cte = 5; // ERROR: una constante no puede cambiar de valor
a + 23 = 5; // ERROR: no puede haber una expresión a la izda.
b = "abc"; // ERROR: un entero no puede guardar una cadena
c = 23 5; // ERROR: expresión no válida (falta operador)

Variables, asignación y memoria
int i, j = 2; i = 23 + j * 5;
Memoria
01
02
03
04
05
?
j 06
2
07
08
09
10
. . .
i
Memoria
01
02
23 + 2 * 5 33
03
04
05
j 06
2
07
08
09
10
. . .
i

Ejemplo: Intercambio de valores
Se necesita una variable auxiliar.
double a = 3.45, b = 127.5, aux;
a 3.45
b 127.5
aux ?
a 3.45
b 127.5
aux 3.45
a 127.5
b 127.5
aux 3.45
a 127.5
b 3.45
aux 3.45
aux = a;
a = b;
b = aux;

Funciones matemáticas
La biblioteca cmath contiene muchas funciones matemáticas
que podemos utilizar en nuestras expresiones.
Para poder utilizarlas hay que incluir la biblioteca:
#include <cmath>
Una llamada (erróneamente llamada a menudo invocación)
de una función tiene esta forma:
nombre(argumentos) Los argumentos irán separados por comas.
Por ejemplo, abs(a)  Valor absoluto de a.
Una llamada a función de biblioteca será un término más de una expresión.
f = 3 * pow(x, 2) / 5 + 2 * sqrt(x);

Algunas funciones matemáticas de cmath
abs(x) Valor absoluto de x
pow(x, y) x elevado a y
sqrt(x) Raíz cuadrada de x
ceil(x) Menor entero que es mayor o igual que x
floor(x) Mayor entero que es menor o igual que x
exp(x) ex
log(x) Ln x (logaritmo natural de x)
log10(x) Logaritmo en base 10 de x
sin(x) Seno de x
cos(x) Coseno de x
tan(x) Tangente de x
round(x) Redondeo al entero más próximo
trunc(x) Pérdida de la parte decimal (entero)
Las llamadas a funciones
tienen la mayor prioridad.

Un ejemplo
#include <iostream>
#include <cmath>
int main()
{
3
2
x
y
5 y
f x y x 
( , ) 2 cos( )
x 
y
 
funciones.cpp
double x, y, f;
cout << "Introduzca el valor de X: ";
cin >> x;
cout << "Introduzca el valor de Y: ";
cin >> y;
f = 2 * pow(x, 5) + sqrt(pow(x, 3) / pow(y, 2)) / abs(x * y) – cos(y);
cout << "f(x, y) = " << f << endl;
return 0;
}
Pon un espacio detrás de cada coma en las listas de argumentos.

Operadores para caracteres
Los únicos operadores definidos para el tipo char son
la asignación, incremento/decremento (código siguiente/anterior)
y los operadores relacionales ().
Funciones para caracteres (biblioteca cctype)
— isalnum(c) true si c es una letra o un dígito; si no, false.
— isalpha(c) true si c es una letra; si no, false.
— isdigit(c) true si c es un dígito; si no, false.
— islower(c) true si c es una letra minúscula; si no, false.
— isupper(c) true si c es una letra mayúscula; si no, false.
— toupper(c) devuelve la mayúscula de c.
— tolower(c) devuelve la minúscula de c.
…

Un ejemplo
#include <iostream>
int main()
{
caracteres.cpp
char caracter1 = 'A', caracter2 = '1', caracter3 = '&';
cout << "Caracter 1 (A).-" << endl;
cout << "Alfanumerico? " << isalnum(caracter1) << endl;
cout << "Alfabetico? " << isalpha(caracter1) << endl;
cout << "Digito? " << isdigit(caracter1) << endl;
cout << "Mayuscula? " << isupper(caracter1) << endl;
caracter1 = tolower(caracter1);
cout << "En minuscula: " << caracter1 << endl;
1  true / 0  false
(sigue)

Un ejemplo
cout << "Caracter 2 (1).-" << endl;
cout << "Caracter 3 (&).-" << endl;
cout << "Alfanumerico? " << isalnum(caracter3) << endl;
return 0;
}
1  true / 0  false

Operadores relacionales
Permiten hacer comparaciones (condiciones):
Condición ::= Expresión Operador_relacional Expresión
Las expresiones deben arrojar resultados del mismo tipo (comparables).
El resultado es de tipo bool (true o false).
< menor que
<= menor o igual que
> mayor que
>= mayor o igual que
== igual que
!= distinto de
++ -- (postfijos)
Izda. a dcha.
Llamadas a funciones
- (cambio de signo)
* / % Izda. a dcha.
+ - Izda. a dcha.
< <= > >= Izda. a dcha.
== != Izda. a dcha.
= += -= *= /= %= Dcha. a izda.

Operadores relacionales
bool resultado;
int a = 2, b = 3, c = 4;
resultado = a < 5; // 2 < 5  true
resultado = a * b + c >= 12; // 10 >= 12  false
resultado = a * (b + c) >= 12; // 14 >= 12  true
resultado = a != b; // 2 != 3  true
resultado = a * b > c + 5; // 6 > 9  false
resultado = a + b == c + 1; // 5 == 5  true
Los operadores aditivos y multiplicativos tienen mayor prioridad.
Error común de programación:
Confundir el operador de igualdad (==) con el operador de asignación (=).

Selección
Si la condición es cierta, hacer esto... ; si no, hacer esto otro...
Bifurcación condicional:
true
InstrucciónT
false
InstrucciónF
if (condición)
instrucciónT
else
instrucciónF
Condición

Selección
#include <iostream>
int main()
{
int op1 = 13, op2 = 4;
int opcion;
cout << "1 - Sumar" << endl;
cout << "2 - Restar" << endl;
cout << "Opcion: ";
cin >> opcion;
if (opcion == 1)
cout << op1 + op2 << endl;
else
cout << op1 - op2 << endl;
return 0;
}
seleccion.cpp

¿Hay que hacer más de un cosa?
Si en alguna de las dos ramas del if es necesario poner varias
instrucciones, se necesita crear un bloque de código:
{
intrucción1
intrucción2
...
intrucciónN
}
Por ejemplo:
Tab o
2 ó 3
esp.
{ instrucción }
Cada instrucción simple irá terminada en ;
int num, total = 0;
cin >> num;
if (num > 0)
{
cout << "Positivo";
total += num;
}
cout << endl;
Cada bloque crea
un nuevo ámbito
en el que las declaraciones
son locales.

Posición de las llaves: cuestión de estilo
if (num > 0) if (num > 0) {
{ cout << "Positivo";
cout << "Positivo"; total += num;
total += num; }
} cout << endl;
cout << endl;
No te dejes engañar
if (num > 0) if (num > 0)

cout << "Positivo"; cout << "Positivo";
total += num; total += num;
Aunque la sangría pueda dar a entender, a simple vista, que las dos
instrucciones se ejecutan como destino del if, la segunda instrucción
se ejecuta sea num mayor que cero o no: ¡en cualquier caso!

Ejemplo
#include <iostream>
int main()
{
int op1 = 13, op2 = 4, resultado;
int opcion;
char operador;
cout << "1 - Sumar" << endl;
cout << "2 - Restar" << endl;
cout << "Opcion: ";
cin >> opcion;
if (opcion == 1) {
operador = '+';
resultado = op1 + op2;
}
else {
operador = '-';
resultado = op1 - op2;
}
cout << op1 << operador << op2 << " = " << resultado << endl;
return 0;
}
bloques.cpp

Iteración
Mientras que la condición sea cierta, repetir esto...
while ( condición ) cuerpo
Repetición condicional:
while (condición)
cuerpo
true false
Condición
Cuerpo
Mientras la condición sea true se ejecuta el cuerpo.
Si la condición es false al empezar, no se ejecuta el cuerpo ninguna vez.
El cuerpo del bucle es una instrucción (simple o compuesta –bloque –).

Iteración
#include <iostream>
int main()
{
int i = 1, n = 0, suma = 0;
while (n <= 0) { // Sólo n positivo
cout << "Cuantos numeros quieres sumar? ";
cin >> n;
}
while (i <= n) {
suma += i;
i++;
n
}
cout << "Sumatorio de i (1 a " << n << ") = " << suma << endl;
return 0;
}
serie.cpp

i

i
1

false
Iteración
while (i <= n) {
suma += i;
i++;
true
5
10
}
serie.cpp
n

i

i
1
n 5
i 1
suma 0
suma += i;
i++;
4
2
6
3
1
6
3
i <= n 15

Flujos de texto
C++ no tiene facilidades de E/S en el propio lenguaje.
La E/S se realiza a través de flujos (streams).
Los flujos conectan la ejecución del programa
con los dispositivos de entrada/salida.
Los flujos de texto son secuencias de caracteres.
Entrada por teclado:
Se colocan los caracteres en el flujo de entrada cin (de tipo istream).
Salida por pantalla:
Se colocan los caracteres en el flujo de salida cout (de tipo ostream).
cin cout
Programa
7 3 5 . 3 5 1 1 6 = l a t o T

Flujos
cin y cout son objetos de datos definidos en la biblioteca iostream.
La E/S se realiza por medio de sus operadores.
Operadores de entrada/salida:
>> Extractor: Operador binario para expresiones de entrada de datos.
El operando izquierdo es un flujo de entrada (cin) y el operando derecho
una variable. El resultado de la operación es el propio flujo de entrada.
Flujo de entrada Variable
>>
<< Insertor: Operador binario para expresiones de salida de datos.
El operando izquierdo es un flujo de salida (cout) y el operando derecho
una expresión. El resultado de la operación es el propio flujo de salida.
Flujo de salida << Expresión
La asociatividad de ambos operadores es de izquierda a derecha.

Expresiones de entrada
Variable
cin >>
— char: Se saltan los espacios en blanco* y se asigna el carácter a la variable.
— int: Se saltan los espacios en blanco* que haya. Se leen los dígitos seguidos
que haya y se transforma la secuencia de dígitos en un valor que se asigna.
— float/double: Se saltan los espacios en blanco* que haya. Se leen los
dígitos seguidos que haya; si hay un punto se leen los dígitos que le sigan;
se transforma la secuencia en un valor que se asigna.
— bool: Si lo leído es 1, la variable toma el valor true; con cualquier otra
entrada toma el valor false. No se suelen leer este tipo de variables.
int i;
char c;
double d;
cin >> c >> d >> i;
cout << c << "|" << d << "|" << i;
* Espacios en blanco: espacios, tabuladores o saltos de línea.

Flujos de entrada
int i;
char c;
double d;
cin >> c >> d >> i;
Programa z 1 2 3 . 4 5 6 5 
cin
Se lee el carácter 'z' y se asigna a la variable c; resultado: cin
Se leen los caracteres 123.45, se convierten al valor 123.45
(válido para double) y se asigna a la variable d; resultado: cin
Se ignoran los espacios, se leen los caracteres 65, se convierten
al valor 65 (válido para int) y se asigna a la variable i
cin >> d >> i;
cin >> i;
C++ siempre intentará leer los datos sin provocar errores de ejecución,
pero si las secuencias de caracteres de la entrada no son correctas,
los valores asignados a las variables serán impredecibles.

Facilitar la entrada
Programas amigables con el usuario
Indicar al usuario para cada dato qué se espera que introduzca:
int edad;
char letra;
double saldo;
cout << "Introduce una letra: ";
cin >> letra;
cout << "Introduce el saldo: ";
cin >> saldo;
cout << "Introduce tu edad: ";
cin >> edad;
cout << letra << "|" << saldo << "|" << edad;
Tras escribir cada dato el usuario pulsará la tecla Intro.
Buenos hábitos de programación:
Ser amigable con el usuario

Ejecución de funciones con el operador punto (.)
Las variables de algunos tipos (como istream u ostream)
admiten que se llamen sobre ellas sus funciones
con la notación del operador punto:
variable.función(argumentos)
Por ejemplo:
char c;
cin.get(c);
// Llama a la función get() sobre la variable cin
La función get() lee el siguiente carácter sin saltar espacios en blanco.
Los caracteres de espacio en blanco también se asignan a la variable.

Lectura de cadenas de caracteres (string)
La lectura de cadenas de tipo string con cin >> termina
cuando encuentra el primer espacio en blanco.
El resto de los caracteres tecleados quedan pendientes para
la siguiente lectura. Si queremos descartarlos usamos cin.sync().
string nombre, apellidos;
cout << "Nombre: ";
cin >> nombre;
cin.sync();
cout << "Apellidos: ";
cin >> apellidos;
cout << "Nombre completo: "
<< nombre << " "
<< apellidos << endl;
¿Cómo leer varias palabras?
cout << "Nombre: ";
cin >> nombre;
cin >> apellidos;
<< nombre << " "
apellidos toma la cadena "Antonio"

Lectura de cadenas de caracteres (string)
string.cpp
Para leer incluyendo espacios en blanco se usa la función getline():
getline(cin, cadena)
Se guardan en la cadena todos los caracteres leídos hasta el final
de la línea (Intro).
¡Se leen bien los caracteres castellanos!
cout << "Nombre: ";
getline(cin, nombre);
getline(cin, apellidos);
<< nombre << " "

Expresiones de salida
Expresión
cout <<
Se calcula el resultado de la expresión. Se convierte (si es necesario)
a su representación en caracteres y se envían los caracteres al flujo
de salida (pantalla).
int meses = 7;
cout << "Total: " << 123.45 << endl << " Meses: " << meses;
Total: 123.45
Meses: 7
La biblioteca iostream
define la constante endl
como un salto de línea.

Flujos de salida
T o t a l : 1 2 3 . 4 5  M e s e s : 7 Programa
cout
int meses = 7;
cout << "Total: " << 123.45 << endl << " Meses: " << meses;
cout << 123.45 << endl << " Meses: " << meses;
cout << endl << " Meses: " << meses;
cout << " Meses: " << meses;
cout << meses;
Total: 123.45
Meses: 7

Datos y flujos de texto
No es lo mismo el valor double 123.45 que su representación textual,
que es la secuencia de caracteres: '1' '2' '3' '.' '4' '5'
double d = 123.45;
d 123.45
cout << d;
¡Un número real!
5 4 . 3 2 1
¡Un texto!
(secuencia de caracteres)

Formato de la salida
Las bibliotecas iostream e iomanip tienen definidas constantes
que permiten, cuando se envían a cout, establecer opciones de formato
que afecten a la salida que se realice a continuación.
Biblioteca Identificador Propósito
iostream
showpoint /
noshowpoint
Mostrar o no el punto decimal para reales sin
parte decimal (añadiendo 0 a la derecha).
fixed / scientific Notación de punto fijo / científica (reales).
boolalpha Valores bool como true / false.
left / right Ajustar a la izquierda/derecha.
iomanip setw(anchura)* Nº de caracteres (anchura) para el valor.
setprecision(p)
Precisión: Nº de dígitos (antes y después del .).
Con fixed o scientific, nº de decimales.
*setw() sólo afecta al siguiente dato que se escriba, mientras que los otros afectan a todos.
(Subrayadas las opciones predeterminadas.)

Formato de la salida (ejemplo)
bool fin = false;
cout << fin << "->" << boolalpha << fin << endl;
double d = 123.45;
char c = 'x';
int i = 62;
cout << d << c << i << endl;
cout << "|" << setw(8) << d << "|" << endl;
cout << "|" << left << setw(8) << d << "|" << endl;
cout << "|" << setw(4) << c << "|" << endl;
cout << "|" << right << setw(5) << i << "|" << endl;
double e = 96;
cout << e << " - " << showpoint << e << endl;
cout << scientific << d << fixed << endl;
cout << setprecision(8) << d << endl;
0->false
123.45x62
| 123.45|
|123.45 |
|x |
| 62|
96 - 96.0000
1.234500e+002
123.45000000
Se han añadido saltos de línea adicionales.

 Programming. Principles and Practice Using C++
B. Stroustrup. Pearson Education, 2009
 C++: An Introduction to Computing (2ª edición)
J. Adams, S. Leestma, L. Nyhoff. Prentice Hall, 1998
 El lenguaje de programación C++ (Edición especial)
B. Stroustrup. Addison-Wesley, 2002

Licencia CC (Creative Commons)
Este tipo de licencias ofrecen algunos derechos a terceras personas
bajo ciertas condiciones.
Este documento tiene establecidas las siguientes:
Reconocimiento (Attribution):
En cualquier explotación de la obra autorizada por la licencia
hará falta reconocer la autoría.
No comercial (Non commercial):
La explotación de la obra queda limitada a usos no comerciales.
Compartir igual (Share alike):
La explotación autorizada incluye la creación de obras derivadas
siempre que mantengan la misma licencia al ser divulgadas.
Pulsa en la imagen de arriba a la derecha para saber más.

Lenguaje C

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (6)

Destacado

Destacado (8)

Similar a Lenguaje C

Similar a Lenguaje C (20)

Último

Último (20)

Lenguaje C