Programación de

Computadoras
Referencias
http://en.cppreference.com/w/cpp
http://www.tutorialesya.com.ar/cmasmasya/index.php?inicio=0
¿Qué es un programa?
●Conjunto de instrucciones que entiende una
computadora para realizar una actividad.
●Todo programa tiene un objetivo bien definido:

● un procesador de texto es un programa que

permite cargar, modificar e imprimir textos,

● un programa de ajedrez permite jugar al

ajedrez contra el ordenador u otro contrincante

humano.
●La actividad fundamental del programador es
resolver problemas empleando el ordenador como
herramienta fundamental.
●Para la resolución de un problema hay que

plantear un algoritmo.
Algoritmo
● Cualquier problema de computación puede resolverse
ejecutando una serie de acciones en un orden específico.
● Algoritmo: es un procedimiento para resolver un
problema en términos de
− 1. las acciones a ejecutar y
− 2. el orden en el que se ejecutan estas acciones
Algoritmo
● Considere el “algoritmo para levantarse y arreglarse” que
sigue un ejecutivo para levantarse de la cama e ir a
trabajar:
1) Levantarse;
2) Quitarse la pijama;
3) Bañarse;
4) Vestirse;
5) Desayunar;
6) Transportarse al trabajo.
Algoritmo
● Suponga que los mismos pasos se realizan en un orden
ligeramente distinto:
1) Levantarse;
2) quitarse la pijama;
3) Vestirse;
4) Bañarse;
5) Desayunar;
6) transportarse al trabajo
Algoritmo
● Control del programa
− Al proceso de especificar el orden en el que se ejecutan las
instrucciones (acciones) en un programa de computadora, se
le llama control del programa.
Pseudocódigo
● El pseudocódigo (o “imitación” de código) es un lenguaje
informal que ayuda a los programadores a desarrollar
algoritmos sin tener que preocuparse por los estrictos
detalles de la sintaxis del lenguaje.
● El pseudocódigo es similar al lenguaje cotidiano;
● Es conveniente y amigable con el usuario, aunque no es
realmente un lenguaje de programación de computadoras.
● Ayuda al programador a “organizar” un programa antes de
intentar escribirlo en un lenguaje de programación como
C++.
Pseudocódigo
● Por lo general, el pseudocódigo describe sólo las
instrucciones ejecutables, que representan las acciones
que ocurren
● Después, un programador convierte un programa de
pseudocódigo a C++
● Por lo general no incluimos las declaraciones de variables
en nuestro pseudocódigo.
Pseudocódigo
● Ejemplo
− algoritmo que recibe como entrada dos enteros del usuario,
suma estos enteros y muestra su suma en pantalla.
1)Pedir al usuario que introduzca el primer entero
2)Recibir como entrada el primer entero

3)Pedir al usuario que introduzca el segundo entero

4)Recibir como entrada el segundo entero

5)Sumar el primer entero con el segundo entero,

almacenar el resultado
6)Mostrar el resultado en pantalla
Pseudocódigo
// Programa de suma que muestra la suma de dos enteros.
#include <iostream> // permite al programa realizar operaciones de entrada y salida
// la función main empieza la ejecución del programa
int main()
{
// declaraciones de variables
int numero1; // primer entero a sumar
int numero2; // segundo entero a sumar
int suma; // suma de numero1 y numero2

std::cout << "Escriba el primer entero: "; // pide los datos al usuario
std::cin >> numero1; // lee el primer entero del usuario y lo coloca en numero1

std::cout << "Escriba el segundo entero: "; // pide los datos al usuario
std::cin >> numero2; // lee el segundo entero del usuario y lo coloca en numero2

suma = numero1 + numero2; // suma los números; almacena el resultado en suma

std::cout << “La suma es “ << suma << std::endl; // muestra la suma; fin de línea
return 0; // indica que el programa terminó correctamente
} // fin de la función main
Pseudocódigo
● Aspectos importantes acerca del pseudocódigo del
ejemplo:
− Observe que el pseudocódigo corresponde sólo al código de la
función main;
− el pseudocódigo se utiliza normalmente para los algoritmos no
para los programas completos.
− En este caso, el pseudocódigo representa el algoritmo.
− La función en la que se coloca este código no es importante
para el algoritmo en sí.
Diagrama de Flujo
● Un diagrama de flujo es la representación gráfica de un
ALGORITMO.
● Los símbolos gráficos a utilizar para el planteo de
diagramas de flujo son:
Diagrama de Flujo
● Inicio y fin del diagrama

● Entrada de datos
(Ej. Teclado)
● Condición
● Salida de datos
(Ej. Pantalla)
● Operación
Ejemplo de un programa en C++
#include<iostream>
using namespace std;

int main()
{
int horasTrabajadas;
float costoHora;
float sueldo;

cout <<"Ingrese Horas trabajadas por el operario:";

cin >>horasTrabajadas;

cout <<"Ingrese el pago por hora:";

cin >>costoHora;

sueldo = horasTrabajadas * costoHora;

cout <<"El sueldo total del operario es:";

cout <<sueldo;

return 0;
}
Ejemplo de un programa en C++
Ejemplo de un programa en C++
Estructuras de Control
● ejecución secuencial
− A menos que se le indique lo contrario, la computadora ejecuta
las instrucciones en C++ una después de otra, en el orden en
que estén escritas, es decir, en secuencia.
● instrucción goto
− permite al programador especificar la transferencia de control a
uno de los muchos posibles destinos dentro de un programa
(creando lo que se conoce comúnmente como “código
espagueti”)
Estructuras de Control
● programación estructurada
− sinónimo de la “eliminación del goto”
Estructuras de Control

● Instrucciones de selección (condicionales) en C++

− if
● realiza (selecciona) una acción si la condición (predicado) es
verdadera, o evita la acción si la condición es falsa.
− if...else
● se conoce como instrucción de selección doble, ya que selecciona
entre dos acciones distintas (o grupos de acciones).
− switch
● es una estructura de selección múltiple, ya que selecciona entre
diversas acciones (o grupos de acciones).
Estructuras de Control
● Instrucciones de repetición (o de ciclos) en C++
− permiten a los programas ejecutar instrucciones en forma
repetida, siempre y cuando una condición (llamada la
condición de continuación del ciclo) siga siendo verdadera.
− while
● realizan la acción (o grupo de acciones) en sus cuerpos, cero o más
veces;
● si la condición de continuación del ciclo es inicialmente falsa, no se
ejecutará la acción (o grupo de acciones).
Estructuras de Control
● Instrucciones de repetición (o de ciclos) en C++
− do...while
● realiza la acción (o grupo de acciones) en su cuerpo, una o más
veces;
● la verificación de la condición de continuación de ciclo se realiza al
final de la instrucción.
− for
● realizan la acción (o grupo de acciones) en sus cuerpos, cero o más
veces;
● si la condición de continuación del ciclo es inicialmente falsa, no se
ejecutará la acción (o grupo de acciones).
Estructuras de Control

● Instrucción de selección if en C++

Si la calificación del estudiante es mayor o igual a 60
Imprimir “Aprobado”

if ( calificacionEstudiante >= 60 )
cout << "Aprobado";
Estructuras de Control

● Instrucción de selección doble if..else en C++

Si la calificación del estudiante es mayor o igual a 60
Imprimir “Aprobado”
De lo contrario
Imprimir “Reprobado”

if ( calificacion >= 60 )
cout << "Aprobado";
else
cout << "Reprobado";
Estructuras de Control
● Operador condicional ternario ? : en C++

cout << ( calificacionEstudiante >= 60 ? "Aprobado" : "Reprobado" );

Los valores en una expresión condicional también pueden ser acciones a ejecutar:
calificacionEstudiante >= 60 ? cout << "Aprobado" : cout << "Reprobado";
#include <iostream>
using namespace std; // si la edad es mayor o igual a 18
int main() // Woow eres un adulto
{ // de lo contrario
int vEdad; // Woow eres un menor de edad
cout<<"Cual es tu edad?";
cin >> vEdad; return 0;
}

Usar las estructuras if..else y el operador condicional para

resolver lo que se indica en comentarios.
Estructuras de Control

● Instrucciones if..else anidadas en C++

Si la calificación del estudiante es mayor o igual a 90
Imprimir “A”
de lo contrario
Si la calificación del estudiante es mayor o igual a 80
Imprimir “B”
de lo contrario
Si la calificación del estudiante es mayor o igual a 70
Imprimir “C”
de lo contrario
Si la calificación del estudiante es mayor o igual a 60
Imprimir “D”
de lo contrario
Imprimir “F”
 Estructuras de Control

● Instrucciones if..else anidadas en C++

if ( calificacionEstudiante >= 90 ) // 90 o más recibe una "A"
cout << "A";
else
if ( calificacionEstudiante >= 80 ) // 80 a 89 recibe una "B"
cout << "B";
else
if ( calificacionEstudiante >= 70 ) // 70 a 79 recibe "C
cout << "C";
else
if ( calificacionEstudiante >= 60 ) // 60 a 69 recibe "D"
cout << "D";
else // menos de 60 recibe "F“
cout << "F";
 Estructuras de Control

● Instrucciones if..else anidadas en C++

if ( calificacionEstudiante >= 90 ) // 90 o más recibe una "A"
cout << "A";
else if ( calificacionEstudiante >= 80 ) // 80 a 89 recibe una "B"
cout << "B";
else if ( calificacionEstudiante >= 70 ) // 70 a 79 recibe "C"
cout << "C";
else if ( calificacionEstudiante >= 60 ) // 60 a 69 recibe "D"
cout << "D";
else // menos de 60 recibe "F"
cout << "F";
Estructuras de Control

● Problema del else suelto

if ( x > 5 )
if ( y > 5 )
cout << "x y y son > 5";
else
cout << "x es <= 5" );
Tipos de Errores de Programación
● Sintácticos
− A los errores tipográficos, como por ejemplo la falta de puntos
y comas, nombres de variables incorrectas, falta de paréntesis,
palabras claves mal escritas, etc.
● Lógicos
− Este tipo de errores en programas grandes (miles de líneas)
son más difíciles de localizar.
Tipos de Errores de Programación
Compiladores
● Las computadoras sólo entienden un idioma y es el
lenguaje que se compone de una serie de instrucciones
hechas de unos y ceros. Este lenguaje de programación
se llama apropiadamente lenguaje de máquina.
● Una sola instrucción a un ordenador podría tener este
aspecto:
− 00000 10011110
Compiladores
● Un programa en lenguaje de máquina de una
computadora particular, que permite al usuario introducir
dos números, suma los dos números, y muestra el total
podría incluir estas instrucciones de código máquina:
00000 10011110
00001 11110100
00010 10011110
00011 11010100
00100 10111111
00101 00000000
Compiladores
● Esta es una porción de código escrito en C++ que lleva a
cabo exactamente el mismo objetivo:
Compiladores
● En ambientes Mac o Linux:

Compiler Platform Command

GCC Linux, among g++ -std=c++0x example.cpp -o
Clang others... example_program
OS X, among clang++ -std=c++11 -stdlib=libc++ example.cpp -o
others... example_program
Estructura de un programa en
C++
// my first program in C++
#include <iostream>

int main()
{
std::cout << "Hello World!";
}
Estructura de un programa en
C++
● Comentarios
− Los comentarios no afectan a la operación del programa; Sin
embargo, proporcionan una importante herramienta para
documentar directamente en el código fuente de lo que hace el
programa y cómo funciona.
− C++ soporta dos formas de comentarios:
Estructura de un programa en
C++
● Comentarios
Estructura de un programa en
C++
● Using namespace std
− Uso de cout en lugar de std::cout
− cout es parte la biblioteca estandar, y todos los
elementos de la biblioteca estandar de C++ son
declarados dentro de lo que es llamado un espacio de
nombres (namespace): el espacio de nombres std.
Estructura de un programa en
C++
● using namespace std
C++
● Variables
− Una variable es como
un recipiente, donde
se puede colocar
información para
luego utilizarla.
− Una variable es el
nombre de un lugar
(dirección) en la
memoria de la
computadora donde
se almacenan datos.
C++
● Variables
− Una variable es el
nombre de un lugar
en la memoria de la
computadora donde
se almacenan datos.
C++

Memoria
C++
● Identificadores
− alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break,
case, catch, char, char16_t, char32_t, class, compl, const, constexpr,
const_cast, continue, decltype, default, delete, do, double,
dynamic_cast, else, enum, explicit, export, extern, false, float, for,
friend, goto, if, inline, int, long, mutable, namespace, new, noexcept,
not, not_eq, nullptr, operator, or, or_eq, private, protected, public,
register, reinterpret_cast, return, short, signed, sizeof, static,
static_assert, static_cast, struct, switch, template, this, thread_local,
throw, true, try, typedef, typeid, typename, union, unsigned, using,
virtual, void, volatile, wchar_t, while, xor, xor_eq
● *Muy Importante: El lenguaje C++ es un lenguaje sensible a
mayúsculas y minúsculas (case sensitive)
Tipos de datos en C++

● Tipos de Datos Fundamentales

− Tipos Character: Pueden representar un solo carácter, como 'A' o '$'. El
tipo más básico es char, que es un carácter de un byte. También se
proporcionan otros tipos para caracteres más amplios. (Ascii Table)
− Tipos Entero: Pueden almacenar un valor de número entero, como 7 o
1024. Existen en una variedad de tamaños y pueden con o sin signo,
dependiendo de si admiten valores negativos o no.
− Tipos de punto flotante: Pueden representar valores reales, como 3.14
o 0.01, con diferentes niveles de precisión, según cuál de los tres tipos
de coma flotante se utilice.
− Tipo Booleano: El tipo booleano, conocido en C ++ como bool, solo
puede representar uno de dos estados, true -verdadero- o false -falso-.
Tipos de datos en C++
● Tipos caracter

Type names Notes on size/precision

char Exactly one byte in size. At least 8 bits.

char16_t Not smaller than char. At least 16 bits.
char32_t Not smaller than char16_t. At least 32 bits.
wchar_t Can represent the largest supported character set.
Tipos de datos en C++
● Tipos entero (con signo)

Type names Notes on size/precision

signed char Same size as char. At least 8 bits.

signed short int Not smaller than char. At least 16 bits.
signed int Not smaller than short. At least 16 bits.
signed long int Not smaller than int. At least 32 bits.
signed long long int Not smaller than long. At least 64 bits.
Tipos de datos en C++
● Tipos entero (sin signo)

Type names Notes on size/precision

unsigned char (same size as their signed counterparts)

unsigned short int
unsigned int
unsigned long int
unsigned long long int
Tipos de datos en C++
● Tipos punto flotante

Type names Notes on size/precision

float
double Precision not less than float
long double Precision not less than double
Tipos de datos en C++
● Otros Tipos

Group Type names Notes on size/precision

Boolean type bool

Void type void no storage
Null pointer decltype(nullptr)
Tipos de datos en C++
● Longitudes o tamaños
− Los tamaños de letra anteriores se expresan en bits; cuantos
más bits tiene un tipo, más valores distintos puede representar,
pero al mismo tiempo, también consume más espacio en la
memoria:
Size Unique representable values Notes

8-bit 256 =28

16-bit 65 536 =216
32-bit 4 294 967 296 = 232 (~4 billion)
64-bit 18 446 744 073 709 551 616 = 264 (~18 billion billion)
C++
● Declaración de variables
− C ++ es un lenguaje fuertemente tipado y requiere que cada
variable se declare con su tipo antes de su primer uso. Esto
informa al compilador el tamaño a reservar en memoria para la
variable y cómo interpretar su valor.
C++
C++
● Inicialización de variables
− c-like initialization
● type identifier = initial_value;
C++
● Inicialización de variables
− constructor initialization (introduced by the C++ language)
● type identifier (initial_value);
C++
● Inicialización de variables
− uniform initialization
● type identifier {initial_value};
Tipos de datos en C++
● String
− Puede concatenar cadenas con el operador + como en Pascal,
pero recuerde que C ++ encierra cadenas literales entre
comillas dobles (por ejemplo, "Hill") en lugar de entre comillas
simples. Las cadenas de C ++ tienen muchas rutinas
incorporadas. Aquí demostramos length(), at(), find(),
append() e insert(). Una copia de la salida sigue al
código.
C++
● Constantes
− Constants are expressions with a fixed value.
● Literales
75 // int
75u // unsigned int
75l // long
75ul // unsigned long
75lu // unsigned long
3.14159 // 3.14159
6.02e23 // 6.02 x 10^23
1.6e-19 // 1.6 x 10^-19
3.0 // 3.0
3.14159L // long double
6.02e23f // float
C++
● Literales string y caracter

'z'
'p'
"Hello world"
"How do you do?"
C++
● Caracteres de escape
Escape Description
Code
\n newline
\r carriage return
\t tab
\v vertical tab
\b backspace
\f form feed (page feed)
\a alert (beep)
\' single quote (')
\" double quote (")
\? question mark (?)
\\ backslash (\)
C++
● Literales string y carácter
− Ejemplos
'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree" x = "string expressed in \
"Is \"okay\"\?" two lines"

is equivalent to:

x = "string expressed in two lines"

C++
● Otras literales
C++
● Expresiones constantes con tipo
C++
C++
● Definiciones de preprocesador (#define)
− Another mechanism to name constant values is the use of
preprocessor definitions.
● #define identifier replacement
C++
C++
● Operadores de Asignación (=)
int a, b; // a:?, b:?
a = 10; // a:10, b:?
b = 4; // a:10, b:4
a = b; // a:4, b:4
b = 7; // a:4, b:7

x = y = z = 5;
y = 2 + (x = 5);

Es equivalente a:

x = 5;
y = 2 + x;
C++
● Operadores compuestos de asignación (+=, -=, *=, /=, %=,
>>=, <<=, &=, ^=, |=)

expression equivalent to...

y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
price *= units + 1; price = price * (units+1);
C++
● Operadores de incremento y decremento (++, --)

Example 1
x = 3;
y = ++x;
// x contains 4, y contains 4

Example 2
x = 3;
y = x++;
// x contains 4, y contains 3
C++
● Operadores relacionales y de comparación (==, !=, >, <,
>=, <=)

operator description
== Equal to
!= Not equal to
< Less than
> Greater than
<= Less than or equal
to
>= Greater than or
equal to
C++
● Operadores lógicos (!, &&, ||)

!(5 == 5) // evaluates to false because the expression at

// its right (5 == 5) is true
!(6 <= 4) // evaluates to true because (6 <= 4) would be
// false
!true // evaluates to false
!false // evaluates to true

( (5 == 5) && (3 > 6) ) // evaluates to false (true && false)

( (5 == 5) || (3 > 6) ) // evaluates to true (true || false)
C++
● Operadores lógicos (!, &&, ||)

operator short-circuit
&& if the left-hand side expression is false, the
combined result is false (the right-hand side
expression is never evaluated).

|| if the left-hand side expression is true, the

combined result is true (the right-hand side
expression is never evaluated).

Example
if ( (i<10) && (++i<n) ) { /*...*/ }
// note that the condition increments i
C++
● Operador ternario condicional ( ? : )
− El operador condicional evalúa una expresión, devolviendo un
valor si esa expresión se evalúa como verdadera y otro
diferente si la expresión se evalúa como falsa. Su sintaxis es:
condition ? result1 : result2

7==5 ? 4 : 3 // evaluates to 3, since 7 is not equal to 5.

7==5+2 ? 4 : 3 // evaluates to 4, since 7 is equal to 5+2.
5>3 ? a : b // evaluates to the value of a, since 5 is
// greater than 3.
a>b ? a : b // evaluates to whichever is greater, a or b.
C++
● Entrada/Salida básica
− Salida básica (cout) → pantalla
− Operador de inserción <<
cout << "Output sentence"; // prints Output sentence on screen
cout << 120; // prints number 120 on screen
cout << x; // prints the value of x on screen

cout << "Hello"; // prints Hello

cout << Hello; // prints the content of variable Hello

cout << "This " << " is a " << "single C++ statement";

cout << "I am " << age << " anios old and my zipcode is " << zipcode;
C++
● Entrada/Salida básica
− Salida básica (cout)
cout << "First sentence.\n";
cout << "Second sentence.\nThird sentence.";
This produces the following output:

First sentence.
Second sentence.
Third sentence.

cout << "First sentence." << endl;

cout << "Second sentence." << endl;
This would print:

First sentence.
Second sentence.
C++
● Entrada/Salida básica
− Entrada básica (cin) → Teclado. Operador de extracción >>
// i/o example Please enter an integer value: 702
The value you entered is 702 and its double
#include <iostream> is 1404.
using namespace std;

int main ()
{
int i;
cout << "Please enter an integer value: ";
cin >> i;
cout << "The value you entered is " << i;
cout << " and its double is " << i*2 << ".\n";
return 0;
}
C++
● Entrada/Salida básica
− Entrada básica (cin)
cin >> a >> b;
This is equivalent to:

cin >> a;
cin >> b;
C++
● Entrada/Salida básica
− Entrada básica (cin) y strings
The extraction operator can be used on cin to get strings of characters in the same way as with
fundamental data types:

string mystring;
cin >> mystring;

However, cin extraction always considers spaces (whitespaces, tabs, new-line...) as

terminating the value being extracted, and thus extracting a string means to always extract a
single word, not a phrase or an entire sentence.

To get an entire line from cin, there exists a function, called getline, that takes the stream (cin)
as first argument, and the string variable as second. For example:
C++
// cin with strings What's your name? Homer Simpson
#include <iostream> Hello Homer Simpson.
#include <string> What is your favorite team? The Isotopes
using namespace std;
I like The Isotopes too!
int main ()
{
string mystr;
cout << "What's your name? ";
getline (cin, mystr);
cout << "Hello " << mystr << ".\n";
cout << "What is your favorite team? ";
getline (cin, mystr);
cout << "I like " << mystr << " too!\n";
return 0;
}
C++
● Condicionales
− Realizar un programa que solicite ingresar dos números distintos y
muestre por pantalla el mayor de ellos (Condicionales.cpp).
C++
● Ciclo while

− Ejemplo: Desarrollar un programa que

permita la carga de 10 valores por
teclado y nos muestre posteriormente
la suma de los valores ingresados y su
promedio.
● WhileSuma10Valores.cpp
 C++
● Ciclo for
− Ejemplo: Desarrollar un programa
que permita la carga de 10 valores
por teclado y nos muestre
posteriormente la suma de los
valores ingresados y su promedio.
(ForSuma10Valores.cpp ).
− Laboratorio: Escribir un programa
que lea 10 notas de alumnos y nos
informe cuántos tienen notas
mayores o iguales a 7 y cuántos
menores (For10Notas.cpp).
 C++
● Ciclo do..while
− Ejemplo: Escribir un programa que solicite la
carga de números por teclado, obtener su
promedio. Finalizar la carga de valores
cuando se cargue el valor 0 (Ejemplo).
− Laboratorio: Realizar un programa que
permita ingresar el peso (en kilogramos) de
piezas. El proceso termina cuando
ingresamos el valor 0. Se debe informar:
a) Cuántas piezas tienen un peso entre 9.8 Kg. y
10.2 Kg.?, cuántas con más de 10.2 Kg.? y
cuántas con menos de 9.8 Kg.?
b) La cantidad total de piezas procesadas. (Resol).
C++

La declaración break
break deja un bucle, incluso si no se cumple la condición
para su finalización. Puede usarse para terminar un ciclo
infinito, o para forzarlo a terminar antes de su final natural.
Por ejemplo, detengamos la cuenta regresiva antes de su
final natural:
// break loop example
#include <iostream>
using namespace std;

int main ()
{
for (int n=10; n>0; n--)
{
cout << n << ", ";
if (n==3)
{
cout << "cuenta regresiva abortada!";
break;
}
}
}
La declaración de continue
La sentencia continue hace que el programa salte el resto
del bucle en la iteración actual, como si se hubiera llegado
al final del bloque de sentencia, lo que hace que salte al
inicio de la siguiente iteración.
Por ejemplo, saltemos el número 5 en nuestra cuenta
regresiva:
// continue loop example
#include <iostream>
using namespace std;

int main ()
{
for (int n=10; n>0; n--) {
if (n==5) continue;
cout << n << ", ";
}
cout << "liftoff!\n";
}
Otra sentencia de selección: switch
La sintaxis de la instrucción switch es un poco peculiar. Su
propósito es verificar un valor entre un número de posibles
expresiones constantes.
Es algo similar a concatenar sentencias if-else, pero limitado
a expresiones constantes.
Su sintaxis más típica es:
switch (expression)
{
case constant1:
group-of-statements-1;
break;
case constant2:
group-of-statements-2;
break;
.
.
.
default:
default-group-of-statements
}
switch (x) {
case 1:
case 2: Ver: switch demo.cpp
case 3:
cout << "x is 1, 2 or 3";
break;
default:
cout << "x is not 1, 2 nor 3";
}

Observe qué switch se limita a comparar su expresión evaluada con etiquetas

que son expresiones constantes (literales). No es posible usar variables como
etiquetas o rangos, porque no son expresiones constantes válidas de C++
Estructuras C++
● La palabra clave struct introduce la
struct Carta definición de la estructura Carta.
{
string cara; ● El identificador Carta es el nombre de
string palo;
}; // fin de struct Carta la estructura y se utiliza en C++ para
declarar variables de tipo estructura
(registros)
● Los datos (y posiblemente las
funciones; al igual que con las clases)
declarados dentro de las llaves de la
definición de la estructura son los
miembros de la estructura.
 Estructuras C++
● La definición de la estructura Carta no
Carta unaCarta;
Carta mazo[ 52 ]; reserva espacio en memoria;
Carta *cartaPtr;
● en vez de ello, crea un nuevo tipo de
datos que se utiliza para declarar
Palos, dos de color rojo y dos de color negro:
variables de estructura.
→ Picas (conocidas como espadas).

→ Corazones (conocidos como copas).

● Estas variables se declaran de la
→ Rombos (conocidos como diamantes,
misma forma que las variables de
oros o cocos). otros tipos.
→ Tréboles (conocidos como flores o ● Mazo/Mazo.cbp
bastos).
C++
● Declaración de una clase y definición de objetos
− Ejemplo: Desarrollar un programa que cargue los lados de un
triángulo e implemente los siguientes métodos: inicializar los
atributos, imprimir el valor del lado mayor y otro método que
muestre si es equilátero o no. (ClaseTriangulo.cpp).
− Laboratorio: Desarrollar una clase que represente un Cuadrado
y tenga los siguientes métodos: cargar el valor de su lado,
imprimir su perímetro y su superficie (Resol).
C++
● Arreglos
− Declaración

tipoDeDatos nombreArreglo[tamaño];

− Ejemplo
int x[6];

− Ejemplo: Desarrollar un programa que implemente el

ordenamiento por inserción (VectoresOrdenamiento.cpp).
C++
● Arreglos
#include <iostream>
using namespace std;

int main() {
int numeros[5];

cout << "Ingrese 5 números: " << endl;

// almacenar la entrada del usuario en el arreglo

for (int i = 0; i < 5; ++i) {
cin >> numeros[i];
}

cout << "Los números son: ";

// imprimir los elementos del arreglo

for (int n = 0; n < 5; ++n) {
cout << numeros[n] << " ";
}

return 0;
}
C++
● Arreglos
− Otros tipos:
string carros[4] = {"Volvo", "BMW", "Ford", "Mazda"};

carros[0] = "Opel";

cout << carros[0];

// declarar e inicializar un arreglo

int x[6] = {19, 10, 8, 17, 9, 15};

// otra forma

int x[] = {19, 10, 8, 17, 9, 15};

C++
● Arreglos
#include <iostream>
using namespace std; // count the no. of array elements
++count;
int main() { }

// initialize an array without specifying size // print the sum

double numbers[] = {7, 5, 6, 12, 35, 27}; cout << "\nTheir Sum = " << sum << endl;

double sum = 0; // find the average

double count = 0; average = sum / count;
double average; cout << "Their Average = " << average << endl;

cout << "The numbers are: "; return 0;

}
// print array elements
// use of range-based for loop
for (const double &n : numbers) {
cout << n << " ";

// calculate the sum

sum += n;
C++
● Arreglos multidimensionales
int x[3][4];
C++
● Arreglos multidimensionales
int test[2][3] = { {2, 4, 5}, {9, 0, 19}};
C++
● Arreglos multidimensionales
− Ejemplo: Crear una matriz de 3 filas por 5 columnas con
elementos de tipo int, poblar sus componentes y luego
imprimirlas (Ejemplo).
− Ejemplo: Crear y poblar con enteros aleatorios entre 0 y 20,
una matriz de 4 filas por 4 columnas. Una vez poblada, imprimir
la diagonal principal, usando un solo ciclo.
∙ x - - -
∙ - x - -
∙ - - x -
∙ - - - x
C++
● Cadena de caracteres
− En programación, una cadena de caracteres, palabras, ristra
de caracteres o frase (string, en inglés) es una secuencia
ordenada (de longitud arbitraria, aunque finita) de elementos
que pertenecen a un cierto lenguaje formal o alfabeto análogas
a una fórmula o a una oración.
− En general, una cadena de caracteres es una sucesión de
caracteres (letras, números u otros signos o símbolos).
C++
● Cadena de caracteres
− Si no se ponen restricciones al alfabeto, una cadena podrá
estar formada por cualquier combinación finita de los
caracteres disponibles (las letras de la 'a' a la 'z' y de la 'A' a la
'Z', los números del '0' al '9', el espacio en blanco ' ', símbolos
diversos '!', '@', '%', etcétera).
C++
● Cadena de caracteres
− En este mismo ámbito, se utilizan habitualmente como un tipo
de dato predefinido, para palabras, frases o cualquier otra
sucesión de caracteres. En este caso, se almacenan en un
vector de datos, o matriz de datos de una sola fila (array, en
inglés). Las cadenas se pueden almacenar de manera física:
● Seguidas.
● Enlazados letra a letra.
C++
● Cadena de caracteres
● Generalmente los caracteres se guardan uno a
continuación de otro para fines de eficiencia en el acceso.
● Un caso especial de cadena es la que contiene cero
caracteres. A esta cadena se la llama cadena vacía; en
teoría de autómatas, es común representarla por medio de
la letra griega ∊
● String
− Ejemplo: Uso de la clase String estándar de C++ (Ejemplo).
Estructuras C++
● Estructuras
− También son llamadas registros
− Las estructuras son tipos de datos agregados;
● es decir, pueden construirse mediante el uso de elementos de varios
tipos, incluyendo otros tipos struct .
● A cada uno de esos elementos se le llama campo.

struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;
Estructuras C++

struct {
string marca;
string modelo;
int anio;
} miAuto1, miAuto2; // Se puede definir variables separadas por comas

// Poblar la primera estructura

miAuto1.marca = "BMW";
miAuto1.modelo = "X5";
miAuto1.anio = 1999;

// Poblar la segund estructura

miAuto2.marca = "Ford";
miAuto2.modelo = "Mustang";
miAuto2.anio = 1969;

// Imprimir la información de los miembros de las estructuras

cout << miAuto1.marca << " " << miAuto1.modelo << " " << miAuto1.anio << "\n";
cout << miAuto2.marca << " " << miAuto2.modelo << " " << miAuto2.anio << "\n";
Estructuras C++
// Declarar una estructura llamada "car"
struct car {
string marca;
string modelo;
int anio;
};

int main() {
// Crear una estructura car y almacenarla en miAuto1;
car miAuto1;
miAuto1.marca = "BMW";
miAuto1.modelo = "X5";
miAuto1.anio = 1999;

// Crear otra estructura car y almacenarla en miAuto2;

car miAuto2;
miAuto2.marca = "Ford";
miAuto2.modelo = "Mustang";
miAuto2.anio = 1969;

// Imprimr el contenido de lo miembros de las estructuras

cout << miAuto1.marca << " " << miAuto1.modelo << " " << miAuto1.anio << "\n";
cout << miAuto2.marca << " " << miAuto2.modelo << " " << miAuto2.anio << "\n";

return 0;
}
Estructuras C++
Conceptos
● Campo: Es la unidad básica de información en una base de
datos o archivo. Representa una característica o atributo de un
objeto o entidad y se usa para almacenar valores específicos,
como nombres, direcciones, fechas, etc.
● Llave: Es un campo o conjunto de campos que se utilizan para
identificar de manera única un registro en una tabla. La llave se
utiliza para buscar y recuperar información de una tabla de
manera eficiente.
Estructuras C++
Conceptos
● Campo secuencia: Es un tipo de campo que se utiliza para
generar automáticamente un número secuencial único para
cada registro en una tabla. Se suele utilizar como identificador
único para cada registro.
● Registro: Es una colección de campos que representan una
entidad o un objeto. Por ejemplo, un registro de una tabla de
clientes puede incluir campos como nombre, dirección, número
de teléfono, correo electrónico, etc.
● Archivo: Es una colección de registros relacionados que se
almacenan en un medio de almacenamiento, como un disco
duro o una cinta magnética.
Estructuras C++
Conceptos
● Base de datos: Es un conjunto de datos organizados y
relacionados entre sí. Puede contener una o varias tablas, que
a su vez contienen registros y campos.
● Transacción: Es una unidad lógica de trabajo que realiza una o
varias operaciones en una base de datos. Una transacción
puede incluir operaciones como la inserción, actualización o
eliminación de registros.
Estructuras C++
Conceptos
● Organización de registros y archivos: Se refiere a la forma
en que se organizan y se almacenan los registros y archivos de
una base de datos. Las organizaciones más comunes son las
organizaciones secuenciales, indexadas y hash. Cada una
tiene sus propias ventajas y desventajas en términos de
eficiencia y velocidad de acceso a los datos.
Archivos C++
● Acceso Secuencial
− En un archivo de acceso secuencial es posible leer o escribir
un cierto número de datos comenzando siempre desde el
principio del archivo.
− También es posible añadir datos a partir del final del archivo
(habrá que recorrer todo el archivo => poca eficiencia).
− C++ no impone una estructura sobre un archivo.
Archivos C++
● Acceso Secuencial
− Por ende, en un archivo de C++ no existe un concepto tal como
el de un “registro”. En consecuencia, el programador debe
estructurar los archivos de manera que cumplan con los
requerimientos de la aplicación.
− En el siguiente ejemplo veremos cómo se puede imponer una
estructura de registro simple sobre un archivo.
Archivos C++
● Acceso Secuencial
− Es importante tener en cuenta que, debido a que los archivos
secuenciales no están estructurados de manera que permitan
el acceso aleatorio a los datos, si se necesita buscar o
modificar un registro en particular, es necesario leer y procesar
los registros previos en el archivo. Por lo tanto, los archivos
secuenciales no son la mejor opción para aplicaciones que
requieren un acceso aleatorio o una modificación frecuente de
los datos.
Archivos C++
● Acceso Secuencial
− Escritura
● ios::out
− Tenga cuidado al abrir un archivo existente en modo de salida ( ios::out ), en
especial si desea preservar el contenido del archivo, que se descartará sin
advertencia.
− Terminar con
● [Ctrl]+[z] → Windows
● [Ctrl]+[d] → Linux, Unix
Archivos C++
● Acceso Secuencial
− Lectura
● ios::in
− Ejemplo
Archivos C++
● Acceso Aleatorio
− Los registros individuales de un archivo de acceso aleatorio se
pueden utilizar de manera directa (y rápida), sin tener que
buscar en otros registros.
− Al utilizar registros de longitud fija y con el mismo tamaño, es
más fácil para el programa calcular (como una función del
tamaño de registro y la clave de registro) la ubicación exacta de
cualquier registro relativo al inicio del archivo.
− Pronto veremos (Aquí) cómo esto facilita el acceso inmediato a
registros específicos, incluso en archivos extensos.
Estructuras de Datos en C++
● Clases autorreferenciadas
− Una clase autorreferenciada contiene un miembro apuntador
que apunta a otro objeto del mismo tipo de clase.
− Si no se establece el enlace en el último nodo de una
estructura de datos enlazada con el valor nulo( 0 ), se produce
un error lógico (posiblemente fatal).
Estructuras de Datos en C++
● Clases autorreferenciadas
class Nodo {

public:
Nodo( int ); // constructor
void establecerDatos( int ); // establece el miembro de datos
int obtenerDatos() const; // obtiene el miembro de datos
void establecerSiguientePtr( Nodo * ); // establece el apuntador al siguiente Nodo
Nodo *obtenerSiguientePtr() const; // obtiene apuntador al siguiente Nodo

private:
int datos; // datos almacenados en este Nodo
Nodo *siguientePtr; // apuntador a otro objeto del mismo tipo

}; // fin de la clase Nodo

Estructuras de Datos en C++
● Asignación Dinámica de memoria
− Para crear y mantener estructuras dinámicas de datos se
requiere la asignación dinámica de memoria, la cual permite
que un programa obtenga más memoria en tiempo de
ejecución, para almacenar nuevos nodos.
− Cuando el programa ya no necesita la memoria, ésta se puede
liberar para que se pueda reutilizar al asignar otros objetos en
el futuro.
− El límite para la asignación dinámica de memoria puede ser tan
grande como la cantidad de memoria física disponible en la
computadora, o la cantidad de memoria virtual disponible en un
sistema con memoria virtual.
Estructuras de Datos en C++
● Asignación Dinámica de memoria
− El operador new recibe como argumento el tipo del objeto que
se va a asignar en forma dinámica y devuelve un apuntador a
un objeto de ese tipo.
− Nodo *nuevoPtr = new Nodo( 10 );
● asigna sizeof( Nodo ) bytes, ejecuta el constructor de Nodo y asigna
la dirección del nuevo Nodo a nuevoPtr.
● Si no hay memoria disponible, new lanza una expresión bad_alloc.
● El valor 10 se pasa al constructor de Nodo, el cual inicializa el
miembro de datos del Nodo con 10.
Estructuras de Datos en C++
● Asignación Dinámica de memoria
− El operador delete ejecuta el destructor de Nodo y desasigna
la memoria asignada con new;
− esta memoria se devuelve al sistema, de manera que se pueda
reasignar en el futuro.
− delete nuevoPtr;
● Observe que nuevoPtr en sí no se elimina; en vez de ello, se elimina
el espacio al que apunta nuevoPtr.
● Si el apuntador nuevoPtr tiene el valor 0 (apuntador nulo), la
instrucción anterior no tiene efecto. No es un error eliminar mediante
delete un apuntador nulo.
Estructuras de Datos en C++
● Apuntadores
− El operador dirección ( & ) es un operador unario que obtiene la
dirección de memoria de su operando.
− El operador * , que se conoce comúnmente como el operador
de indirección u operador de desreferencia, devuelve un
sinónimo (es decir, un alias o sobrenombre) para el objeto al
que apunta su operando apuntador.
Estructuras de Datos en C++
● Apuntadores
int y = 5; // declara la variable y
int *yPtr; // declara la variable apuntador yPtr

la instrucción

yPtr = &y; // asigna la dirección de y a yPtr

− Entonces, se dice que la variable yPtr “apunta a” y

Estructuras de Datos en C++
● Apuntadores

cout << *yPtr << endl;

Es equivalente a
cout << y << endl;
Ejemplo
Estructuras de Datos en C++
● Listas enlazadas
− Una lista enlazada es una colección lineal de objetos de una
clase autorreferenciada, conocidos como nodos, que están
conectados por enlaces de apuntador; es por ello que se utiliza
el término lista “enlazada”.
− Un programa accede a una lista enlazada mediante un
apuntador al primer nodo en la lista.
− El programa accede a cada nodo subsiguiente a través del
miembro apuntador de enlace almacenado en el nodo anterior.
Estructuras de Datos en C++
● Listas enlazadas
− Por convención, el apuntador de enlace en el último nodo de
una lista se establece en el valor nulo ( 0 ) para marcar el fi nal
de la lista.
− Los datos se almacenan en forma dinámica en una lista
enlazada; se crea cada nodo según sea necesario.
− Un nodo puede contener datos de cualquier tipo, incluyendo
objetos de otras clases.
− Ejemplo
Estructuras de Datos en C++
● Listas tipo Pila

− Una lista se comporta como una pila si las inserciones y

extracciones las hacemos por un mismo lado de la lista.
− También se las llama listas LIFO (Last In First Out - último
en entrar primero en salir).
Estructuras de Datos en C++
● Listas tipo Pila

− Inicialmente la PILA está vacía y decimos que el puntero raiz

apunta a NULL (Si apunta a NULL decimos que no tiene una
dirección de memoria, en realidad este valor NULL es el
valor cero):
− Ejemplo
Estructuras de Datos en C++
● Listas tipo Cola
− Una lista se comporta como una cola si las inserciones las
hacemos al final y las extracciones las hacemos por el frente
de la lista.
Estructuras de Datos en C++
● Listas tipo Cola
− También se las llama listas FIFO (First In First Out - primero en
entrar primero en salir).
− Ejemplo
Estructuras de Datos en C++
● Conceptos de árboles
− Nodo hoja: Es un nodo sin
descendientes (Nodo
terminal)
● Ej. Nodos E, F, C y D.
− Nodo interior: Es un nodo
que no es hoja.
● Ej. Nodos A y B.
 Estructuras de Datos en C++
● Conceptos de árboles
− Nivel de un árbol: El nodo A está en
el nivel 1 sus descendientes directos
están en el nivel 2 y así
sucesivamente.
− El nivel del árbol está dado por el
nodo de máximo nivel.
● Ej. Este árbol es de nivel 3.
 Estructuras de Datos en C++
● Conceptos de árboles
− Grado de un nodo: es el número de
nodos hijos que tiene dicho nodo
(solo se tiene en cuenta los nodos
interiores)
● Ej. El nodo A tiene grado 3.
● El nodo B tiene grado 2.
● Los otros nodos no tienen grado porque
no tienen descendientes.
 Estructuras de Datos en C++
● Conceptos de árboles
− Grado de un árbol: Es el máximo de
los grados de todos los nodos de un
árbol.
● Ej. El grado del árbol es 3.
− Longitud de camino del nodo x: El
número de arcos que deben ser
recorridos para llegar a un nodo x,
partiendo de la raiz.
− La raiz tiene longitud de camino 1,
sus descendientes directos tienen
 Estructuras de Datos en C++
● Conceptos de árboles
− Árbol binario: Un árbol es binario si
cada nodo tiene como máximo 2
descendientes.
− Para cada nodo está definido el
subárbol izquierdo y el derecho.
− Para el nodo A el subárbol izquierdo
está constituido por los nodos B, D y
E. Y el subárbol derecho está
formado por los nodos C y F.
− Lo mismo para el nodo B tiene el
 Estructuras de Datos en C++
● Conceptos de árboles
− Árbol binario perfectamente
equilibrado: Si para cada nodo el
número de nodos en el subárbol
izquierdo y el número de nodos en el
subárbol derecho, difiere como mucho
en una unidad.
− Hay que tener en cuenta todos los
nodos del árbol.
− El árbol de más arriba es
perfectamente equilibrado.
 Estructuras de Datos en C++
● Conceptos de árboles
− Árbol binario completo: Es un árbol
binario con hojas como máximo en los
niveles n-1 y n (Siendo n el nivel del
árbol)
− Los dos árboles graficados son
completos porque son árboles de
nivel 3 y hay nodos hoja en el nivel 3
en el primer caso, y hay nodos hoja
en los niveles 3 y 2 en el segundo
caso.
− Ej. Árbol binario no completo:
 Estructuras de Datos en C++
● Conceptos de árboles
− Árbol binario ordenado: Si para
cada nodo del árbol, los nodos
ubicados a la izquierda son
inferiores al que consideramos raíz
para ese momento y los nodos
ubicados a la derecha son mayores
que la raíz.
 Estructuras de Datos en C++
● Inserción de nodos en un árbol
binario ordenado
− Inicialmente el árbol está vacío, es
decir raíz apunta a NULL
 Estructuras de Datos en C++
● Inserción de nodos en un árbol
binario ordenado
− Insertamos el valor 400
 Estructuras de Datos en C++
● Inserción de nodos en un árbol
binario ordenado
− Insertamos el valor 100
 Estructuras de Datos en C++
● Inserción de nodos en un árbol
binario ordenado
− Insertamos el valor 200
 Estructuras de Datos en C++
● Inserción de nodos en un árbol
binario ordenado
− Insertamos el valor 700
 Estructuras de Datos en C++
● Recorrido de un árbol binario
ordenado
− Recorrer: Pasar a través del árbol
enumerando cada uno de sus
nodos una vez.
− Visitar: Realizar algún
procesamiento del nodo (borrar,
modificar etc.)
 Estructuras de Datos en C++
● Recorrido de un árbol binario
ordenado
− Pre-orden
● Visitar la raíz.
● Recorrer el subárbol izquierdo en
pre-orden.
● Recorrer el subárbol derecho en pre-
orden.
● 400 - 100 - 50 - 75 - 200 - 700
 Estructuras de Datos en C++
● Recorrido de un árbol binario
ordenado
− En-orden
● Recorrer el subárbol izquierdo en en-
orden.
● Visitar la raíz.
● Recorrer el subárbol derecho en en-
orden.
● 50 - 75 - 100 - 200 - 400 - 700
 Estructuras de Datos en C++
● Recorrido de un árbol binario
ordenado
− Post-orden
● Recorrer el subárbol izquierdo en
post-orden.
● Recorrer el subárbol derecho en
post-orden.
● Visitar la raíz
● 75 - 50 - 200 - 100 - 700 - 400
~ Fin ~