MinGW Static and Dynamic Libraries

太过爱你忘了你带给我的痛 2022-12-28 08:12 140阅读 0赞

## Introduction ##

This article is intended to give a brief and simple introduction to compiling your own libraries with the MinGW (Minimal GNU for Windows) compiler. This article assumes you have a basic understanding of the C language. The first thing you'll need to do is download [MinGW][]. I strongly suggest that you set the Windows environmental path to the MinGW directory. This allows you to call the MinGW GCC compiler from any directory on your computer. On Windows 7, it is right click on My Computer->Properties->Advanced->Environmental Variables and add the MinGW directory to the PATH, or simply type this into cmd.exe:

![minus.gif][]  Collapse  |  [Copy Code][]

>SET PATH=%PATH%;C:\MinGW\bin

SET will temporarily set your environmental variables for the duration of your command prompt session. If you would like to permanently change your environmental variables, use SETx instead of SET.

## The Static Library ##

The following code was used to create both the static and dynamic library. It is a simple example to demonstrate a possible math library.

add.c

![minus.gif][]  Collapse  |  [Copy Code][]

#include "add.h"
    int add(int a, int b) {
        return a + b;
    }

add.h

![minus.gif][]  Collapse  |  [Copy Code][]

#ifndef ADD_H
    #define ADD_H
    int add(int a, int b);
    #endif  // ADD_H

The main file demonstrates how to call the library file after it's compiled. Notice that you require the header file or an external reference to execute a static library. In most cases, if you share your library, it will be in the form of a header file. The function declaration is necessary for the linker. If you did not have access to the header file, you would need to go about reverse engineering the library to create the function declarations.

main.c

![minus.gif][]  Collapse  |  [Copy Code][]

#include "add.h"
    #include <stdio.h>
    //extern int add(int a, int b);
    
    int main() {
        int a = 2;
        int b = 1;
        printf("a=%d, b=%d\n", a,b);
        printf("add: %d\n", add(a,b));
        getchar();
        return 0;
    }

## Compiling the Static Library ##

![static.png][]

### Building the Library ###

![minus.gif][]  Collapse  |  [Copy Code][]

>gcc -c add.c -o add.o
    >ar rcs libadd.a add.o

[gcc flags][]:

*  \-c: Disables the linker invocation
 *  \-o: A custom output file

[ar flags][]:

*  \-r: Insert the files member... into archive (with replacement).
 *  \-c: Indicates you are creating an archive file
 *  \-s: Write an object-file index into the archive, change is made to the archive

It is important that you recognize that the GCC compiler requires that you prefix your static library with the keywordlib and suffix .a, like libadd.a. The lib prefix is required by the linker to find the static library.

### Referencing the Library ###

![minus.gif][]  Collapse  |  [Copy Code][]

>gcc -c main.c -o main.o
    >gcc -c main.exe main.o -L. -ladd
    >main.exe

[gcc flags][]:

*  \-L: Indicates the location of the library you want to reference (. = current directory)
 *  \-l: Specifies the specific library you want to attach

## Compiling the Dynamic Library ##

The Dynamic Library uses the exact same code as before. Most tutorials suggest using `__declspec(dllexport)` to export your function references. This is not necessary for GCC as [`__declspec`][declspec] is a Microsoft specific modifier. Secondly, many think of dynamic libraries as DLLs (dynamic linked libraries); however, GNU refers to their dynamic libraries as so(shared objects). Although it is possible to name your shared library with the DLL extension, I do not recommend it as GCC uses the [ELF][] (Executable Linkable Format), and Microsoft Linker uses the [older][] [COFF][] (Common Object File Format). By naming your shared library as a so, you are indicating that it is a GCC shared library, not a Windows specific library.

![dynamic.png][]

### Referencing the Library ###

![minus.gif][]  Collapse  |  [Copy Code][]

gcc -c add.c -o add.o
    gcc -shared -o libadd.so add.o
    gcc -o main.exe main.c libadd.so

[gcc flags][]:

*  \-shared tells the compiler that you want to compile a shared library

Remember that your main.c still requires access to the header of add.h to get the function references. Otherwise you have to manually enter the external reference into your main file.

## Comparison of Static to Dynamic ##

![staticVsDynamicErr.png][]

The first thing I noticed was that the dynamic executable was larger than the static. This is due to the fact that the dynamic library has overhead to reference the dynamic library. This normally would not be the case if the DLL contained a large collection of functions. With only one function in the DLL, the overhead of a dynamic library outweighs the need for a static library. In the example image, once the DLL was deleted, the dynamic executable would not run, as it depends on the dynamic library. The static library executes without an external library because they are compiled directly into the executable.

### Dynamic ###

#### Pro ####

*  Multiple executables can reference the DLL
 *  Executables are generally smaller
 *  Updates are easier as code is centralized
 *  Good for large projects

#### Cons ####

*  Requires an external library

### Static ###

#### Pro ####

*  Does not rely on external libraries
 *  Good for small projects or write-once-only projects

#### Cons ####

*  Executables are generally larger as machine code is replicated across files

## Conclusion ##

Dynamic and static libraries both have their places within your projects. Be sure to select the right library for the right job. Keep in mind that regardless of the library type, you will still require the header file to execute the functions contained within the library. I have found that producing libraries is generally easier with GCC. Remember to name your static libraries \*.a and your shared library \*.so so that they will not be confused as Windows specific \*.lib and \*.dlllibraries. In my next article, I will describe generating libraries in Microsoft Visual C++ and using classes.

## History ##

Version 1.0.

My next article will explain how to reference libraries with Microsoft Visual C++.

## License ##

This article, along with any associated source code and files, is licensed under [The Code Project Open License (CPOL)][The Code Project Open License _CPOL]

[MinGW]: http://www.mingw.org/
[minus.gif]: /images/20221120/e582f7bd626f4c29807e07cda0927055.png
[Copy Code]: http://www.codeproject.com/Articles/84461/MinGW-Static-and-Dynamic-Libraries#
[static.png]: /images/20221120/37138ce9f9ba4735a49abdcde514c159.png
[gcc flags]: http://gcc.gnu.org/onlinedocs/gcc-2.95.3/gcc_2.html#SEC13
[ar flags]: http://unixhelp.ed.ac.uk/CGI/man-cgi?ar
[declspec]: http://msdn.microsoft.com/en-us/library/dabb5z75%28VS.80%29.aspx
[ELF]: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
[older]: http://en.wikipedia.org/wiki/Executable_and_Linkable_Format#Applications
[COFF]: http://msdn.microsoft.com/en-us/library/y0zzbyt4%28VS.80%29.aspx
[dynamic.png]: /images/20221120/a0900f3870da487faf1133ac60e9d3b2.png
[staticVsDynamicErr.png]: http://www.codeproject.com/KB/cpp/libraries/staticVsDynamicErr.png
[The Code Project Open License _CPOL]: http://www.codeproject.com/info/cpol10.aspx