C/C++ 跨平台交叉编译、静态库/动态库编译、MinGW、Cygwin、CodeBlocks使用原理及连接参数选项

时间 2019-11-17

标签 c++ 跨平台交叉编译静态动态 mingw cygwin codeblocks 使用原理连接参数选项栏目 C&C++ 繁體版

原文原文链接

目录html

0. 引言
1. 交叉编译
2. Cygwin简介
3. 静态库编译及使用
4. 动态库编译及使用
5. MinGW简介
6. CodeBlocks简介

0. 引言linux

UNIX是一个注册商标，是要知足一大堆条件而且支付可观费用才可以被受权使用的一个操做系统。linux是unix的克隆版本，是由其创始人Linus和诸多世界知名的黑客手工打造的一个操做系统。为何linux和unix之间有不少软件能够很轻松的移植？由于linux也知足POSIX规范，因此在运行机制上跟unix相近。同时，POSIX标准也是Linux、windows下可以进行交叉编译的基础ios

0x1: POSIX(Portable Operating System Interface)c++

可移植操做系统接口(Portable Operating System Interface POSIX)，是IEEE为要在各类UNIX操做系统上运行的软件，而定义API的一系列互相关联的标准的总称，其正式称呼为IEEE 1003，而国际标准名称为ISO/IEC 9945。此标准源于一个大约开始于1985年的项目。POSIX这个名称是由理查德·斯托曼应IEEE的要求而提议的一个易于记忆的名称。它基本上是(Portable Operating System Interface可移植操做系统接口)的缩写，而X则代表其对Unix API的传承shell

Linux基本上逐步实现了POSIX兼容，但并无参加正式的POSIX认证。微软的Windows NT声称部分实现了POSIX标准，由于有POSIX标准的存在，咱们在unix、linux、windows上进行编程的时候，会发现有不少API都是通用的，虽然大多数状况下进行跨系统兼容编程是很困难的编程

当前的POSIX主要分为四个部分windows

1. Base Definitions
2. System Interfaces
3. Shell and Utilities
4. Rationale

0x2: POSIX 1.1标准api

POSIX(Portable Operating System Interface for Computing Systems)是由IEEE 和ISO/IEC 开发的一簇标准。该标准是基于现有的UNIX实践和经验，描述了操做系统的调用服务接口，用于保证编制的应用程序能够在源代码一级上在多种操做系统上移植运行。
缓存

1. 1003.0
管理POSIX开放式系统环境(OSE)。IEEE在1995年经过了这项标准。ISO的版本是ISO/IEC 14252:1996

2. 1003.1
被普遍接受、用于源代码级别的可移植性标准。1003.1提供一个操做系统的C语言应用编程接口(API)。IEEE和ISO已经在1990年经过了这个标准，IEEE在1995年从新修订了该标准。

3. 1003.1b
一个用于实时编程的标准(之前的P1003.4或POSIX.4)。这个标准在1993年被IEEE经过，被合并进ISO/IEC 9945-1

4. 1003.1c
一个用于线程(在一个程序中当前被执行的代码段)的标准。之前是P1993.4或POSIX.4的一部分，这个标准已经在1995年被IEEE经过，纳入ISO/IEC 9945-1:1996

5. 1003.1g
一个关于协议独立接口的标准，该接口可使一个应用程序经过网络与另外一个应用程序通信。1996年，IEEE经过了这个标准

6. 1003.2
一个应用于shell和工具软件的标准，它们分别是操做系统所必须提供的命令处理器和工具程序。1992年IEEE经过了这个标准。ISO也已经经过了这个标准(ISO/IEC 9945-2:1993)

7. 1003.2d
改进的1003.2标准

8. 1003.5
一个至关于1003.1的Ada语言的API。在1992年，IEEE经过了这个标准。并在1997年对其进行了修订。ISO也经过了该标准

9. 1003.5b
一个至关于1003.1b(实时扩展)的Ada语言的API。IEEE和ISO都已经经过了这个标准。ISO的标准是ISO/IEC 14519:1999

10. 1003.5c
一个至关于1003.1q(协议独立接口)的Ada语言的API。在1998年，IEEE经过了这个标准。ISO也经过了这个标准。

11. 1003.9
一个至关于1003.1的FORTRAN语言的API。在1992年，IEEE经过了这个标准，并于1997年对其再次确认。ISO也已经经过了这个标准

12. 1003.10
一个应用于超级计算应用环境框架(Application Environment Profile，AEP)的标准。在1995年，IEEE经过了这个标准

13. 1003.13
一个关于应用环境框架的标准，主要针对使用POSIX接口的实时应用程序。在1998年，IEEE经过了这个标准 

14. 1003.22
一个针对POSIX的关于安全性框架的指南

15. 1003.23
一个针对用户组织的指南，主要是为了指导用户开发和使用支持操做需求的开放式系统环境(OSE)框架

16. 2003
针对指定和使用是否符合POSIX标准的测试方法，有关其定义、通常需求和指导方针的一个标准。在1997年，IEEE经过了这个标准

17. 2003.1
这个标准规定了针对1003.1的POSIX测试方法的提供商要提供的一些条件。在1992年，IEEE经过了这个标准

18. 2003.2
一个定义了被用来检查与IEEE 1003.2(shell和工具API)是否符合的测试方法的标准。在1996年，IEEE经过了这个标准

0x3: POSIX标准的意义
安全

POSIX的意义在于提供了"跨操做系统兼容性编译"的能力，遵循了POSIX标准的C/C++程序源代码，能够直接在Linux/BSD环境下用GCC编译，或者在windows下用Cygwin/MinGW编译(Cygwin、MinGW提供了跨操做系统的兼容编译)。这叫跨操做系统的编译，注意要和"跨平台交叉编译"区分开来

Relevant Link:

http://zh.wikipedia.org/wiki/POSIX
http://i.linuxtoy.org/docs/guide/ch48s05.html

1. 交叉编译

0x1: 交叉编译简介

从编译所在的平台和运行所在的平台这点来看，有两种编译概念

1. 本地编译
咱们常见的软件开发，都是属于"本地编译"。在当前的PC下，x86的CPU下，直接编译出来程序，能够运行的程序(或者库文件)，其能够直接在当前的环境，即x86的CPU下，当前电脑中，运行。
此时的编译，能够叫作"本地编译"，即在当前目标平台下，编译出来的程序，也只是放到当前平台下，就能够运行的

2. 交叉编译
这是一个和本地编译相对应的概念。而所谓的"交叉编译"，就是在一种平台上编译，编译出来的程序，是放到别的平台上运行
即编译的环境，和运行的环境，不同，属于交叉的，此所谓cross交叉编译，这个概念，主要和嵌入式开发有关

一种最多见的例子就是：

在进行嵌入式开发时，手上有个嵌入式开发板，CPU是arm的，而后在x86的平台下开发，好比Ubuntu的Linux，或者是Win7。而后就须要在x86的平台上，(用交叉编译器)去编译你写好的程序代码，编译生成的(可执行的)程序，是放
到目标开发板，arm的CPU上运行的
此所谓：在x86平台上编译，在ARM平台上运行

交叉编译，英文常写做cross compile，也有其余写法：crosscompile, cross compiling等

0x2: 为什么要有交叉编译

之因此要有交叉编译，主要缘由是：

1. 嵌入式系统中的资源太少
交叉编译出来的程序，所要运行的目标环境中，各类资源，都相对有限，因此很难进行直接的本地编译，最多见的状况是：
由于编译，开发，都须要相对比较多的CPU，内存，硬盘等资源，而嵌入式开发上的那点资源，只够嵌入式(Linux)系统运行的，没太多剩余的资源，供你本地编译。因此须要在别的平台上进行跨平台编译，而后在其余的平台上运行

0x3: 跨平台编译和跨操做系统编译的差异

这里须要注意的是"平台"的概念，实际上包含两个概念

1. 体系结构(Architecture): 同一个体系结构能够运行不一样的操做系统
2. 操做系统(Operating System): 同一个操做系统也能够在不一样的体系结构上运行

举例来讲，咱们常说的x86 Linux平台其实是Intel x86体系结构和Linux for x86操做系统的统称；而x86 WinNT平台其实是Intel x86体系结构和Windows NT for x86操做系统的简称

像crosstool-NG这类交叉编译器和Cygwin这类跨操做系统平台编译器的区别在于

1. crosstool-NG跨平台编译(跨体系结构、操做系统)

2. Cygwin跨平台编译(提供*inux到windows系统的代码级编译兼容性)

Relevant Link:

http://www.crifan.com/files/doc/docbook/cross_compile/release/html/cross_compile.html
http://zh.wikipedia.org/wiki/%E4%BA%A4%E5%8F%89%E7%B7%A8%E8%AD%AF%E5%99%A8
http://baike.baidu.com/view/650389.htm

2. Cygwin简介

0x1: 简介

Cygwin是许多自由软件的集合，最初由Cygnus Solutions开发，用于各类版本的Microsoft Windows上，运行类UNIX系统。Cygwin的主要目的是经过"从新编译"(注意：是从新编译)，将POSIX系统(例如Linux、BSD，以及其余Unix系统)上的软件移植到Windows上。Cygwin移植工做在Windows NT上比较好，在Windows 95和Windows 98上，相对差劲一些。目前Cygwin由Red Hat等负责维护

首要须要明白的是，Cygwin不是一个跨平台模拟器，它不能让咱们把linux上编译出来的程序在windows上运行(像wine那样)，而是一个跨平台的编译器，也就是提供代码级的跨操做系统兼容性，咱们在linux下写的符合POSIX标准的C程序能够在windows下面进行编译，Cygwin提供了一套在windows下可使用的Linux的API

Cygwin包括了一套库，该库在Win32系统下实现了POSIX系统调用的API。还有一套GNU开发工具集(好比GCC、GDB)，这样能够进行简单的软件开发。还有一些UNIX系统下的常见程序。2001年，新增了X Window System

0x2: Cygwin的特性

Cygwin is:
1. a large collection of GNU and Open Source tools which provide functionality similar to a Linux distribution on Windows.
2. a DLL (cygwin1.dll) which provides substantial POSIX API functionality.

Cygwin is not:
1. a way to run native Linux apps on Windows. You must rebuild your application from source if you want it to run on Windows.
2. a way to magically make native Windows apps aware of UNIX® functionality like signals, ptys, etc. Again, you need to build your apps from source if you want to take advantage 
of Cygwin functionality.

0x3: Cygwin原理

cygnus当初首先把GCC，GDB，GAS等开发工具进行了改进，使他们可以生成并解释win32的目标文件。而后，他们要把这些工具移植到windows平台上去。一种方案是基于win32 api对这些工具的源代码进行大幅修改，这样作显然须要大量工做。所以，他们采起了一种不一样的方法

1. 他们写了一个共享库(就是cygwin.dll)，把win32 api中没有的unix风格的调用(如fork、spawn、signals、select、sockets等)封装在里面
2. 也就是说，他们基于win32 api写了一个unix系统库的模拟层(这个模拟层是一个关键，它的底层是win32 api，上层提供unix风格的调用，因此咱们才能够在windows下编译unix风格的C程序)
3. 这样，只要把这些工具的源代码和这个共享库链接到一块儿，就可使用unix主机上的交叉编译器来生成能够在windows平台上运行的工具集
4. 以这些移植到windows平台上的开发工具为基础，cygnus又逐步把其余的工具(几乎不须要对源代码进行修改，只须要修改他们的配置脚本)软件移植到windows上来。这样，在windows平台上运行bash和开发工具、用户工具，感受好
像在unix上工做

0x4: 使用Cygwin编程

code

#iuclude <stdio.h>

main()
{
    printf("hello world!!\n");
}

编译

gcc hello.c -o hello.exe

获得hello.exe，这个程序能够在windows上直接点击运行

Relevant Link:

http://zh.wikipedia.org/wiki/Cygwin
https://www.cygwin.com/
http://www.ibm.com/developerworks/cn/linux/l-cn-cygwin/

3. 静态库编译及使用

0x1: 什么是库

库是写好的现有的，成熟的，能够复用的代码。现实中每一个程序都要依赖不少基础的底层库，不可能每一个人的代码都从零开始，所以库的存在是颇有必要的
本质上来讲库是一种可执行代码的二进制形式，能够被操做系统载入内存执行。库有两种

1. 静态库(.a、.lib)
2. 动态库(.so、.dll)

所谓静态、动态是指"连接"的过程存在区别

0x2: 动态库和静态库的默认路径PATH搜索顺序

库文件在链接(静态库和共享库)和运行(仅限于使用共享库的程序)时被使用，其搜索路径是在系统中进行设置的

1. 静态库的搜索路径顺序
    1) /lib
    2) /usr/lib  
    3) /etc/ld.so.conf文件中添加库的搜索路径
    4) /etc/ld.so.conf.d下新建一个.conf文件，这种方法能够很灵活地将不一样软件的库搜索路径区分开来
2. 动态库的搜索路径顺序
    1) LD_LIBRARY_PATH 
    2) /lib
    3) /usr/lib  
    4) /etc/ld.so.cache(使用ldconfig生成的库路径缓存)
    5) /etc/ld.so.conf文件中添加库的搜索路径
    6) /etc/ld.so.conf.d下新建一个.conf文件，这种方法能够很灵活地将不一样软件的库搜索路径区分开来

0x3: 静态库

之因此称之为"静态库"，是由于在连接阶段，会将汇编生成的目标文件.o与引用到的库一块儿连接打包到可执行文件中。所以对应的连接方式称为静态连接。
从本质上来讲，一个静态库能够简单当作是一组目标文件(.o/.obj文件)的集合，静态库与汇编生成的目标文件(.o/.obj)一块儿连接为可执行文件
静态库和.o文件格式类似。即不少目标文件通过压缩打包后造成的一个文件

静态库特色总结：

1. 静态库对函数库的连接是放在编译时期完成的
2. 程序在运行时与函数库再无瓜葛，移植方便，由于代码已经嵌入到程序里面了，能够直接跟着程序走，不存在对外部文件的依赖
3. 浪费空间和资源，由于全部相关的目标文件与牵涉到的函数库被连接合成一个可执行文件，会增长本来程序的空间

0x4: 静态库编程

咱们接下来学习一下如何建立用于C++应用的静态库(一个.lib 文件)。使用静态库是重用代码的一种绝佳方式。你没必要在要求功能的每一个应用中从新实现同一例程，而只需将其写入静态库一次，而后从应用引用它们便可。从静态库连接的代码成为了应用的一部分，这样你就没必要安装另外一个文件来使用代码。

1. VS编译、使用静态库

//建立静态库项目
1. 在菜单栏上，依次选择"文件"、"新建"、"项目"
2. 在"新建项目"对话框的左窗格中，依次展开"已安装"、"模板"、"Visual C++"，而后选择"Win32"
3. 在中间窗格中，选择"Win32 控制台应用程序"
4. 在"名称"框中为项目指定名称，例如 MathFuncsLib。 在"解决方案名称"框中为解决方案指定名称，例如 StaticLibrary。 选择"肯定"按钮
5. 在"Win32 应用程序向导"对话框的"概述"页上，选择"下一步"按钮
6. 在"应用程序设置"页的"应用程序类型"下，选择"静态库"
7. 在"应用程序设置"页的"附加选项"下，清除"预编译头"复选框
8. 选择"完成"按钮建立项目

MathFuncsLib.h

// MathFuncsLib.h
#ifndef MATHFUNCSLIB_H  
#define MATHFUNCSLIB_H  
  
namespace MathFuncs
{
    class MyMathFuncs
    {
    public:
        // Returns a + b
        static double Add(double a, double b);

        // Returns a - b
        static double Subtract(double a, double b);

        // Returns a * b
        static double Multiply(double a, double b);

        // Returns a / b
        static double Divide(double a, double b);
    };
}  
  
#endif

MathFuncsLib.cpp

// MathFuncsLib.cpp
// compile with: cl /c /EHsc MathFuncsLib.cpp
// post-build command: lib MathFuncsLib.obj

#include "MathFuncsLib.h"

#include <stdexcept>

using namespace std;

namespace MathFuncs
{
    double MyMathFuncs::Add(double a, double b)
    {
        return a + b;
    }

    double MyMathFuncs::Subtract(double a, double b)
    {
        return a - b;
    }

    double MyMathFuncs::Multiply(double a, double b)
    {
        return a * b;
    }

    double MyMathFuncs::Divide(double a, double b)
    {
        return a / b;
    }
}

编译静态库文件

//编译此静态库
1. 在菜单栏上依次选择"生成"、"生成解决方案"
2. 这将建立一个可供其余程序使用的静态库

vs是windows操做系统下的编译平台，经过vs编译获得的.lib静态库只能在windows的程序代码中使用，主要是编译器、汇编器和链接器的不一样，所以两者库的二进制是不兼容的。文章以后会学习到如何将linux下编译的静态库经过跨平台编译连接到windows的程序代码中

要在其余程序中使用静态库中的功能，必须引用静态库才能使用其中的例程

//建立引用静态库的 C++ 控制台应用
1. 在菜单栏上，依次选择"文件"、"新建"、"项目"。
2. 在左窗格中的"Visual C++"下，选择"Win32"。
3. 在中间窗格中，选择"Win32 控制台应用程序"。
4. 在"名称"框中为项目指定名称，例如 MyExecRefsLib。 在"解决方案"旁的下拉列表中选择"添加到解决方案"。 这会将新项目添加到包含此静5. 态库的解决方案。 选择"肯定"按钮。
6. 在"Win32 应用程序向导"对话框的"概述"页上，选择"下一步"按钮。
7. 在"应用程序设置"页的"应用程序类型"下，选择"控制台应用程序"。
8. 在"应用程序设置"页的"附加选项"下，清除"预编译头"复选框。
9. 选择"完成"按钮建立项目。
 
//在应用中使用静态库的功能
1. 在建立一个控制台应用程序后，一个空的程序已经为你建立好了。 源文件的名称与你以前选择的名称相同。 在此示例中，源文件名为 MyExecRefsLib.cpp。
2. 必须引用静态库才能使用其中的算术例程。 为此，请在"解决方案资源管理器"中打开 MyExecRefsLib 项目的快捷菜单，而后选择"引用"。 在 MyExecRefsLib"属性页"对话框中，展开"通用属性"节点，选择"框架和引用"，而后
选择"添加新引用"按钮。 有关"引用"对话框的更多信息，请参见"<Projectname> 属性页"对话框 ->"通用属性"->"框架和引用"。
3. "添加引用"对话框列出了能够引用的库。 "项目"选项卡列出了当前解决方案中的全部项目以及它们包含的全部库。 在"项目"选项卡上，选中"MathFuncsLib"复选框，而后选择"肯定"按钮。
4. 若要引用 MathFuncsLib.h 头文件，必须修改包含的目录路径。 在 MyExecRefsLib"属性页"对话框中，依次展开"配置属性"节点和"C/C++"节点，而后选择"常规"。 在"附加包含目录"旁，指定 MathFuncsLib 目录的路径或
浏览至该目录。
5. 若要浏览至目录路径，请打开属性值下拉列表框，而后选择"编辑"。 在"附加包含目录"对话框中，在文本框中选择一个空行，而后选择行尾的省略号按钮 (…)。 在"选择目录"对话框中，选择 MathFuncsLib 目录，而后选择"选择
文件夹"按钮以保存所作选择并关闭对话框。 在"附加包含目录"对话框中，选择"肯定"按钮，而后在"属性页"对话框中，选择"肯定"按钮以保存对该项目进行的更改。

MyExecRefsLib.cpp

// MyExecRefsLib.cpp
// compile with: cl /EHsc MyExecRefsLib.cpp /link MathFuncsLib.lib

#include <iostream>

#include "MathFuncsLib.h"

using namespace std;

int main()
{
    double a = 7.4;
    int b = 99;

    cout << "a + b = " <<
        MathFuncs::MyMathFuncs::Add(a, b) << endl;
    cout << "a - b = " <<
        MathFuncs::MyMathFuncs::Subtract(a, b) << endl;
    cout << "a * b = " <<
        MathFuncs::MyMathFuncs::Multiply(a, b) << endl;
    cout << "a / b = " <<
        MathFuncs::MyMathFuncs::Divide(a, b) << endl;

    return 0;
}

Relevant Link:

http://msdn.microsoft.com/zh-cn/library/ms235627.aspx#BKMK_CreateLibProject

2. GCC编译、使用静态库

静态库的后缀是.a(并无强制规定)，它的产生分两步

1. 由源文件编译生成一堆.o，每一个.o里都包含这个编译单元的符号表
2. ar命令将不少.o转换成.a，成为静态库，从这点也能够看出来，库是不少.o文件的集合

在linux下，库文件通常放在/usr/lib和/lib下
静态库的名字通常为libxxxx.a，其中xxxx是该lib的名称
动态库的名字通常为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号，minor是副版本号(若是库的命名不遵循 libXXXXX.a的格式就找不到相应文件)

ldd命令能够查看一个可执行程序依赖的共享库 
ldd /bin/ping
    linux-gate.so.1 =>  (0x006cd000)
    libidn.so.11 => /lib/libidn.so.11 (0x005d6000)
    libc.so.6 => /lib/libc.so.6 (0x00927000)
    /lib/ld-linux.so.2 (0x005ac000)

首先，咱们先完成函数库(静态库的代码)的编码

hello.h: 函数库(静态库)的头文件

#ifndef HELLO_H
#define HELLO_H

void hello(const char* name);

#endif

hello.c: 函数库的实现代码

#include <stdio.h>

void hello(const char* name)
{
    printf("Hello%s!\n", name);
}

如今，咱们能够将当前的代码编译为静态库文件，须要注意的，静态库和可执行在本质上都是可执行代码，可是静态库没有main主程序，因此不能独立运行，须要被引入到别的程序中进行运行

//将代码编译为对象文件.o
gcc -c hello.c
//将.o连接为静态库文件
ar rcs libhello.a hello.o

编译好静态库文件以后，咱们就能够在其余程序中使用静态库文件中的函数了

1. 只须要在使用到这些公用函数的源程序中包含这些公用函数的原型声明(include对应的头文件)
2. 而后在用gcc命令生成目标文件时指明静态库名
3. gcc将会从静态库中将公用函数链接到目标文件中
4. 注意，gcc会在静态库名前加上前缀lib，而后追加扩展名.a获得的静态库文件名来查找静态库文件,所以，咱们在写须要链接的库时，只写名字就能够，如libhello.a的库，只写: -lhello

main.c: 调用静态库的程序代码

#include "hello.h"

int main()
{
    hello("LittleHann");
    return 0;
}

编译

gcc -o hello main.c -L. -lhello

关于gcc的编译指令，请参阅另外一篇文章

http://www.cnblogs.com/LittleHann/p/3855905.html

Relevant Link:

http://wenku.baidu.com/view/7d8602b265ce050877321301.html

4. 动态库编译及使用

0x1: 动态库

动态库文件名命名规范和静态库文件名命名规范相似，也是在动态库名增长前缀lib，但其文件扩展名为.so。例如：咱们将建立的动态库名为myhello，则动态库文件名就是libmyhello.so。

接下来咱们继续学习如何建立用于 C++ 应用程序的动态连接库 (DLL)。使用库是重用代码的一种绝佳方式。您没必要在本身建立的每一个程序中从新实现同一例程，而只需对这些例程写入一次，而后从须要该功能的应用程序引用它们便可。经过将代码放入 DLL，您节省在引用它的每一个应用程序的空间，并且，您能够更新 DLL，而无需从新编译全部应用程序

0x2: 动态库编程

1. VS编译、使用静态库

//建立动态连接库 (DLL) 项目
1. 在菜单栏上，依次选择"文件"、"新建"、"项目"。
2. 在"新建项目"对话框的左窗格中，依次展开"已安装"、"模板"、"Visual C++"，而后选择"Win32"。
3. 在中间窗格中，选择"Win32 控制台应用程序"。
4. 在"名称"框中为项目指定名称，例如，MathFuncsDll。 在"解决方案名称"框中为解决方案指定一个名称，例如 DynamicLibrary。 选择"肯定"按钮。
5. 在"Win32 应用程序向导"对话框的"概述"页上，选择"下一步"按钮。
6. 在"应用程序设置"页上的"应用程序类型"下，选择"DLL"。
7. 选择"完成"按钮建立项目。

编写动态库DLL的头文件，MathFuncsDll.h

// MathFuncsDll.h

#ifndef MATHFUNCSDll_H
#define MATHFUNCSDll_H

/*
当定义了 MATHFUNCSDLL_EXPORTS 符号时，MATHFUNCSDLL_API 符号将在此代码中的成员函数声明中设置 __declspec(dllexport) 修饰符，此修饰符使函数能做为 DLL 导出，以供其余应用程序调用
当 MATHFUNCSDLL_EXPORTS 未定义时，MATHFUNCSDLL_API 会在成员函数声明中定义 __declspec(dllimport) 修饰符。 此修饰符可以使编译器优化从 DLL 导入的用于其余应用程序的函数
默认状况下，生成 MathFuncsDll 项目时会定义 MATHFUNCSDLL_EXPORTS
*/
#ifdef MATHFUNCSDLL_EXPORTS
    #define MATHFUNCSDLL_API __declspec(dllexport) 
#else
    #define MATHFUNCSDLL_API __declspec(dllimport) 
#endif

namespace MathFuncs
{
    // This class is exported from the MathFuncsDll.dll
    class MyMathFuncs
    {
    public: 
        // Returns a + b
        static MATHFUNCSDLL_API double Add(double a, double b); 

        // Returns a - b
        static MATHFUNCSDLL_API double Subtract(double a, double b); 

        // Returns a * b
        static MATHFUNCSDLL_API double Multiply(double a, double b); 

        // Returns a / b
        // Throws const std::invalid_argument& if b is 0
        static MATHFUNCSDLL_API double Divide(double a, double b); 
    };
}

#endif

编写动态库DLL的函数实现的.cpp文件

// MathFuncsDll.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"
#include "MathFuncsDll.h"
#include <stdexcept>

using namespace std;

namespace MathFuncs
{
    double MyMathFuncs::Add(double a, double b)
    {
        return a + b;
    }

    double MyMathFuncs::Subtract(double a, double b)
    {
        return a - b;
    }

    double MyMathFuncs::Multiply(double a, double b)
    {
        return a * b;
    }

    double MyMathFuncs::Divide(double a, double b)
    {
        if (b == 0)
        {
            throw invalid_argument("b cannot be zero!");
        }

        return a / b;
    }
}

编译后能够获得一个.dll文件

编译获得一个dll文件后，咱们就在其余的程序代码中去引入这个dll文件，并使用其中的函数功能了

//建立引用 DLL 的应用程序
1. 为了建立一个项目引用你刚刚建立好的DLL，在菜单栏中选择 文件>新建>项目。
2. 在左窗格中的"Visual C++"下，选择"Win32"。
3. 在中间窗格中，选择"Win32 控制台应用程序"。
4. 在"名称"框中为项目指定名称，例如，MyExecRefsDll。 从"解决方案"旁边的下拉列表中选择"添加到解决方案"。 这会将新项目添加到包含 DLL 的同一个解决方案中。 选择"肯定"按钮。
5. 在"Win32 应用程序向导"对话框的"概述"页上，选择"下一步"按钮。
6. 在"应用程序设置"页的"应用程序类型"下，选择"控制台应用程序"。
7. 在"应用程序设置"页的"附加选项"下，清除"预编译头"复选框。
8. 选择"完成"按钮建立项目。

//在应用程序中使用类库的功能
1. 在建立一个控制台应用程序后，一个空的程序已经为你建立好了。 源文件的名称与你以前选择的名称相同。 在本示例中，名为"MyExecRefsDll.cpp"。
2. 若要使用您 DLL 中建立的算术例程，必须引用 DLL。 为此，请在 解决方案资源管理器 中选择 MyExecRefsDll 项目，而后在菜单栏上，选择 项目，引用。 在"属性页"对话框中，展开"通用属性"节点，选择"框架和引用"，然
后选择"添加新引用"按钮。 有关"引用"对话框的更多信息，请参见"<Projectname> 属性页"对话框 ->"通用属性"->"框架和引用"。
3. "添加引用"对话框列出了能够引用的库。 "项目"选项卡列出了当前解决方案中的全部项目，以及它们包含的全部库。 在"项目"选项卡上，选中"MathFuncsDll"旁边的复选框，而后选中"肯定"按钮。
4. 若要引用 DLL 的头文件，必须修改包含的目录路径。 为此，请在"属性页"对话框中展开"配置属性"节点，而后展开"C/C++"节点，并选择"常规"。 在"附加包含目录"旁边，指定 MathFuncsDll.h 头文件所在位置的路径。 能够
使用相对路径（例如 ..\MathFuncsDll\），而后选择"肯定"按钮。
5. 如今便可在此应用程序中使用 MyMathFuncs 类。 使用如下代码替换""的内容：

MyExecRefsDll.cpp

// MyExecRefsDll.cpp
// compile with: /EHsc /link MathFuncsDll.lib

#include <iostream>

#include "MathFuncsDll.h"

using namespace std;

int main()
{
    double a = 7.4;
    int b = 99;

    cout << "a + b = " <<
        MathFuncs::MyMathFuncs::Add(a, b) << endl;
    cout << "a - b = " <<
        MathFuncs::MyMathFuncs::Subtract(a, b) << endl;
    cout << "a * b = " <<
        MathFuncs::MyMathFuncs::Multiply(a, b) << endl;
    cout << "a / b = " <<
        MathFuncs::MyMathFuncs::Divide(a, b) << endl;

    try
    {
        cout << "a / 0 = " <<
            MathFuncs::MyMathFuncs::Divide(a, 0) << endl; 
    }
    catch (const invalid_argument &e) 
    {
        cout << "Caught exception: " << e.what() << endl; 
    }

    return 0;
}

2. GCC编译、使用静态库

foo.h:

#ifndef foo_h__
#define foo_h__
 
extern void foo(void);
 
#endif  // foo_h__

foo.c:

#include <stdio.h>
 
void foo(void)
{
    puts("Hello LittleHann, I'm a shared library");
}

编译动态库文件.so

gcc -shared -Wall -Werror -fpic -o libfoo.so foo.c

编译好动态库文件以后，咱们就能够在其余程序中引入这个动态库文件.so，并使用其中的导出函数

main.c:

#include <stdio.h>
#include "foo.h"
 
int main(void)
{
    puts("This is a shared library test...");
    foo();
    return 0;
}

在main.c中引入了foo.h头文件

gcc -L. -Wall -o test main.c -lfoo

编译成功后，还有一件很重要的事，咱们回想一下Linux下静态库、动态库的默认搜索顺序

1) LD_LIBRARY_PATH 
2) /lib
3) /usr/lib  
4) /etc/ld.so.cache(使用ldconfig生成的库路径缓存)
5) /etc/ld.so.conf文件中添加库的搜索路径
6) /etc/ld.so.conf.d下新建一个.conf文件，这种方法能够很灵活地将不一样软件的库搜索路径区分开来

linux是默认不会去搜索当前目录的，因此咱们必须将.so文件复制到默认路径下、或者使用LD_LIBRARY_PATH显示指定

cp libfoo.so /usr/lib
./test
rm -f /usr/lib/libfoo.so

Relevant Link:

http://msdn.microsoft.com/zh-cn/library/ms235636.aspx
http://www.cprogramming.com/tutorial/shared-libraries-linux-gcc.html

5. MinGW简介

0x1: MinGW是什么

MinGW(Minimalist GNU for Windows)，又称mingw32，是将GCC编译器和GNU Binutils移植到Win32平台下的产物，包括一系列头文件(Win32API)、库和可执行文件

GCC支持的语言大多在MinGW也受支持，其中涵盖

1. C 
2. Objective-C
3. Fortran
4. Ada
5. 对于C语言以外的语言，MinGW使用标准的GNU运行库，如C++使用GNU libstdc++

可是MinGW使用Windows中的C运行库。所以用MinGW开发的程序不须要额外的第三方DLL支持就能够直接在Windows下运行，并且也不必定必须听从GPL许可证。这同时形成了MinGW开发的程序只能使用Win32API和跨平台的第三方库，而缺乏POSIX支持，大多数GNU软件没法在不修改源代码的状况下用MinGW编译

GCC是一个本来用于Unix系统下编程的编译器。不过，如今GCC也有了许多Win32下的移植版本，目前GCC在windows下有三个移植版本

1. MinGW
2. Cygwin
3. Djgpp

MinGW是Minimalistic GNU for Windows 的缩写。它是一个创建在GCC和binutils 项目上的编译器系统。和其余GCC的移植版相比，它能够说是最接近Win32的一个了。由于，MinGW几乎支持全部的Win32 API，这也是MinGW的特点之一。它所链接的程序，不须要任何第三方库就能够运行了。在某种程度上看，MinGW更像是VC的替代品

0x3: MinGW的Linker参数

0x3: 编程示例

Relevant Link:

http://www.mingw.org/
https://code.google.com/p/msys-cn/wiki/ChapterThree
http://wenku.baidu.com/view/c6f71522af45b307e87197a6.html

6. CodeBlocks简介

Relevant Link:

http://bbs.chinaunix.net/thread-3640636-1-1.html
http://zh.wikipedia.org/wiki/Code::Blocks
http://blog.csdn.net/wtfmonking/article/details/17487705