Linux – Dynamic and Static Libraries

Of course, we can also write the Makefile directly, so we don’t need to complete the packaging and publishing of the static library step by step

2. Use of static libraries

Method 1

In the above, we already have a static library output, how should others use it? For example: want to use this library under the friend file:

Now there is a mytest.c file and a static library file lib in the friend directory. Mytest.c wants to use lib. Let’s write the code of mytest.c first:

1. #include "add.h"
   
   #include "sub.h"
   
   
   int main()
   
   {
   
   int x = 30;
   
   int y = 20;
   
   
   int ret1 = my_add(x, y);
   
   int ret2 = my_sub(x, y);
   
   
   printf("ret1 = %d\\
   ",ret1);
   
   printf("ret2 = %d\\
   ",ret2);
   
   return 0;
   
   }

To compile:

After compiling, a warning is reported: there is no header file, but obviously there are files and library files we want under the lib file, why is this?

In fact, when the compiler is compiling, it will look for the files in the current directory, not the folders of the current directory, the header files and libraries in the lib directory The file is not the same directory as mytest.c, so the compilation will go wrong;

When compiling, we need to tell the compiler which directory the header files are in.

[mlg@VM-20-8-centos friend]$ gcc mytest.c -I ./lib

At this point, there is another warning: link error, two undefined functions? Two functions have been defined in the lib directory and packaged? Why is it still reporting an error?

The reason is the same as above;So we also need to tell the compiler that the library file is in the lib directory:

[mlg@VM-20-8-centos friend]$ gcc mytest.c -I ./lib -L ./lib

The location of the header file and library file has been told to the compiler, why is it still reporting an error?

In fact, both the header file and the library file are in the lib directory. In the mytest.c file, add.h and sub.h are clearly included. Gcc can recognize it when compiling, but it does not know the library file, if there are multiple library files in the lib directory, gcc does not know which library you want to use. So we also need to specify the name of the library.

[mlg@VM-20-8-centos friend]$ gcc mytest.c -I ./lib -L ./lib -l mymath

At this point, the entire program can be compiled and run correctly

Summary:

When we use the static library to compile and link, we need to specify the path of the header file, the path of the library file and the name of the library to be used

• -I: Specifies the path where the header file is located.
• -L: Specify the path where the library file is located.
• -l: Indicate which library under the library file path needs to be linked

[mlg@VM-20-8-centos friend]$ gcc mytest.c -I ./lib -L ./lib -l mymath

Similarly, we can also write Makefile:

Method 2

Compared with when we compiled a .c file before, why did we add these options? . This is because the previous libraries are all in the default path of the system, so we can copy the static library we made to the default path of the system, and we can also achieve the effect of not needing to add these options; but it is seriously not recommended.

3. Production of dynamic library

Write the following four files: the source file contains add.c and sub.c, the header The file containsadd.h and sub.h; used to make a dynamic library and package

//add.h

#pragma once

#include <stdio.h>

extern int my_add(int x, int y);


//add.c

#include "add.h"

int my_add(int x, int y)

{

return x + y;

}


//sub.h

#pragma once

#include <stdio.h>

extern int my_sub(int x, int y);


//sub.c

#include "sub.h"

int my_sub(int x, int y)

{

return x - y;

}

1. Generate binary (.o) file

First generate the .o file from the above .c file

1. [mlg@VM-20-8-centos test_lib]$ gcc -fPIC -c add.c -o add.o

2. [mlg@VM-20-8-centos test_lib]$ gcc -fPIC -c sub.c -o sub.o

-fPIC: The function is to tell the compiler to generate position-independent code (the compiled code has no absolute position, only relative position); thus, the generated dynamic library can be called anywhere.

2. Packing

We will package the generated .o file:

[mlg@VM-20-8-centos test_lib]$ gcc -shared -o libmymath.so add.o sub.o

-shared:When linux adds the -shared parameter when gcc is compiled, the purpose is to compile the source code into a dynamic library .so file;

3. Release dynamic library

Organize the library files and all header files and put them in the lib directory, so that the dynamic library can be released

Of course, we can also write the Makefile directly, so we don’t need to complete the packaging and publishing of the static library step by step

4. Use of dynamic library

The use of dynamic libraries is roughly similar to that of static libraries, but there are some differences. We first use the static library method to realize the link of the dynamic library.

It can be compiled successfully, but an error is reported when running, why?

We used the ldd command to list the dynamic library dependencies and found that it was not found. Although the compiler has been told the path location of the library files and header files, when the compiler is compiled, it has nothing to do with the compiler; when we execute (run) the executable program a.out, it is the loader. Completed. So we need to tell the system where the library file is at runtime;

Method One

Copy it to the default path of the system, generally refers to /usr/lib This is not a demonstration, it is seriously not recommended;

Method Two

Change LD_LIBRARY_PATH

[mlg@VM-20-8-centos lib]$ export LD_LIBRARY_PATH=/home/mlg/lesson5-dynamic and static library/friend/lib

The LD_LIBRARY_PATH environment variable is used to specify a path other than the system default path when searching for a dynamic link library during program loading and running. Note that the path specified in LD_LIBRARY_PATH will be searched before the system default path;

After adding, we checked again and found that the path has been specified

Compile and run again:

Fourth, a summary of the characteristics of dynamic libraries and static libraries

Features of static library:

• The static library is added to the executable code when the executable program is linked, and physically becomes a part of the executable program; the static library will no longer be needed when the program is running.
• Compared to the program generated by the dynamic library link, the static function is equivalent to the compiler completes the code, so the execution program will be larger, but it runs relatively faster;
• The static library sacrifices space efficiency in exchange for time efficiency;

Features of dynamic library:

• The dynamic library will not be connected to the target code when the program is compiled, but will be loaded when the program is running, so the dynamic library needs to exist when the program is running;
• Only when the program is executed in the dynamic library, the required function codes are copied into the memory. This makes the executable file smaller and saves disk space;
• Because it will take a certain amount of time to link the library at runtime, the execution speed will be relatively slower;
• Dynamic library sacrifices time efficiency for space efficiency;