¿Qué es la biblioteca estática y la biblioteca dinámica? ¿Cómo generar la biblioteca estática y dinámica?

Cómo generar biblioteca estática y dinámica (Libaries compartidas) Usar Makefile
En primer lugar me gustaría darle un poco de introducción sobre biblioteca estática y dinámica

La diferencia entre las bibliotecas estáticas y dinámicas se puede. visto como la forma de llegar a trabajar. Usted puede conducir su coche o se puede coger un tren. Conduciendo su propio coche es un poco como una biblioteca estática. Tomar el tren es un poco como una biblioteca compartida.

Cuando usted conduce su coche todo lo que necesitas es el coche. Cuando usted toma el tren por lo general hay más de un vagón de tren en sí mismo. Por lo general, hay una locomotora, y luego algunos vehículos de pasajeros, y tal vez un furgón de cola para arrancar. Mientras que todos los coches están trabajando en armonía continúa para llegar al trabajo. Si cualquiera de los coches tiene un problema de sus posibilidades de llegar al trabajo disminuyen.

Al compilar un programa con bibliotecas estáticas estáticamente bibliotecas vinculadas se enlazan con el ejecutable final por el enlazador. Esto aumenta el tamaño del ejecutable. Del mismo modo, cuando una biblioteca se debe actualizar tendrás que compilar la nueva biblioteca y luego vuelva a compilar la aplicación para tomar ventaja de la nueva biblioteca. Ok, así que ¿por qué tenemos bibliotecas estáticas entonces? Bueno, si usted está arrancando el sistema en modo de mantenimiento bibliotecas estáticas pueden ser beneficiosos.

Lo biblioteca estática?

bibliotecas estáticas son simplemente una colección de archivos de objetos ordinarios, convencionalmente, bibliotecas estáticas terminan con el sufijo «.». Esta colección se ha creado usando el programa (archivador) ar.

En la vinculación estática, el tamaño del ejecutable es mayor que en la vinculación dinámica, ya que el código de la biblioteca se almacena dentro del ejecutable en lugar de en archivos independientes
bibliotecas estáticas permiten a los usuarios vincular a los programas sin tener que recompilar su código, ahorrando tiempo de recompilación. Tenga en cuenta que el tiempo de recompilación es menos importante dada compiladores más rápidos de hoy en día, así que eso no es tan fuerte como lo era antes. Bibliotecas estáticas son a menudo útiles para los desarrolladores si desean permitir a los programadores un enlace a la biblioteca, pero no quieren dar el código fuente de la biblioteca.

Para crear una biblioteca estática, o añadir archivos de objetos adicionales a una biblioteca estática existente, utilice un comando como el siguiente:
     ar rcs library.A File1.o   File2.o     
     o     
     ar-qcs library.A File1.o   File2.o             

Makefile para generar biblioteca estática


Echemos pequeño ejemplo, supongamos que hay dos archivos y generar la biblioteca estática y vincularlo a un archivo principal.

archivo1.c

int fun1 (int a, int b)
{
int c;

/ * agregar las dos variables * /
c = a + b;
(c);
}

file2.c

int fun2 (int a, int b)
{
int c;

/ * agregar las dos variables * /
c = a + b;
return (c);
}
Por encima hay dos archivos, aquí se puede encontrar el Makefile para generar la biblioteca utilizando file1.o y file2.o

Makefile para generar MyLibrary.a usando file1.o y file2.o

CC = gcc />
CFLAGS =-g-Wall

#. una extensión de biblioteca estática
# modo de extensión para la biblioteca dinámica
# paso 1:
# va al paso 2:

todo: libMylibrary.a

# paso 3:
# Vuelva al paso 2
# declare esta OBJS antes de su uso, aquí OBJS es una variable.

OBJS = $ (PWD) / archivo1 . o
$ ( PWD) / file2.o

# paso 2:

libMylibrary. a : $ (OBJS)
; ar-qcs libMylibrary.a $ (OBJS)

# paso 4:
# Volver al paso 3

$ (PWD) /% d:% c
limpia:
rm-f * . o
rm .-f * a

Cómo vincular esta biblioteca para el archivo de función principal para conseguir exe

mainFile.c

# include
# include

int fun1 extern (int a, int b);
extern int fun2 (int a , int b);

int main ()
{

printf (» El valor de Función1:% d «, fun1 (4,5));
printf («El valor de Función2:% d», fun2 (6,7));

return 0;
}

Makefile vincula biblioteca y generar el test.exe

CC = gcc

CFLAGS =-g-Wall

# una extensión de la biblioteca estática
#.. por lo que la extensión de la biblioteca dinámica
# paso 1:
# va al paso 2:

todo: prueba />

# paso 3:
# Vuelva al paso 2

$ (CC) $ (CFLAGS) $ (OBJS) $ (LIBDIR) $ (LIBLOG) – o test.exe

# paso 4:
# Volver al paso 3 />

# Para biblioteca estática, siempre incluyen LIB DIR

# Este es
Obligatorio LIBDIR =-L. /
= LIBLOG-lMylibrary

limpia:
rm-f * o
rm-f *. a

Punto Importante:
Cuando quiera que esté la vinculación de la biblioteca estática para mainFile, es obligatorio mencionar el LIBDIR (donde la biblioteca está presente) opción con-L. Estos $ (LIBDIR) debe incluirse cuando se genera el archivo exe

Nota:.. Cómo ejecutar su propio makefile, supongamos que tengo makefile como Makefile_org, a continuación, ejecuta utilizando el mandato abajo
make-f Makefile_org
limpia:

Tiempo real Ejemplo.
Supongamos que hay tres módulos BMODULE , , . es tener dependencia de otros dos módulos es decir, , DMODULE .
Por lo tanto, primero compilar y y vincular su .. objetos a para generar el exe

aquí DMODULE genera la biblioteca estática y cModule genera los archivos objeto (o de )

-bash-3.2 # mkdir mreddya
-bash-3.2 # mkdir MAKEFILE_EXERCISE

crear directorios bajo / root / mreddya / MAKEFILE_EXERCISE / , como se muestra a continuación.

-bash-3.2 # mkdir BMODULE
-bash-3.2 # mkdir cModule

-bash-3.2 # mkdir DMODULE

-bash-3.2 # cd DMODULE /

-bash-3.2 # mkdir src
-bash-3.2 # mkdir inc
-bash-3.2 # mkdir obj
-bash-3.2 Courier Nuevo «, Courier, espacio sencillo,»>-bash-3.2 # mkdir src
-bash- 3.2 # mkdir inc
-bash-3.2 # mkdir obj
-bash-3.2 # BMODULE cd /
-bash-3.2 # ; mkdir src
-bash-3.2 # mkdir inc
-bash-3.2 # mkdir obj
Paso 3: Generar Biblioteca para DModule para los archivos de abajo
/>
-bash-3.2 # cd DMODULE Courier New «, Courier, espacio sencillo,»>-bash-3.2 # cd

Cree cuatro archivos bajo el directorio principal, dModulefile1.c dModulefile2.c dModulefile3.c, Makefile

-bash-3.2 # cd DMODULE /
-bash-3.2 # inc
Cree tres archivos bajo inc, dModulefile1.h dModulefile2.h dModulefile3.h

dModulefile1.c
# include» dModulefile1.h «

int DModuleFunction1 (int a)
{
printf («Estoy en DModuleFunction1 y su valor:% d», a);
a = a + FUNC_VALUE4;
retorno (a);
}
dModulefile2.c
# include» dModulefile2.h «

int DModuleFunction2 (int b)
{
printf («Estoy en DModuleFunction2 y su valor:% d», b);
b = b + FUNC_VALUE5;
retorno (b);
}

dModulefile3.c
# include» dModulefile3.h «

int DModuleFunction3 (int c)
{
printf («Estoy en DModuleFunction3 y su valor:% d», c);
c = c + FUNC_VALUE6;
return (c);
}


dModulefile1.h
# include
# define FUNC_VALUE4 14
dModulefile2.h
» color: amarillo; font-family: «Courier New», Courier, espacio sencillo ; «> # include
# define FUNC_VALUE5 11
dModulefile3.h
# include
# define FUNC_VALUE6 13
Makefile lugar en el directorio src)
# define del compilador como gcc
CC = gcc />
# define parámetros del compilador «CFLAGS» si la opción que-g es para el IAE, de la pared para mostrar todos


CFLAGS =-g-Wall

A # include para incluir los directorios dan Directorio -I/Path
# ej: includedir = -I/VOBS/CMODULE / INC /, para incluir una mayor directorio
# Sintaxis entonces será includedir + = -I/VOBS/CMODULE/INC /
#                     Includedir = -I/VOBS/BMODULE/INC /

includedir = -I/root/mreddya/MAKEFILE_EXERCISE/DMODULE/inc

# define MACRO para diretory OBJETO
OBJS = $ (OBJ-DIR) / dModulefile1.o
$ (OBJ-DIR) / dModulefile2.o
$ (OBJ-DIR) / dModulefile3.o

# Primero siempre damos Marca, se trata aquí, y la hora de OBJS
# Luego Se comprobará qué y todos o se necesitan de

# OBJS directorio
# y luego el tope de comandos para generar el o
todo: libDmodule.a

# Generar la biblioteca

libDmodule.a : $ (OBJS)
; ar-qcs libDmodule.a $ (OBJS)
# Para Generar% o significa mismo directorio
# target (Narra $ . (OBJ-DIR) /% s:…% c, generar el% archivos de C # o de archivos mediante comandos)
# Para.. conseguir el objetivo el siguiente comando debería ser ejecutado,
# de lo contrario error vinculador estará allí
$ (OBJ-DIR) /% d:% c
.. , $ (CC) $ (CFLAGS) $ (includedir) -c $ <-o $ @

limpia:
;. rm-f $ (OBJ-DIR) / * s
rm .-f * a

-bash-3.2 # pwd
/ root / mreddya / MAKEFILE_EXERCISE / DMODULE / src
-bash-3.2 # make />
gcc-g-Wall -I/root/mreddya/MAKEFILE_EXERCISE/DMODULE/inc-c dModulefile2.c-o / root / mreddya / MAKEFILE_EXERCISE / DMODULE/obj/dModulefile2.o
gcc-g-Wall -I/root/mreddya/MAKEFILE_EXERCISE/DMODULE/inc-c dModulefile3.c-o / root/mreddya/MAKEFILE_EXERCISE/DMODULE/obj/dModulefile3.o
ar-qcs libDmodule.a / root/mreddya/MAKEFILE_EXERCISE/DMODULE/obj/dModulefile1.o / root/mreddya/MAKEFILE_EXERCISE/DMODULE/obj/dModulefile2.o / root/mreddya/MAKEFILE_EXERCISE/DMODULE/obj/dModulefile3. o
dModulefile1.c dModulefile2.c dModulefile3.c 3.2>-bash- libDmodule.a Makefile
= «color: blanco; font-family:» Courier New «, Courier, espacio sencillo,»>-bash-3.2 #
pwd / root / mreddya / MAKEFILE_EXERCISE / DMODULE / obj
-bash-3.2 # ls
dModulefile1.o dModulefile2.o dModulefile3.o