一.静态库和动态库的创建与调用。
1.创建静态库：
static_test_sort.h
#define funtype int //变量类型
funtype Sel_sort(funtype *a, funtype len); //选择排序
funtype bub_sort(funtype *a, funtype len); //冒泡排序
funtype insert_sort(funtype *a, funtype len); //插入排序
funtype shell_sort(funtype *arr, funtype len); //希尔排序
funtype MergeSort(funtype arr[], funtype start, funtype end, funtype *temp); //归并排序
funtype QuickSort(funtype *arr, funtype start, funtype end); //快速排序
funtype HeapAdjust(funtype arr[], funtype i, funtype length); //堆排序准备
funtype HeapSort(funtype arr[], funtype length); //堆排序
static_test_sort.c
#include "kind_sort.h"
funtype bub_sort(funtype *a, funtype len)
{
int i, j;
for (i = 0; i < len; i++)
{
for (j = 0; j < len - i; j++)
{
if (a[j] > a[j + 1])
{
a[j] = a[j] ^ a[j + 1];
a[i + 1] = a[j] ^ a[j + 1];
a[j] = a[j] ^ a[j + 1];
}
}
}
return 1;
}
funtype Sel_sort(funtype *a, funtype len)
{
int i, j, minindex;
for (i = 0; i < len; i++)
{
minindex = i;
for (j = i + 1; j < len; j++)
{
if (a[j] < a[minindex])
{
minindex = j;
}
}
if (minindex != i)
{
a[i] = a[minindex] ^ a[i];
a[minindex] = a[minindex] ^ a[i];
a[i] = a[minindex] ^ a[i];
}
}
return 1;
}
funtype insert_sort(funtype *a, funtype len)
{
int i, preindex, cnt;
for (int i = 0; i < len; i++)
{
preindex = i - 1;
cnt = a[i];
while (preindex >= 0 && a[preindex] > cnt)
{
a[preindex + 1] = a[preindex];
preindex--;
}
a[preindex + 1] = cnt;
}
return 1;
}
funtype shell_sort(funtype *arr, funtype len)
{
int int_mp = len;
int i, j, k;
do
{
// 确定分组的增量
int_mp = int_mp / 3 + 1;
for (i = 0; i < int_mp; i++)
{
for (j = i + int_mp; j < len; j += int_mp)
{
if (arr[j] < arr[j - int_mp])
{
int temp = arr[j];
for (k = j - int_mp; k >= 0 && temp < arr[k]; k -= int_mp)
{
arr[k + int_mp] = arr[k];
}
arr[k + int_mp] = temp;
}
}
}
} while (int_mp > 1);
return 1;
}
funtype QuickSort(funtype *arr, funtype start, funtype end)
{
if (start >= end)
return 0;
int i = start;
int j = end;
// 基准数
int baseval = arr[start];
while (i < j)
{
// 从右向左找比基准数小的数
while (i < j && arr[j] >= baseval)
{
j--;
}
if (i < j)
{
arr[i] = arr[j];
i++;
}
// 从左向右找比基准数大的数
while (i < j && arr[i] < baseval)
{
i++;
}
if (i < j)
{
arr[j] = arr[i];
j--;
}
}
// 把基准数放到i的位置
arr[i] = baseval;
// 递归
QuickSort(arr, start, i - 1);
QuickSort(arr, i + 1, end);
return 1;
}
funtype MergeSort(funtype arr[], funtype start, funtype end, funtype *temp)
{
if (start >= end)
return 0;
int mid = (start + end) / 2;
MergeSort(arr, start, mid, temp);
MergeSort(arr, mid + 1, end, temp);
// 合并两个有序序列
int length = 0; // 表示辅助空间有多少个元素
int i_start = start;
int i_end = mid;
int j_start = mid + 1;
int j_end = end;
while (i_start <= i_end && j_start <= j_end)
{
if (arr[i_start] < arr[j_start])
{
temp[length] = arr[i_start];
length++;
i_start++;
}
else
{
temp[length] = arr[j_start];
length++;
j_start++;
}
}
while (i_start <= i_end)
{
temp[length] = arr[i_start];
i_start++;
length++;
}
while (j_start <= j_end)
{
temp[length] = arr[j_start];
length++;
j_start++;
}
// 把辅助空间的数据放到原空间
for (int i = 0; i < length; i++)
{
arr[start + i] = temp[i];
}
}
funtype HeapAdjust(funtype arr[], funtype i, funtype length)
{
// 调整i位置的结点
// 先保存当前结点的下标
int max = i;
// 当前结点左右孩子结点的下标
int lchild = i * 2 + 1;
int rchild = i * 2 + 2;
if (lchild < length && arr[lchild] > arr[max])
{
max = lchild;
}
if (rchild < length && arr[rchild] > arr[max])
{
max = rchild;
}
// 若i处的值比其左右孩子结点的值小，就将其和最大值进行交换
if (max != i)
{
int temp;
temp = arr[i];
arr[i] = arr[max];
arr[max] = temp;
// 递归
HeapAdjust(arr, max, length);
}
}
// 堆排序
funtype HeapSort(funtype arr[], funtype length)
{
// 初始化堆
// length / 2 - 1是二叉树中最后一个非叶子结点的序号
for (int i = length / 2 - 1; i >= 0; i--)
{
HeapAdjust(arr, i, length);
}
// 交换堆顶元素和最后一个元素
for (int i = length - 1; i >= 0; i--)
{
int temp;
temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
HeapAdjust(arr, 0, i);
}
}
2.创建调用文件
maintest.c
#include 3.注意顺序：
创建完静态库文件后：
gcc -c static_test_sort.c -o static_test_sort.o
ar rcs libstatic_test_sort.a static_test_srot.o
之后对
gcc -c maintest.c -o maintest.o
gcc -static maintest.o libstatic_test_sort.a -o maintest //(在同一文件下时)
gcc maintest.o -o maintest -static -lstatic_test_sort -L /home/test //(不同时)
说明：
1.静态库对应的头文件为功能函数的声明，不需要添加标准库的头文件，以及头文件定义信息等。
2.对应.c文件中为功能函数的实现步骤，只需要补全功能步骤以供调用。
3.对静态哭的编译与生成使用到的命令：
gcc -c xx.c -o xx.o
ar rcs libxx.a xx.o
libxx.a为静态库文件
4.调用静态库分两类，一类时在当静态库下调用文件
gcc -static main.o libxx.a -o main //(在同一文件下时)
另一类为不在静态库下调用文件
gcc main.o -o main -static -lxx -L (静态库所在的绝对路径) //(不同时)
同时在main应用中的调用的静态库的函数头文件也是其对应的绝对路径，需要统一。
5.对gcc编译参数的补充说明：
-c
只激活预处理,编译,和汇编,也就是他只把程序做成obj文件。
-s
只激活预处理和编译，就是指把文件编译成为汇编代码。
-e
只激活预处理,这个不生成文件, 你需要把它重定向到一个输出文件里面。
-o
制定目标名称, 默认的时候, gcc 编译出来的文件默认是 a.out, 可以改掉它
-g
只是编译器，在编译的时候，产生调试信息。
-static
此选项将禁止使用动态库，所以，编译出来的东西，一般都很大，也不需要什么动态连接库，就可以运行。
-share
此选项将尽量使用动态库，所以生成文件比较小，但是需要系统由动态库。
-O0 、-O1 、-O2 、-O3
编译器的优化选项的 4 个级别，-O0 表示没有优化, -O1 为默认值，-O3 优化级别最高。
-ggdb
此选项将尽可能的生成 gdb 的可以使用的调试信息。
-w
不生成任何警告信息。
-Wall
生成所有警告信息。
可通过vs软件生成静态库。
在window下生成的静态库文件是xx.lib。
在调用时：
#include 动态库的调用创建
对于动态库的创建：dynshate为动态库文件，test为应用文件，同样的test中需要含动态库的头文件（当在同一文件下时直接添加，否则以绝对地址方式调用）
1.gcc -shared -fpic dynshate.c -o libdynshate.so
2.gcc test.c libdynshate.so -o test
3.(1)mv libdynshate.so dynshate.h /usr/lib
(2)export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:xxx(对动态库所在位置进行pwd的绝对地址)
(3)vi ~/.bashrc 或 ~/.bash_profile 添加export ....xxx,并source bashrc
4.lld test 查看链接库的动态信息提示
静态和动态库的区别点后缀不同静态为libxxx.a ,动态为libxx.so