静态库是指在我们的应用中，有一些公共代码是需要反复使用，就把这些代码编译为“库”文件；在链接步骤中，连接器将从库文件取得所需的代码，复制到生成的可执行文件中的这种库。

上面提到了静态库是指在我们的应用中，有一些公共代码是需要反复使用，那么我们就假设一个背景，我们的开发过程中要反复使用各种排序算法。本文将使用到封装，继承，多态 以及多种排序算法，初学者可以多看看。

源码如下：

由于我们编写的库给别人使用肯定要给别人一个接口

SortInterface.h

#ifndef SORTINTERFACE_H
#define SORTINTERFACE_H

#define Interface  struct
//排序
Interface ISort
{ //冒泡排序
  virtual void BubbleSort(char* ptr,int len)=0;
  //快速排序
  virtual void QuickSort(char* ptr,int Low,int High)=0;
  //一个循环排序
  virtual void OneWhileSort(char* ptr,int len)=0;
};
//给他们一个获取我们子类对象的接口（算法实现的接口）
extern "C" ISort *GetCSort(void);
#endif

上面是一个抽象类，那么我们肯定要写一个能够实例化对象的类

Sort.h

#ifndef SORT_H
#define SORT_H
#include "SortInterface.h" 
class CSort:public ISort
{ 
 public:
  CSort(){}
  ~CSort(){}
  //冒泡排序
  virtual void BubbleSort(char* ptr,int len);
  //快速排序
  virtual void QuickSort(char* ptr,int Low,int High);
  //一个循环排序
  virtual void OneWhileSort(char* ptr,int len);
};
#endif

要实例化肯定要将函数实现 

#include "Sort.h"
ISort* GetISort(void)
{
   return (new CSort);
}


  //冒泡排序
void CSort::BubbleSort(char* ptr,int len)
{ 
  for(int i=0;i<len-1;i++)
  {
      for(int j=i+1;j<len;j++)
      {
          if(ptr[i]>ptr[j])
          {
              ptr[i]+=ptr[j];
              ptr[j]=ptr[i]-ptr[j];
              ptr[i]=ptr[i]-ptr[j];
          }
      }
  }
  return ;
}
  //快速排序
void CSort::QuickSort(char* ptr,int Low,int High)
{
   if(Low>High)
     return;
   char temp=ptr[Low];
   int tempLow=Low;
   int tempHigh=High;
   while(tempLow<tempHigh)
    {
      while(tempLow<tempHigh&&temp<=ptr[tempHigh])
         {
           tempHigh--;
         }
      char tempData=ptr[tempHigh];
      ptr[tempHigh]=ptr[tempLow];
      ptr[tempLow]=tempData;
      while(tempLow<tempHigh&&temp>ptr[tempLow])
         {
           tempLow++;
         }
      tempData=ptr[tempHigh];
      ptr[tempHigh]=ptr[tempLow];
      ptr[tempLow]=tempData;
    }
    QuickSort(ptr,Low,tempLow-1);
    QuickSort(ptr,tempLow+1,High);
    return;
}
//一个循坏排序
void CSort::OneWhileSort(char* Array,int len)
{
    int temp=0;
    int i=0;
    while (i < len)
    {  
        temp++;
        if (i == 0 || Array[i - 1] <= Array[i])
        {
            i+=temp;
            temp=0;
        }
        else
        {
            int t = Array[i];
            Array[i] = Array[i - 1];
            Array[i - 1] = t;
            i--;
        }
    }
    return;
}

好了 源码我们已经准备好了 ，接下来我们进入编译阶段

第一步：将我们的源代码编译成中间文件

g++ -c Sort.cpp -o test.o//-c便是我们要将后面的源文件编译成中间文件 -o就是给编译的目标文件取一个名字

第二步：将我们的中间文件编译成静态库

ar -rsc libtest.a test.o 

//r：在库中插入模块（替换）。当插入的模块名已经在库中存在，则替换同名的模块。如果若干模块中有一个模块//在库中不存在，ar显示一个错误消息，并不替换其他同名模块。默认的情况下，新的成员增加在库的结尾处，可以//使用其他任选项来改变增加的位置。【1】
//c：创建一个库。不管库是否存在，都将创建。
//s：创建目标文件索引，这在创建较大的库时能加快时间。（补充：如果不需要创建索引，可改成大写S参数；如

//果。a文件缺少索引，可以使用ranlib命令添加

貌似我们的库编译好了？对你没猜错，编译静态库就是这个简单。那么我们用一个测试代码试一下。

main.cpp

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include"SortInterface.h"//只需要我们给的接口就可以了

using namespace std;
int main()
{   
    ISort*TempRule =GetISort(); 
    char a[20]{12,1,9,2,0,11,7,19,4,15,18,5,14,13,10,16,6,3,8,17};
    TempRule->QuickSort(a,0,19);
    for(int i=0;i<20;i++)
       {
        printf("%d\n",a[i]);
       }
  return 0;
}

然后我们编译可执行文件

g++  main.cpp  libtest.a  -o  a.out

//注意libtest.a的路径

好了，大功告成，大家可以试一下了，下一篇我将讲动态库的编译与调用