BASE C++ atl academy

Se trata de un lenguaje esencial en el mundo de la programación que es empleado

por grandes empresas como Google, Facebook, etc.
Vamos a utilizar DEV, programa para programar en c++.

Ctrl + n <- se abre un nuevo archivo

Estructura básica de cada programa de c++:

#include <iostream>
using namespace std;
int main(){

return 0;
}

¿Qué significa todo esto?

#include <iostream>
Es la biblioteca éstandar de c++ para poder tener acceso a los dispositivos de
estrada y salida. Es decir un conjunto de funciones que te permite una serie de
cosas, como el uso de objetos, cin,cout,cerr y clog.
using namespace std;
Es que te vengan incluidas todas las funciones de std, para poder recibir y enviar
información.
Int main(){
Return 0;
}
Es para ejecutar el programa , indicando con el return 0, que el programa se
ejecuta sin problemas.
Para escribir se utiliza:
cout<<”Mi texto a escribir”;
---------------------------------------------------------------------------------
Dato<- mínima unidad dentro de la información.
Variable<- recordemos que son espacios donde almaceno datos. Se le asigna un
valor y luego se reutiliza.
Constantes<-Se le asigna un valor y ya no cambia.
Formas de nombrar a variables/constantes/documentos etc
camelCase <- para variables
snake_case <- para bases de datos
SCREAMING_SNAKE_CASE <- para constantes
Kebab-case <- para url y carpetas
L33t <- para contraseñas ej: P445W0RD
Notación Húngara <- ej: strNombre , indicando el tipo de variable al principio, en
este caso, string o cadena de texto.
Para crear variables
Indica el tipo de variable:
Ej: int edad = 20
Creo una variable de tipo entero llamada edad, que vale 20.
Hay 5 tipos de datos:
Enteros <- int
Float <- decimales con una aproximación de 7 decimales.
Double <- decimales con una aproximación de 15-16 decimales.
Char<- cadena de caracteres.
Booleano<- verdadero o falso /true or false
Para mostrar saltos de línea <- cout<<”\n”;
Char <- solo una letra
String <- varios caracteres
CONSTANTES Y OPERADORES
Hay 2 formas de escribir constantes:
 #define PI 3.1416
 const float gravedad=9.8
Define se utilizaría antes del int main, o de la función principal,pre procesador,mientras que
const se utiliza dentro.

Para incluir funciones matemáticas se escribe; #include <math.h>

Para aproximar los decimales se escribe la función; #include <iomanip>
Le asignamos valores al principio valores para que el ordenador no asigne valores aleatorios.
Cin <- para leer respuestas
Pow (gracias a #include <math.h> ) : sirve para elevar un número, en este caso a 2
Pow(altura,2)
Setprecision(4) <- indica que se aproxima en el cuarto decimal.

OPERADORES LÓGICOS
&& <- AND
|| <- OR
! <- NOT
IF ELSE AND SWITCH

IF sería nuestro SI en este lenguaje.

If (condición){
Los pasos a seguir
} else if (condición){
Pasos a seguir otra vez
}
El SWITCH evalúa cada caso, aquí nos indica que pasa si escribimos que la opción sea 1, 2
o 3. Al final se escribe break para que no se ejecuten las demás opciones.

HACER COMENTARIOS
Podemos hacer comentarios de un solo renglón como este:
//comentario auhigaxuhwc
Pero podemos hacer comentarios de varias líneas de otra forma:
/*
Comentario
Sjdohweoihfcpoajdckq
D´cOHQEIFCIPewhvowev ´p whv
*/

INCLUDE
Es una directiva que nos ayudará a incluir declaraciones de otros ficheros en la compilación.
#include <nombre de la librería > Para incluir librerías que ya están en el sistema
#include “nombre de la libreria”> Va a buscar la carpeta donde esté nuestro archivo

DEFINE
Permite que hagamos operaciones con un identificador y una secuencia que declaremos, es
decir podemos sustituir operaciones con esta macro.

Otros ejercicios
DO WHILE

Son bucles donde la condición se evalúa al final, es decir que mínimo se hace una vuelta.
ARRAYS
Son espacios que se dividen para almacenar muchas variables.
Se empiezan a contar las posiciones por 0, por ejemplo la frase: Hola mundo
Se guardarían las letras y espacios por separado tal que así:
H0
O1
L2
A3
4
M5
U6
N7
D8
O9

En este caso de arriba creamos el arreglo: int numero[]={4,5,6,7,10,11};

Llamada numero, sin tamaño definido por los corchetes, y entre llaves todos los datos a
almacenar.
Después abrimos un bucle for y dentro de este bucle creamos una variable (int i=0) que valga
0 , que sea menor o igual a 5 para que me lo haga 5 veces o 6 si cuentas con la posición 0 y
después le sumas para que vaya aumentando su valor y no haga un bucle.
Por último, mandas a escribir el arreglo en la posición “i” es decir la posición 0,1,2,3,4, y 5,
porque se va a ir repitiendo, y me muestra los valores que le he dado: 4,5,6,7,10,11.
Para el siguiente caso le pido al usuario que registre un numero de notas, es decir que
designe un tamaño para mi arreglo, para eso creo la variable tamaño, la leo y creo el arreglo
de esta forma <- int notas[tamaño]; para que ocupe el tamaño que he ingresado, pero sin
valores porque el usuario se encargará de ingresar la notas.
Abro un bucle for y creo una variable llamada x que valga 0,que sea menor que tamaño,
porque tenemos que tener en cuenta la posición 0, y que vaya aumentando para que no se
haga infinito.
Pido la primera nota con x+1, leyendo la nota en a, variable que habré creado anteriormente.
Escribo el arreglo con tamaño x y con valor a, es decir que se repita el numero de veces que
he ingresado en un principio y que valga la nota que he ingresado, y por último escribo que
suma, variable que he de crear también, vaya sumando el arreglo, con el símbolo +=.
Hago el promedio dividiendo la suma de notas entre el tamaño y le pongo (float) delante
para que me muestre los decimales.

Búsqueda secuencial en arreglos

Se trata de búsqueda de datos en arreglos, esta se lleva a cabo con whiles,ifs y contadores.
Un ejemplo de búsqueda secuencial sería esta:
En este caso creamos un arreglo dentro de la función principal, y creamos la variable ‘i’ que
nos servirá de contador,una variable llamada dato, que será lo que tendrá que buscar, además
de una variable llamada “band” que vale ‘F’, porque para estos casos donde se comprueba
algo, se le suelen apodar bandera o flag.
El dato ya lo establecemos previamente, y ya empezamos con la búsqueda
secuencial,iniciando el contador en 0.
Creamos un while que tendrá por condición que “band” sea ‘F’ Y que el contador ‘i’ sea
menor que 5,cosa que siempre se debe cumplir porque solo tengo 5 números.
Dentro abro un if y establezco que si el arreglo a[i] con tamaño i es igual al dato que la
bandera pase a ser 0. ES decir, imaginemos que empezamos, i sería 0, entonces el programa
haría; banda es igual a F e i es menor que 5, entro al if, el arreglo con tamaño 0, o sea, la
posición 0, que en este caso es 3, debe ser igual a la variable dato, pero se encuentra con que
no es igual así que bandera sigue siendo F y no entra en el if, se le suma uno más al contador
y vuelve hacer lo mismo con la posición 1, pero en esta ocasión se encuentra con que si se
cumple el if, por tanto bandera e V, y ya pararía el ciclo porque bandera seria V y no F.
Más tarde termino este algoritmo con otro if donde escribo la frase correspondiente en casa
caso.
Una forma un poco diferente de abordarlo sería crear una variable llamada posición que sirva
como contador, para mostrar la posición real del ordenador, y cuente desde el 0.

Búsqueda binaria
Es otra forma de buscar datos en arreglos pero más efectiva y para datos que estén en orden.
La diferencia es que aquí crea otras variables, como sup, inf y mitad , para ir almacenando el
número en mitad y vaya comparando con el dato. En este caso para terminar con el ciclo
tenemos que escribir break para que no haya un ciclo infinito.
ESTRUCTURAS
Son un tipo de datos complejo, puede almacenar un numero ordenado de variables, como un
bloque.
A diferencia de los arreglos, en las estructuras son variables independientes.
Ej:
Struct pokemon{
Char nombre[50];
Char tipo[50];
Float peso;
Char genero;
}pokemon1,pokemon2,pokemon3;

La parte final se puede hacer de otra forma, dentro de la estructura principal:

Struct pokemon pokemon1,pokemon2,pokemon3;

Es de decir que en una estructura creamos variables de distintos tipos pero también unas
variables principales que me indican cuantas veces voy a usar la estructura.

SIEMPRE declarar estructuras antes de la función principal.

En este caso solo creamos una variable estructura(pokemon1) y enseguida le pedimos los
datos al usuario, lo diferente es que para introducir datos de texto ponemos <-
cin.getline(nombredelaestructura.nombrevariable,tamaño);
Sin embargo cuando introduzco solo números escribo <-
cin>>nombreestructura.nombrevariable;
SIEMPRE poner le nombre de la variable estructura.
Estructuras anidadas
Se trata de una estructura dentro de otra estructura. En ellas escribo struct nombreestructura
y el nuevo nombre de mi estructura, un ; y ya puedo crear más variables sin necesidad de
abrir llaves.
Además puedo hacer arreglos de mi estructura, escribiendo el nombre de la estructura y entre
corchetes el número de arreglos que quiero. Por ejemplo: empleado[2].
FUNCIONES
Una función realiza una tarea concreta y es diseñada, implementada y depurada de forma
independiente al código.
La sintaxis básica para la definición de una función es:
Tipo nombre(tipo var1,tipovar2,…,tipovarn){
Conjunto de instrucciones;
}
Por ejemplo si quiero retornar un valor entero pongo int y ya creo mis variables.
Las funciones tipo void no retornan nada.

Plantillas de función
Las plantillas de función me servirán cuando quiera generar un dato de tipo genérico.

Para la plantilla de función se escribe “template <class nombre>”, en este caso le asignamos
el nombre “TIPOD”. Una vez declarado el template, se puede escribir la función void, y la
declaramos como siempre, la única diferencia es que en lugar de poner el tipo de dato
escribimos el nombre de la calse del template “TIPOD” y ya el nombre que le queramos dar
al dato.
Las funciones siempre se declaran antes de la función principal, y se expresan después de la
función principal, y para ejecutarla solo tengo que escribir el nombre de la función y entre
paréntesis,el dato que quiero introducir.
EJERCICIO
Escribe una plantilla de función llamada máximo(), que devuelva el valor máximo
de tres argumentos, que se transmitan a la función cuando sea llamada.Suponga
que los tres argumentos sean del mismo tipo de dato.
Para resolver este ejercicio he creado una plantilla de función, cuya clase se llama TIPOD.
Después he creado la función máximo tal como me piden pero claro, me pide que la función
devuelva un valor así que no puede ser void, pero tampoco puede ser entero o flotante
porque no sé de que tipo de dato se trata, para resolver eso pongo el mismo nombre de la
clase como tipo de dato,para crear una función que retorne, sin especificar el tipo, gracias a
mi comodín de la plantilla. Después de la función principal determino mi función máximo y
creo una escalera de ifs comparando los datos y escribiendo en cada caso cual sería mayor, y
devolviendo como me pide el ejercicio el dato mayor. Una vez terminada la función máximo
vamos a la principal y declaramos variables de distinto tipo, números enteros, flotantes,
dobles, y una cadena de texto, y tras declararlas y apodría utilizar mi función, no obstante,
cuando se trata de funciones que retornan valores no puedo escribir :
máximo(num1,num2,num3); porque esto solo sirve para funciones tipo void. En el caso de
querer ejecutar mi función debo llamarla con un “cout” o con una variable que cree
previamente, por ejemplo en cada tipo d edato creo una variable llamada
maxnum,maxflot,maxdob,maxstring y luego pongo:
Maxnum = máximo(num1,num2,num3);
O en el caso que se nos presenta abajo, con un simple cout:
Cout<<máximo(num1,num2,num3);
PASO DE PARÁMETROS POR REFERENCIA:
Arriba tenemos dos funciones tipo void que crean valores enteros ‘x’ y que después igualan a
3 dentro de la función, sin embargo cuando yo creo una variable entera en la función
principal, le doy de valor 17 y ejecuto las dos funciones en a, me desplazan valores distintos:
17 y 3.
¿Por qué ocurre esto? Simplemente en la función void modificado (int &x) añadimos algo
nuevo y es el carácter “&”, esto nos indica que no se crea una nueva variable si no que nos
vamos al espacio designado en memoria para esa variable, en este caso la ‘a’, la función se
dirige al espacio en memoria a que pone 17 y después lo corrige y pone que a vale 3. En la
segunda función creamos el espacio llamado x, además de tener el de a y le cambiamos el
valor de x a 3.
Es decir, en resumen, en la que utilizamos ‘&’ le cambiamos el valor y en la otra no, porque
una va al espacio donde se encuentra, y en la otra crea otro espacio.
PARÁMETROS EN VECTOR
Se trata de introducir arreglos o vectores en las funciones. La forma de escribir estas sería:
void nombreFuncion (tipoDato nombreArreglo[],tipoDato tamañoArreglo);
Es importante que los corchetes estén vacíos. Después de solo haría falta declarar en la
función principal el contenido del arreglo y el tamaño. Este sería un ejemplo:
Se hacen 2 funciones porque las funciones deben encargarse solo de un proceso.

PASO DE PARÁMETROS TIPO MATRIZ

Es un proceso parecido a los vectores, pero con matrices. Primero creamos la matriz en la
función principal,con el número de filas y columnas como constantes, y después fuera de la
función principal la declaramos con la matriz con el número max de columnas
OBLIGATORIO, y dos variables más para el numero de filas y col.
Para operar con sus elementos o pedir los datos de estos se abren dos bucles for.
Importnate los saltos de línea antes de que termine el bucle for de las filas para que se
imprima con el aspecto de la matriz.
DECIR SI UNA MATRIZ ES SIMÉTRICA
Una matriz es simétrica cuando es igual a su matriz transpuesta, es decir si intercambias las
filas y columnas, y además si tiene el mismo número de filas y de columnas.

PARÁMETROS CON ESTRUCTURAS

A la hora de implementar estructuras en funciones, debemos declarar la estrcutura primero
antes de nuestra función principal y de nuestras funciones adicionales.
Tomaremos como base el ejercicio de abajo, donde me piden diseñar un programa que sume
dos numeros complejos, que son aquellos que tienen parte real e imaginaria como z = 2+3i;
Creamos la estructura complejo y creamos dos variables flotantes llamadas real e imaginaria,
y dos variables de estructura,z1 y z2.
Se crea la función void pedirDatos y después una función que retorne la suma, pero como se
trata de una estructura la función tiene que ser del tipo estrcutura, ¿eso como se consigue?
Llamándola igual que nuestra estructura;complejo.
Entonces quedaría tal que así; complejo suma(complejo,complejo);
Porque toma variables dentro de complejo.
Más tarde creamos otra función tipo void que me muestre el resultado,con una varivale de
complejo también porque el resultado lo sacará de allí.
Ya lo que queda será desarrollar las funciones y escribirlas en la principal.
Cabe destacar la función que retorna(suma),porque se crea una variable de la estructura
complejo llamada x, todo esto para ejecutar esa función en lugar de escribir cout.
RECURSIVIDAD
Las funciones recursivas son aquellas que se llaman así mismas. Como ejemplo tomaremos
un ejercicio que nos pide diseñar un programa que haga el factorial de un numero. ¿Qué era
el factorial de un número? Era la multiplicación consecutiva del mismo por sus anteriores, ej:
3! = 3*2*1
Pero también es : 3! = 3*2!
Así surge la fórmula, tomando una función n ->
Factorial(n)
n=n*factorial(n-1);

¿Por qué es una función recursiva? Porque dentro de la función factorial se vuelve a llamara
a sí misma de nuevo.
ARREGLOS Y PUNTEROS
ARREGLOS DINÁMICOS
Se trata de crear arreglos en los que solo se reservan los bytes solicitados. Por ejemplo, creo
un arreglo pero no sé cuantos datos va a introducir el usuario, entonces utilizo el operador
“new” para reservar solo los necesarios, y el operador “delete” para borra esos bytes
reservados cuando haya finalizado. Para utilizar estos operadores es necesario escribir la
librería; #include <stdlib.h>

Suele utili
zarse con punteros.
Ejercicio contar vocales

MATRICES DINÁMICAS CON PUNTEROS

Las matrices dinámicas son bastante parecidos a los arreglos dinámicos, se reservan los
espacios necesarios para la matriz con new y delete. Pero al tratarse de matrices usaremos 2
punteros, uno para las filas y otro para las columnas, esto s etraslada al código declarando el
puntero con 2 asteriscos. En el caso de abajo, le pedimos al usuario que indique el numero de
filas y columnas, y que vaya haciendo la matriz , para ello tenemos que crear las variables
globales de : **puntero_matriz,nFilas y nCol. Dentro de la función pedir datos resevamos los
espacios en memoria de la siguiente forma:
Puntero_matriz = new int*[nFilas];
For(int i=0;i<nFilas;i++){
Puntero_matriz[i]= new int[nCol]; }
¿Que estamos haciendo? Primero reservamos espacio para als filas, igualando el puntero y
utilizando el operador new, le añadimos un * al numero de filas porque va a ser un puntero
pero no al de columnas porque está dentro de un bucle. Abrimos bucle for, porque el
puntero_matriz ya lo hems utilizad, entonces abrimos el bucle for para utilizar el espacio en
columnas, con puntero_matriz[i].
Una vez que se han reservado los espacios, se piden todos los dtaos con un bucle for con dos
contadores, i para filas, y j para columnas, pero al tratarse de un ejercicio con punteros se
expresa de forma diferente, en lugar de escribir esto: puntero_matriz[i][j];
Se escribe esto: (*(*(puntero_matriz+i)+j));
Por último se muestra la matriz en otra función, con un bucle for. (importante el salto de
línea y el espacio para que parezca una matriz)
En la función principal se ejecutan las funciones y se borran todos los espacios reservados
con un dete. TENER EN CUENTA QUE HAY QUE BORRAR EL ESPACIO DE FILAS Y
COLUMNAS. Para borrar las filas se escribe puntero_matriz pero para borrar las columnas
hay que abrir un bucle for otra vez como habíamos hecho para reservarlo.
En resumen: El puntero debe llevar ** y se deben resevar los espacios de forma
diferente(bucle for) cuando tengo más de un puntero.
PUNTEROS CON ESTRUCTURAS
Con las estructuras es lo mismo que con arreglos, se iguala el puntero a la posición en
memoria de una variable pero con estructuras se crea la variable después de la variable
estructura. A la hora de introducir datos se escribe el puntero y se pone un flecha ->.
PILAS
Son estructuras de datos de entradas ordenadas, que solo pueden ser añadidas y eliminadas
por un extremo llamado cima. Las operaciones comunes en una pila son: añadir(push) y
quitar(pop). Sale el último dato que entró.
¿Cuál es su forma?
Se escriben los datos en forma de NODOS, ej:
dato
*siguiente
Eso es un nodo, son estructuras en las que se dividen las pilas.
En ellas se introduce un dato y se indica el dato que se encuentra abajo con un puntero.
Todo esto son estructuras:
Struct Nodos{
Int dato;
Nodos *siguiente};
INSERTAR ELEMENTOS EN LA PILA
Hay que seguir 4 pasos:
1.Reservar el espacio para el nodo, con new.
2.Darle valor dentro del nodo(dato).
3.Cargar el puntero pila dentro del nodo(*siguiente).
4.Asignar otro apodo a la pila.
Ej:
1.Reservar el espacio en memoria.
Pila = NULL;
PARA INDICAR QUE EL PUNTERO ESTÁ VACÍO PORQUE ES EL PRIMERO.
Reservamos el espacio para el nodo con new y un nuevo puntero:
Nodo *nuevo_nodo=new Nodo();
2.Agregar valor al dato
Nuevo_nodo->dato=10;
3.Puntero *siguiente
Nuevo_nodo->siguiente = pila;
4.Asignar nuevo apodo a pila.
Pila= nuevo_nodo;
Void agregarPila(Nodo *&nuevo_nodo,int n){
Nodo *nuevo_nodo = new Nodo(); //Reservamos espacio en memoria
nuevo_nodo ->dato=n; //Le damos valor al dato
nuevo_nodo->siguiente=pila; //Asignamos el puntero;
pila= nuevo_nodo; }
ELIMINAR ELEMENTOS DE UNA PILA
1.Crear una variable *aux tipo Nodo.
2.Igualar n a aux->dato
3. Igualar pila a aux-> siguiente.
4.Borrar aux.

Void sacarPila(Nodo *&pila,int &n){

Nodo *aux=pila;
N=aux->dato;
Pila=aux->siguiente;
Delete aux;
Siempre se llevan a cabo los mismos procesos, se crea una función para agregar elementos
en la que se cree otro puntero y se reserve el espacio del nodo, se asigna valor al dato, se
asigna valor al puntero siguiente, y se iguala el puntero pila con el nuevo puntero de antes.
Para eliminar elementos se crea el puntero *aux, y se iguala a pila,después se iguala la
variable del dato al dato en aux,se iguala la pila al puntero siguiente en aux, y por último se
borra aux. NO OLVIDAR escribir la variable del dato, en este caso ‘n’ con un ‘&’ en la
función de eliminar elementos, para que vaya al espacio en memoria.
COLAS
Se añaden y eliminan datos por dos extremos diferentes, es decir que el primer dato en entrar
es el primero en salir, al contrario que en las pilas, va en orden.
Se siguen 3 pasos para insertar:
1.Asignar espacio al nodo.
2.Darle valor al dato
3.Asignar los punteros frente y fin
Para eliminar datos:
1.Obtener el valor del nodo.
2.Crear un nodo aux y asignarle el frente de la cola.
3.Eliminar el nodo del frente de la cola.
Ejercicio crea un programa con colas que admita los datos de los clientes de un banco.
El comando system(“pause”) sirve para hacer una pausa a la hora de imprimir los datos, y el
comando system(“cls”) sirve para resetear la pantalla y que no se sature con un nuevo menú.
LISTAS
Una lista enlazada consta de un número de nodos, con dos componentes, campos, un enlace
al siguiente nodo, y un valor.
Es una estructura de datos dinámica, no tienes por que definir el numero de estructuras que
vaya a tener.
Hay 4 tipos de listas enlazadas:
1.Listas simplemente enlazadas.
2.Listas doblemente enlazadas.
3.Listas circular simplemente enlazadas.
4.Lstas circular doblemente enlazadas.

1.Listas simplemente enlazadas

Estas contienen un único enlace que apunta al nodo siguiente. Es eficiente en recorridos
directos(adelante).

2.Listas doblemente enlazadas.

Estas contienen dos enlaces, uno que señala al nodo del que proviene, y otro que señala el
siguiente. ES eficiente en recorridos tanto directos como inversos.

3.Listas circular simplemente enlazadas.

Listas simplemente enlazadas donde el ultimo elemento de la lista se enlaza al primer
elemento.

4.Listas circular doblemente enlazadas.

Listas doblemente enlazadas donde el ultimo nodo de la lista se enlaza al primero y el
primero al ultimo.
INSERTAR ELEMENTOS A UN LISTA
Hay que seguir 4 pasos:
1.Crear un nuevo nodo
2.Asignar al nuevo nodo_nodo->dato el elemento que queramos introducir
3.Crear dos nodos auxiliares y asignar al lista a uno de ellos
4.Añadir el elemento a la lista
MOSTRAR ELEMENTOS DE LA LISTA
1.Crear un nuevo nodo(actual)
2.Igualar a lista
3.Recorrer la lista de inicio a fin
La diferencia es que, para mostrar los elementos de un nodo, el puntero se manda sin paso
por parámetro (&). Además no eliminamos los elementos porque en ningún caso escribimos
delete, solo mostramos.
BUSCAR ELEMENTOS

ELIMINAR ELEMENTOS EN LISTAS ENLAZADAS

Como eliminar un elemento
1.Preguntar si la lista esta vacia
2.Crear *aux_borrar y *anterior=NULL
3.Igualar *aux_borrar a lista para que indique el inicio
4.Recorrer la lista
5.Eliminar el elemento

En primer lugar se pregunta si la lista está vacía con un condicional(lista!=NULL) y s la lista

no está vacia, que es la condición necesaria para borrar un elemento, se crean dos punteros
tipo nodo (*aux_borrar y *anterior) y a *anterior lo igualamos a NULL, y *aux_borra a lista.
Después vamos a recorrer la lista en busca del dato introducido que queremos borrar,
primero escribimos el caso en que el elemento que se inspecciona no sea el que necesitemos
borrar, para ello abrimos un while y le ponemos de condición que aux_borrar sea distinto de
NULL, que debe cumplirse porque aux_borrar lo hemos igualado a lista y ya hemos
comrpobado que lista no está vacia.Además que el dato de aux_borrar sea distinto de n
porque estamos en la situación de que el dato no sea el que queramos eliminar, entonces se
repite un bucle while donde anterior se iguala a aux_borrar y aux_borrar al aiguiente de
aux_borrar para que avance de posición.
Esto se repetirá siempre y cuando no sea el dato que buscamos. A continuación vemos el
caso en que el elemento no ha sido encontrado en toda la lista, con un condicional
(if(aux_borrar==NULL)) es decir que la lista ha llegado al final, se escribe que el elemento
no ha sido encontrado. Ya hemos visto el caso en que el elemento no sea el que buscamos y
el caso en que no se encuentra en toda la lista pero, ¿y si se encuentra? Para ello hay dos
condicionales mas, si el elemento que se busca es el primero o se encuentra más adelante.
Para el primer caso; se escribe el condicional de que anterior sea igual a NULL, porque
entonces no habrá entrado al while, y lista se iguala al siguiente de lista para que avance y se
elimina aux_borrar. Ahora para el último caso, en que el elemento se encuentra mas adelante,
escribimos que el siguiente de anterior sea igual al siguiente de aux_borrar, y que elimine
aux_borrar.

Eliminar todos los elementos de la lista

1.Crear un nodo *aux e igualarlo a lista.

2.Guardar el dato que queramos eliminar en *aux.
3.Pasar lista al siguiente nodo.
4.Eliminar nodo.

Como agregar elementos al final de una lista

No necesariamente el cliente quiere que la lista esté ordenada, los elementos se pueden
añadir al final en lugar de comprobar si el dato es mayor.
Primero se comprueba que la lista esté vacia y luego recorremos la lista e igualamos aux-
>siguiente a nuevo nodo para que se añada al final.

PROGRAMACIÓN ORIENTADA A OBJETOS

Ventajas:
 Permite reutilizar el código
 Es más fácil de entender
 Agiliza el desarrollo de software
 Facilita el trabajo en equipo
Para la programación orientada a objetos se crean clases, un archivo separado con las
variables, que ahora se van a llamar propiedades, y las funciones, que ahora se van a llamar
métodos.
Lo de arriba, se trata de herencia de propiedades, es decir yo puedo hacer que una clase tenga
propiedades de otra, esto se hace para hacer distinciones de clases. Todo esto con arreglos.
Las clases necesitan un nivel de protección , es decir que sean public,static o private por
ejemplo para poder acceder a ellas con cualquier archivo o no. Esto se indica después de
declarar la clase. Ej: public:
Los objetos son lo que nos ayuda utilizar las clases.
Las herencias son para no repetir clases todo el rato.
La creación de la clase tiene 3 partes:
1.Declarar la clase
Creamos la clase y se declaran las variables o propiedades separadas a los métodos, donde
escribiré mi constructor, que se trata de una función que permite que funcione la clase, y más
tarde otra función que quiera incluir.

2.Inicializar el constructor
Para inicializar el constructor, igualamos la clase al constructor, y en esta ocasión en lugar de
poner solo los tipos de variable, las nombro de nuevo, para igualar las variables ya creadas
con los nuevos nombres del constructor.
Por último escribimos la función que hayamos incluido y le indicamos que acci´n llevar a
cabo, como mostrar un mensaje.
3.Declarar objetos
Ya tenemos las variables, ahora solo falta darles valor, creando un objeto, por ejemplo
pokemon1 , y entre paréntesis colocamos los datos en orden.
Para ver que funciona escribimos el nombre del objeto,un “.” Y el nombre de la función que
he creado y que me debe mostrar el mensaje.
Clase hija
Se repite el mismo proceso pero esta vez se iguala a la clase madre, a la hora de declararla
como a la hora de inicializarla para no repetir las mismas variables.
Polimorfismos
Se trata de invocar métodos de clases sin realizar la misma acción.

En lugar de crear otra función, volvemos a utilizar la misma, la diferencia es que cuando
inicializamos la función tenemos que poner el nombre de la función padre e igualarla a la
función, por ejemplo pokemon::Saludo();
Pero hay otras formas de polimorfismo, por ejemplo en algunos casos para indicar que una
función va a tener polimorfismo se escribe la palabra virtual,pero solo en la clase padre. Ej:
virtual void Saludo();
Constructores
Los constructores son necesarios, pero…¿Solo podemos tener uno? La respuesta es no,
podemos tener tantos constructores como queramos, para introducir por ejemplo los atributos
de forma diferente.
En este caso creamos un constructor que permita que introduzcamos el tiempo solo en
segundos, y lo muestre en horas, minutos y segundos.

Destructores
Sirven para destruir objetos y se escriben así: ~nombreClase();
Y ya estaría creado nuestro destructor sin necesidad de escribir nada más.
Getters y Setters
Setters
Son funciones que me permiten modificar atributos que están encapsulados en una clase
privada, en el momento que quiera <- void setClase(tipoDato);
Después tendré que inicializarla como los constructores, ya que es una función.
Void Clase::setClase(tipoDato _variable){
Variable = _variable;
}
Y ya teniendo esa función puedo cambiar el valor de mis variables siempre que quiera
creando un objeto tal que así:
Clase1.setClase(a,b); por ejemplo, todo esto en mi función principal.
Getters
Son funciones que me envían un dato que está encapsulado en una clase privada, es decir me
lo consigue.
Se declara junto a los métodos y se pone <- pongamos que quiero la variable x y que esta en
una letra char getClasex();
Se pone el tipo de variable que quiero fuera, y ya después el get y el nombre de la calse y la
variable.
Se inicializa poniendo <- int Clase::getClasex(){
Return x;
}
Y ya en la función principal se escribe <- clase1.getClasex();