Listas doblemente enlazadas

Una lista doblemente enlazada (DLL) es un tipo especial de lista enlazada en la que cada
El nodo contiene un puntero al nodo anterior y al siguiente de la lista enlazada. Ver ejercicio de listas dobles.c
Listas circularmente doblemente enlazadas ver ejercicio lista circular.c

 Una lista circular doblemente enlazada se define como una lista circular
enlazada en la que cada nodo tiene dos enlaces que lo conectan con el
nodo anterior y el siguiente.
 La característica principal de una lista circular doblemente enlazada es que
tiene un diseño circular.
 Cada nodo en una lista circular doblemente enlazada tiene dos punteros:
uno que apunta al nodo anterior y el otro al nodo posterior.
Listas circularmente doblemente enlazadas

Construyendo a partir de múltiples fuentes

Los compiladores de C pueden compilar varios archivos fuente
en un ejecutable.
Para cada declaración debe haber una definición en uno de los archivos compilados.
Las bibliotecas desempeñan un papel fundamental.
El control del proceso lo realiza el enlazador gcc -o nombre archivo1.c archivo2.c archivo3.c

Enlace
 Archivo de encabezado de lista vinculada

Una lista enlazada simple está enlazada desde estructuras de nodos cuyo tamaño puede crecer según
sea necesario. Agregar más elementos a la lista solo hará que crezca y eliminar elementos hará que se
reduzca.
Struct 11_node
Se utiliza para contener la información de un nodo de una lista simplemente vinculada.
Declaración de función (rutinas)
push_front: agrega un elemento al principio
push_back: agrega un elemento al final
dispose_list: elimina todos los elementos
Importación de definición mediante #include

Compilar lista enlazada de múltiples fuentes

• Cree un proyecto con su IDE, agregue todos los archivos, incluido el archivo de encabezado, y luego
compílelo y ejecútelo.
• tu o
• Compilar: gcc -Wall -o use_linked_list linked_list.c use_linked_list.c
• Ejecutar: ./use_linked_list -La opción Muro habilita todos los mensajes de advertencia.
• Cygwin
• Cygwin es un entorno similar a Unix y una interfaz de línea de comandos para Microsoft Windows.
• Cygwin proporciona integración nativa de aplicaciones, datos y otros recursos del sistema basados ​en
Windows con aplicaciones, herramientas de software y datos del entorno tipo Unix.
 Por lo tanto, es posible iniciar aplicaciones de Windows desde el entorno Cygwin, así como utilizar
herramientas y aplicaciones de Cygwin dentro del contexto operativo de Windows.
Instalar Cygwin en Windows I
u Vaya a https://cygwin.com/install.html, descargue setup-x86_64.exe e instálelo
u Durante la instalación, agregue gdb, gcc-core y haga que aparezcan en Devel
 Instalar Cygwin en Windows II

Una vez instalado en C:/cygwin64, tendrá un entorno similar a Unix.

u Puedes usarlo para compilar y depurar tu código usando gcc y gdb.
Organizar un proyecto C
u En grandes proyectos de programación en C, debe manejar una gran cantidad de archivos C.
u Es una buena práctica gestionar grupos de archivos C de forma organizada. Será mucho más fácil de diseñar,
implementar y mantener.
u El punto clave es separar las declaraciones y definiciones de funciones en varios archivos.
Ejemplo de uso de varios archivos
Supongamos que tenemos dos funciones add_int() y
multi_int(), La mejor práctica es colocar las declaraciones en
archivos de encabezado: int_header.h #Prototipos de add_int()
y multi_int(). Luego coloque las definiciones en archivos C
separados: add_int.c #Definición de la función add_int().
multi_int.c #Definición de la función multi_int(). Finalmente
invocando las funciones en la función principal.
Hacer utilidad
u La utilidad make se puede utilizar para gestionar eficazmente la compilación, vincular varios archivos y producir el código
ejecutable.
u Una utilidad make determina automáticamente qué partes de un programa grande deben recompilarse y genera los
comandos necesarios para recompilarlas.
u En la práctica, el comando make compila automáticamente diferentes partes del programa y crea un ejecutable final.
Archivo Make
u Para usar make, debe escribir un script llamado makefile que describa las relaciones entre los archivos en su programa y
defina los comandos que definen cómo actualizar cada archivo.
u En un programa, normalmente el archivo ejecutable se actualiza a partir de archivos objeto, que a su vez se crean
compilando archivos fuente.
u Un archivo MAKE consta de tres partes.
u Destinos: nombres de los archivos que se crearán o actualizarán después
ejecutando make.
u Dependencias: Nombres de los archivos (separados por espacios) a partir de los cuales se construye el destino.
u Los comandos: reglas que describen cómo crear o actualizar el objetivo cuando cambian las dependencias.
Estructura de un archivo MAKE
u La estructura de un archivo MAKE tiene el siguiente aspecto:

Un archivo MAKE también puede contener definiciones de variables e inclusión de otros archivos MAKE.
Ejemplo de archivo MAKE
u Para los archivos definidos anteriormente en el ejemplo, podemos crear un archivo MAKE como: todos:
gcc -o principal principal.c add_int.c multi_int.c
u Cuando escriba make en la terminal, se generará el ejecutable principal. hacer
u El comando make invocará el objetivo "todos", tomando el primer objetivo como predeterminado.
Reglas del archivo MAKE I
u One Makefile tiene varios conjuntos de reglas.
u La primera regla es la predeterminada y establece cómo se
creará el ejecutable final (el destino) a partir de archivos objeto
aún no creados (dependencias).
Reglas del archivo MAKE II
La sintaxis del Makefile en este caso es:
EJECUTABLE: Archivo de objeto 1, Archivo de objeto 2
Comandos <TAB>
Archivo de objeto 1: archivo fuente 1, archivo fuente 2
Comandos <TAB>
Archivo objeto 2: archivo fuente 2
Comandos <TAB>
Comentarios y macros
u Comentarios
u Cualquier línea que comience con # es un comentario.
u Formato de macro
tu nombre = datos
u Ejemplo: OBJ=linked_list.o use_linked_list.o Se puede
denominar $(OBJ) de ahora en adelante.
Makefile – Reglas explícitas
u Reglas explícitas
u destino: fuente1 [fuente2] [fuente3] comando1 [comando2] [comando3]
tu objetivo es el nombre del archivo a crear
u El archivo se crea desde fuente1 (y fuente2, ...) use_linked_list: use_linked_list.o linked_list.o gcc -o use_linked_list
use_linked_list.o
lista_vinculada.o
Archivo Make IV
u Reglas explícitas objetivo: comando
u Los comandos se ejecutan incondicionalmente cada vez que se ejecuta make. Los comandos se pueden omitir, luego se usan
reglas integradas para determinar qué hacer.
use_linked_list.o: linked_list.h use_linked_list.c
u Cree use_linked_list.o desde linked_list.h y use_linked_list.c usando la regla de sufijo estándar para llegar a use_linked_list.o
desde linked_list.c
u $(CC) $(CFLAGS) -c archivo.c
Ejemplo – hacer yo
u Supongamos que nuestro objetivo es crear un ejecutable que imprima el mensaje "Más información sobre Makefiles".
u Seguimos los siguientes pasos:
1. Cree un directorio llamado Prueba.
2. Cree tres archivos fuente main.c, text.c y text.h:
Ejemplo – principal.c
main.c - es el archivo con la función principal (int main) que llama a una función desde otro archivo.
Ejemplo: texto.c
text.c: es el archivo con el que desea imprimir "¡Más información sobre Makefiles!".
Ejemplo: texto.h
u text.h: es el archivo de encabezado con declaraciones para las
funciones.
u El encabezado se incluye en ambos archivos c con el
argumento #include, que tiene el mismo propósito que copiar y
pegar el contenido del encabezado.
Ejemplo: archivo Make I
u Creemos un Makefile en el mismo directorio que otros archivos. En el archivo, definimos un nuevo ejecutable como
destino llamado my_app.
u Agregamos los archivos objeto main.o y text.o como dependencias. Este comando make vuelve a compilar el destino cada
vez que cambian los archivos de objeto.
u En la siguiente línea, presionamos TAB e invocamos el compilador gcc para los archivos objeto.
u Agregue el indicador -o y nombre el objetivo my_app.
Ejemplo: Makefile II
A continuación, indique al Makefile cómo crear main.o:

1. Establezca main.o como objetivo.

2. Escriba main.c como dependencia. main.c sirve para crear y
actualizar main.o.
3. Escriba el siguiente comando para actualizar main.o cada vez
que cambie main.c: gcc -c main.c
4. Agregue el indicador -c para indicarle al Makefile que no cree
un nuevo ejecutable sino que solo lea el código y compile el
archivo objeto.

Ejemplo: Makefile III

u Para crear text.o, establezca ese archivo como destino y agregue text.c y text.h como dependencias.
u Sin embargo, el comando gcc solo compila el archivo text.c, ya que los encabezados nunca se compilan:
 Guarde el Makefile y escriba make en la terminal.

Ejecutando Makefile
u El comando make crea dos archivos objeto (main.o y text.o) y
el ejecutable (my_app).
u Ejecutando el archivo my_app
$ ./my_app $ ¡Aprenda sobre los archivos MAKE!
Pregunta de ejercicio
Pregunta 1
Repita el ejercicio cubierto en las diapositivas anteriores para imprimir "¿Dónde
estoy?".