1.自己寫一個庫：和建工程是一樣的，但是建的專案是DLL檔案，然後再其工程下新增原始檔和標頭檔案，原始檔正常寫，標頭檔案是有要求的，__declspec(dllexport)的加入，程式在下面是給出的，所以往下讀，你會有所得的！！最終得到DLL,LIB，以及.h檔案（.h檔案只是一個路徑，在用的時候）
2.原始檔----庫檔案（.h檔案，lib檔案，dll檔案）
H檔案和lib和opencv中的新增過程一樣的，dll是要新增到debug資料夾中的，和.exe檔案要放在一起的，在opencv中dll是放在環境變數中的，H是包含標頭檔案中，lib是庫目錄中，lib中的lib是新增依賴項的，如果庫不是很大的話，可以新增到專案路徑下，直接在專案中#include”標頭檔案”，#pragma comment(lib,”lib所在的路徑下”)，這樣就可以用庫了，接著把dll複製到debug中去,整個工程就可以用庫了，lib和標頭檔案是編譯的時候用，dll是程式執行的時候用，所以要和.exe放在一起使用的。
本人在vs2017中把之前寫的排序庫進行了一次跨平臺編譯，然後這個工程我們就來建一個（工程的庫，供本人以後的開發使用的） Sortlib是已經編譯好了的工程檔案，接著把這個檔案來生成dll lib .h 檔案，

庫裡匯出標頭檔案：__declspec(dllexport) 放在標頭檔案中的，不用就不用匯出來的
生成成功之後dll和lib檔案在debug檔案中
然後就是在其他的工程中去使用他：和（2）中的操作是一致的
對於我這種比較差的人配置這個還真是挺難的，從寫原始碼，到生成自己的庫，然後測試自己的庫，真的挺多問題。
分成三部分完成的
（1）原始檔的編寫
（2）dll庫檔案的編寫（用裡面產生的dll,lib,標頭檔案（匯出的那部分）），
（3）測試，簡單的方法就是把庫檔案放在自己建的專案裡面，然後呼叫標頭檔案，呼叫庫檔案，最後執行時把dll放到.exe可執行檔案中去（放在一起的）
（4）對於非常大的庫，我們就和配置opencv那樣的進行配置（opencv是大庫所以它的配置是可以直接在網上看到的）

（1）.cpp檔案的編寫（是我自己總結的幾種排序的寫法）（也叫自己的排序庫）
#include “sortLib.h”
#include
#include
void show(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d\t", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/選擇排序，選擇關鍵字小的元素來進行交換

/
void chooseSort(int array[], int len)
{
int i = 0, j = 0, k = 0;
for (i = 0; i < len; i++)
{
k = i;
for (j = i; j < len; j++)
{
if (array[k] > array[j])
{
k = j; //對於關鍵字的排序
}
}
swap(array, i, k); //每次交換都不需要進行交換的，每一掃描找出最小元素的下標的
}
//show(array,len);
}
/選擇排序是一種穩定的排序演算法/
/插入排序的辦法，這種排序還是很厲害的是基於插入位置的一種插入演算法/
void insertSort(int array[], int len)
{
int temp = 0, i = 0, j = 0, k = 0;
for (i = 1; i < len; i++)
{
k = i;
temp = array[i];
for (j = i - 1; (j >= 0) && (array[j] > temp); j–)
{
array[j + 1] = array[j];
k = j; //找位置的程式
}
array[k] = temp; //把元素插入到找到的位置中間
}
// show(array,len);
}
/插入排序是一種穩定的排序演算法，2，2還是之前的2,2，對於資料元素是公平的/
/氣泡排序的用法，氣泡排序是一種在比較中進行交換的過程，第一趟進行n-1次排序。。。/
void bubbleSort(int array[], int len)
{
int i = 0, j = 0;
for (i = 0; i < len; i++)
{
for (j = len - 1; j > i; j–)
{
if (array[j] < array[j - 1])
{
swap(array, j, j - 1);
}
}
}
}
/氣泡排序也是一種穩定的排序演算法，對於排序是相對公平的/
/以上是簡版的氣泡排序演算法，對於簡版的排序演算法可以進行優化處理的/
//加一個程式控制變數
void bubbleOptimizeSort(int array[], int len)
{
int i = 0, j = 0;
int control = 1;
for (i = 0; i < len && control; i++)
{
control = 0;
for (j = len - 1; j > i; j–) //切記不能等於的
{
if (array[j] < array[j - 1])
{
swap(array, j, j - 1);
control = 1;
}
}
}
}
/優化引數的說明，優化引數是針對程式的執行來說的，如果一趟下來程式中並沒有發生交換就說明，這個陣列或者其他是排好順序的，優化引數在此時就決定不再進行程式的執行/
/快速排序的程式分解，快速排序是不穩定的對於快速演算法就是對序列進行劃分的過程的/
/進行一次劃分/
int onceQuickSort(int array[], int low, int high)
{
int temp = array[low];//把第一個元素取出來作為基準元素的
while (low < high)
{
while ((low < high) && (array[high] >= temp))
{
high–;
}
swap(array, low, high);
while ((low < high) && (array[low] <= temp))
{
low++;
}
swap(array, low, high);
}
//進行完這次的劃分之後會把基準元素劃分好啦
array[low] = temp;
return low;
}
/在這裡就完成了資料的第一次簡單的劃分/
/這裡是對子序列進行遞迴的操作的/
void Qsort(int array[], int low, int high)
{
if (low < high)
{
int pv = onceQuickSort(array, low, high);
Qsort(array, low, pv - 1);
Qsort(array, pv + 1, high);
}//這裡的操作都是在一個完整的空間裡面操作的在一個完整的空間裡面實現遞迴的操作過程
}
void QuickSort(int array[], int len)
{
Qsort(array, 0, len - 1);
}

/快速排序是一種不穩定的排序演算法,在這裡快速排序基於的原理就是不斷的劃分區間的/
/歸併排序的用法，基於的思想也是分組的思想，在兩個已經排好序的基礎上進行排序/
//兩組序列歸併成一組的子程式
void Merge(int array[], int des[], int low, int med, int high)
{
int i = low; //左邊序列的開始下標
int j = med + 1;//右邊序列的開始下標
int k = low;//空陣列的下標
while (i <= med && j <= high)
{
if (array[i] <= array[j])
{
des[k] = array[i];
k++;
i++;
}
else {
des[k] = array[j];
k++;
j++;
}
}
while (i <= med)
{
des[k++] = array[i++]; //左邊的序列長
}
while (j <= high)
{
des[k++] = array[j++]; //兩個序列的長度不等，右邊的序列長
}
//把兩個排好的子序列排成一個完整的序列
}
void MergeSort(int array[], int des[], int low, int high, int max)
{
if (low == high)
{
des[low] = array[high];
}
else {
int med = (low + high) / 2;
int* space = (int*)malloc(sizeof(int)*max);
if (space != NULL)
{
MergeSort(array, space, low, med, max);
MergeSort(array, space, med + 1, high, max);
Merge(space, des, low, med, high);
}
}
}
void MergeSortDisplay(int array[], int len)
{
MergeSort(array, array, 0, len - 1, len);
}
/歸併排序是一種不穩定的排序演算法，其排序思想是在遞迴的思想上進行的，對於兩組有序的序列，進行排序筆記本上有歸併排序的模型的/
/排序中的大神–希爾排序演算法簡單版本，基於插入排序的思想/
void shellSort(int array[], int len)
{
int i = 0, j = 0, gap = len;
do {
gap = gap / 3 + 1;//gap必須要收斂於1的
for (i = gap; i < len; i += gap)
{
int k = i;
int temp = array[k];
for (j = i - gap; (j >= 0) && array[j] > temp; j -= gap)
{
array[j + gap] = array[j];
k = j;
}
array[k] = temp;
}
} while (gap > 1);
}
/希爾排序是一種不穩定的排序演算法，基於最簡單的插入排序演算法/
/希爾排序高階實現形式 對每一組進行希爾排序的利用的，gap在變分的組數就是在變的/
void ShellSort(int array[], int len)
{
int i, j, k, temp, m, l;
int gap = len;
for (gap = len / 2; gap > 0; gap = gap / 2) //對gap進行收斂遞減的過程 如果最終能收斂到1也就是整個排序就是完美的
{
for (i = 0; i < gap; i++) //對於每一個gap分成gap組來進行插入排序
{
for (j = i + gap; j < len; j += gap) //每一組內進行排序的
{
if (array[j] < array[j - gap])
{
temp = array[j];
k = j - gap;
while (k >= 0 && array[k] > temp) {
array[k + gap] = array[k];
k = k - gap;
}
array[k + gap] = temp;
}

}
}
}
}
/希爾排序的原理是基於分組排序的原理進行的成功應用/
/希爾排序的自己實現方法/
void ShellSort1(int array[], int len)
{
int i, j, temp, gap, m, l;
for (gap = len / 2; gap > 0; gap = gap / 2) //最終一定要收斂到1的 ，不然演算法退步出來的
{
for (i = 0; i < gap; i++) //對於每一個gap都會把資料分成gap組來進行處理的
{
for (j = i + gap; j < len; j += gap) //對於每一組內進行的排序
{
int l = j;
temp = array[l]; //這一步是非常關鍵的，不然在之後的資料複製會出錯的，以後在多變數的程式中要注意的問題就是每一個變數的初值問題
for (m = j - gap; (m >= 0) && (array[m] > temp); m -= gap)
{
array[m + gap] = array[m];
l = m; ;
}
array[l] = temp;
}
}
}
}
/變數的初值問題 ，對於每一個變數不要突然的出現在某個位置上，一定要進行賦初值處理的/

以上就是整個原始檔的
2.下面是標頭檔案.h：最關鍵了
__declspec(dllexport) void show(int array[], int len);
__declspec(dllexport) void swap(int array[], int i, int j);
__declspec(dllexport) void chooseSort(int array[], int len);
__declspec(dllexport) void insertSort(int array[], int len);
__declspec(dllexport) void bubbleSort(int array[], int len);
__declspec(dllexport) void bubbleOptimizeSort(int array[], int len);
__declspec(dllexport) int onceQuickSort(int array[], int low, int high);
__declspec(dllexport) void Qsort(int array[], int low, int high);
__declspec(dllexport) void QuickSort(int array[], int len);
__declspec(dllexport) void Merge(int array[], int des[], int low, int med, int high);
__declspec(dllexport) void MergeSort(int array[], int des[], int low, int high, int max);
__declspec(dllexport) void MergeSortDisplay(int array[], int len);
__declspec(dllexport) void shellSort(int array[], int len);
__declspec(dllexport) void ShellSort(int array[], int len);
__declspec(dllexport) void ShellSort1(int array[], int len);
//匯出標頭檔案的方法：__declspec(dllexport)新增到標頭檔案之前的 在專案下重新生成在debug資料夾下就去看看dll,和lib檔案

3.把上面的原始檔和標頭檔案放到自己的工程中去，編譯就可以產生 LIB AND DLL

4.測試自己的寫的庫檔案，也就是相當於你呼叫別人的庫是一樣的，是不是感覺自己特別的牛逼！！哈哈測試程式碼如下：
#include “include\sortLib.h”
#pragma comment(lib,“include\sortDll.lib”)
int main(int argc, char *argv[])
{
int array[] = { 12,12,8,4,9,5,62,33 };
int len = sizeof(array) / sizeof(*array);
show(array, len);
ShellSort1(array, len);
show(array, len);
}
這裡呼叫的是自己庫中的希爾排序，自己測試下吧！！在寫程式碼的過程中要沉住氣！！