一、环境介绍

我目前使用的是ubuntu的16.04版本，所以的话这篇文章所有的截图都来自于ubuntu下的终端，个人的话推荐不要装16.04，或者说不要装ubuntu，centos相对于它更加稳定（前提是你能够接受那种丑爆了的桌面）。我用ubuntu的时候wifi就经常炸，各种奇葩的连不上或者说一直连，然后还是连不上。

这个时候推荐使用下面的命令：

sudo service network-manager restart```
不过这个命令有时候还是不好使，所以只能是重启，总的来说这就很尴尬了，所以大家懂的···

##二、编译器
***
gcc是linux下自带的编译器，其功能可以说很强大，可以编译c，c++，java等多门语言，不过这里我讲的是关于c语言编译的时候的一些使用方法。在此之前，你至少需要知道下面的一些基本知识，然后后面的一些命令才好进行讲解。
#####（一）基础知识
-  从你写好的代码到生成最终的可运行文件，大致分为以下几步：
 - 对源文件进行预处理，处理除#pragma以外以#号开头的命令，去除文件中的空格，注释，添加行号和文件标识（在生成调试文件时有用）。
 - 对处理过的文件进行编译，对语法进行解析，在进行相应的优化后，生成汇编代码，但是生成的是AT&T语法格式的汇编代码，而不是intel的。
 - 将汇编代码通过几乎是直接翻译的方式生成机器码，然后你打开文件就会看到一堆二进制码。
 - 最后一步链接，就是将生成的二进制文件与静态库链接或者做动态库的链接标记。如果说没有自己创建库文件，这一步可以由编译器自动完成。
- 库文件
 - 库文件分为静态库和动态库。
 - 库文件在linux下为.a或.so文件，它们的名字以lib开头，是经过编译了的源文件，它在生成时需要有一个头文件(.h)标注其所含有的函数以及这些函数的类型定义，同时需要有一个源文件(.c)，实现所有的函数。比如： 

calc.h:
double aver(double, double);
double sum(double, double);```

calc.c:
double aver(double num1, double num2) 
{
        return (num1+num2)/2;
}
double sum(double num1, double num2)
{
        return num1+num2;
}```
 - 静态库在编译的时候会把代码放入程序中，而动态库则是在程序中留下调用的链接，等到程序运行的时候再将动态库加载进入内存进行使用，所以对于同样的程序，使用动态库会使程序文件本身占空间更少。
 - 动态库可以多个程序共用，而只占一份的空间。而静态库本身是不共享的，也就是说一个程序要使用，就要自己留有一份代码。
- gcc编译器可以控制编译的过程，通过在终端（terminal）中输入不同的命令，可以生成从源文件到可运行程序间的各种文件。
 - .s汇编语言文件
 - .o二进制文件
 - .i仅仅进行预处理的文件
 - .a静态库文件
 - .so动态库文件

#####（二）gcc基础命令
gcc的命令超过了100条，所以这里仅仅只是列举一些常常用到的命令，其余的命令会在后面需要时再列举。这里我用到了一个很简单的hello.c作为例子进行讲解。

include <stdio.h>

int main()
{
printf("hello world");
return 0;
}```

• 直接生成一个可以运行的文件

gcc hello.c```
这个时候你应该可以在当前的目录下找到a.out文件，因为在命令中没有指定最终生成的文件名，所以会输出一个带有默认文件名的文件。如果你想指定生成文件的名字，可以用-o命令。

gcc hello.c -o hello```
这样就可以生成一个hello的可运行程序，最后你需要做的就是再输入下面的命令让程序运行起来。

./hello```

- 生成一个仅仅进行过预处理的文件

gcc -E hello.c -o hello.i```
这里的-E命令告诉编译器在预处理后就停止，至于hello.i你可以改成别的名字，只是一般习惯于把预处理文件的后缀名命名为i。这个时候打开文件，你可以看到所有的stdio.h中的内容都导入到了hello.i中。

• 对预处理过的文件进行编译

gcc -S hello.i -o hello.s```
这里注意是大写的S，等你再次打开文件的时候，熟悉的c代码就变成了汇编代码，同样的，.s文件常常表示汇编语言文件。

- 将汇编代码翻译为二进制代码

gcc -c hello.s -o hello.o```
这个时候你写的源文件的转换就已经结束了，但是这个时候的文件还不能使用，因为这个文件还没有和库文件进行链接，许许多多的函数在头文件中只有定义，如果你要使用这些函数，就需要与动态库或者静态库进行链接。

• 进行链接

gcc hello.o -o hello```
将二进制文件链接，最终生成可以运行的hello文件。

实际上，如果你只想要自定义链接过程，你可以从源文件开始，直接生成没有链接的二进制文件，命令和上面的差不多

gcc -c hello.c -o hello.o```
上面的命令包括-c -E -S其实都是停止命令，意思是告诉编译器在某一步骤停下来，所以说gcc会自动判断目前文件所在的步骤，你需要做的就是告诉编译器怎么停下来。

（三）动态库和静态库

这里主要是讲在编译的时候使用库文件，制作库文件只是简单说一下，制作静态库和动态库的制作和gcc的关系并不是很大。如果你要生成静态库，你需要的东西有：你的.o文件和库的头文件。然后你需要运行的命令如下：

ar rc libmylib.a mylib.o```
如果你的库文件由多个.o文件组成，你只需要把.o文件都列出来就ok了

ar rc libmylib.a mylib1.o mylib2.o```
完成后你的目录下就会生成一个libmylib.a的文件，需要注意到的是，不论是动态库还是静态库都需要以lib作为命名的前缀。然后生成动态库的命令要稍微长一些：

gcc -shared -o libmylib.somylib1.o mylib2.o```
说完了怎么制作，就要说说怎么用了，如果你要使用静态库，那么原本的编译命令中仅仅需要加上几个字母：

gcc test.c -lmylib -L . -o test```
需要注意的是第一个-l是库名，但是省略了lib这个前缀和.a的扩展名，第二个-L是说明编译器寻找库的位置，‘.’代表了当前文件夹，如果在别的文件夹寻找，则可以用正常的地址说明（比如‘..’代表上一个文件夹，别的的话可以用绝对地址和相对地址）。最后如果你要使用动态库的话，就自己左转百度吧，因为那个用起来比较麻烦，需要设置系统的寻找路径，如果只是简单的程序，静态库就足够了。

下面是我做的一个简单的例子，演示了上面的过程，代码拙劣，希望不要笑话我（我只是个学生），当然有什么建议还是希望指出。

2333.png

这个是最早的三个源文件

stack.h是用来后期给引用库文件的程序include的，里面存放了函数的原型和数据结构

stack.h

#pragma once
#ifndef STACK_INTERFACE
#define STACK_INTERFACE
typedef struct {
    char *base;
    char *top;
    int stack_size;
    int ele_size;
}Stack;
Stack* stackInit(int ele_size);
int stackDes(Stack *stack);
int stackPop(Stack *stack, void *value);
int stackPush(Stack *stack, void *value);
int stackGetTop(Stack *stack,void *value);
int stackEleNum(Stack *stack);
#endif

stackBase.h主要是存放了一些基本定义和宏函数

stackBase.h
//基本定义
#include <stdio.h>
#include <stdlib.h>

#pragma once

#ifndef JUDGEMENT
#define JUDGEMENT
#define YES 1;
#define NO 0;
#endif

#ifndef STACK_ERROR
#define STACK_ERROR
#define OVERFLOW -1
#define STACK_EMPTY -2
#endif

#ifndef STACK_INI
#define STACK_INI
#define STACK_INIT_SIZE 40
#define STACK_INCREMENT_SIZE 40
#endif

#ifndef STACK_STRUCT
#define STACK_STRUCT
typedef struct {
    char *base;
    char *top;
    int stack_size;
    int ele_size;
}Stack;
#endif

stackBase.h
//用于扩展栈的大小
#ifndef STACK_BASE_FUNC
#define STACK_BASE_FUNC

/*
 *@param char* _INCRE_BASE_
 *@param char* _INCRE_TOP_
 *@param int   _INCRE_STACK_SIZE_
 *@param int   _INCRE_STACK_ELE_SIZE_
 *
 */
#define stackIncre(_INCRE_BASE_, _INCRE_TOP_, _INCRE_STACK_SIZE_,    \
                    _INCRE_STACK_ELE_SIZE_)                         \
({                                                                  \
    int _INCRE_RETURN_;                                         \
    _INCRE_BASE_ = realloc(_INCRE_BASE_, _INCRE_STACK_SIZE_ +        \
            STACK_INCREMENT_SIZE * _INCRE_STACK_ELE_SIZE_);     \
    if(_INCRE_BASE_) {                                              \
        _INCRE_TOP_ = _INCRE_BASE_ + _INCRE_STACK_SIZE_;              \
        _INCRE_STACK_SIZE_ += STACK_INCREMENT_SIZE *                  \
        _INCRE_STACK_ELE_SIZE_;                                    \
        _INCRE_RETURN_ = 0;                                        \
    } else {                                                          \
        _INCRE_RETURN_ = OVERFLOW;                                  \
    }                                                                \
    _INCRE_RETURN_;                                                \
})                  

stackBase.h
//检查栈是否为空
/*
 *@param char* _EMPTY_BASE_ 
 *@param char* _EMPTY_TOP_
 *
 */
#define stackEmpty(_EMPTY_BASE_, _EMPTY_TOP_)  \
({                                            \
    (_EMPTY_BASE_ == _EMPTY_TOP_) ? 1 : 0;     \
})

stackBase.h
//检查栈是否已满
/*
 *@param char* _FULL_BASE_
 *@param char* _FULL_TOP_
 *@param int   _FULL_STACK_SIZE_
 *
 */
#define stackFull(_FULL_BASE_, _FULL_TOP_, _FULL_STACK_SIZE_)   \
({                                                             \
    (_FULL_TOP_ - _FULL_BASE_ == _FULL_STACK_SIZE_) ? 1 : 0;     \
})
#endif

stackBase.h
//向栈中插入数据
#ifndef DATA_HANDLE
#define DATA_HANDLE

/*
 * Insert data into stack.
 *
 * @param char* _IN_TOP_
 * @param char* _IN_DATA_ 
 * @param int   _IN_ELE_SIZE_
 *
 */
#define stackDataIn(_IN_TOP_, _IN_DATA_, _IN_ELE_SIZE_)  \
do {                                                     \
    int _IN_TEMP_COUNT_ = 0;                             \
    while(_IN_TEMP_COUNT_++ < _IN_ELE_SIZE_) {           \
        *(_IN_TOP_)++ = *(_IN_DATA_)++;               \
    }                                                   \
} while(0)

stackBase.h
//删除栈中的数据
/*
 * Delete data from stack
 *
 * @param char* _OUT_TOP_
 * @param char* _OUT_DATA_
 * @param int   _OUT_ELE_SIZE_
 *
 */
#define stackDataOut(_OUT_TOP_, _OUT_DATA_, _OUT_ELE_SIZE_)  \
do {                                                        \
    int _OUT_TEMP_COUNT_ = 0;                               \
    (_OUT_DATA_) += _OUT_ELE_SIZE_;                       \
    while(_OUT_TEMP_COUNT_++ < _OUT_ELE_SIZE_) {             \
        *--(_OUT_DATA_) = *--(_OUT_TOP_);                    \
    }                                                       \
} while(0)
#endif

最后的.c文件放了真正的函数

stackInterface.c

#include "stackBase.h"
//初始化一个栈
Stack* stackInit(int ele_size) 
{
    Stack *init = (Stack *)malloc(sizeof(Stack));
    if(init->base = (char *)malloc(ele_size * STACK_INIT_SIZE)) {
        init->stack_size = ele_size * STACK_INIT_SIZE;
        init->top = init->base;
        init->ele_size = ele_size;
    } else {
        init->top = init->base = 0;
        init->stack_size = 0;
        init->ele_size = 0;
    }
    return init;
}

stackInterface.c
//将元素出栈
int stackPop(Stack *stack, void *value) 
{
    char *cvalue = (char *)value;
    int empty = stackEmpty(stack->base, stack->top);
    if(empty) {
        return STACK_EMPTY;//stack_empty
    }
    stackDataOut(stack->top, cvalue, stack->ele_size);
    return 0;
}

stackInterface.c
//将元素入栈
int stackPush(Stack *stack, void *value)
{
    char *cvalue = (char *)value;   
    if(stackFull(stack->base, stack->top, stack->stack_size)) {
        if(stackIncre(stack->base, stack->top, stack->stack_size, stack->ele_size)) {
            return OVERFLOW;
        }
    }
    stackDataIn(stack->top, cvalue, stack->ele_size);
    return 0;
}

stackInterface.c
//获取栈顶元素而不出栈
int stackGetTop(Stack *stack, void *value)
{
    char *cvalue = (char *)value;
    if(stackEmpty(stack->base, stack->top)) {
        return STACK_EMPTY;//stack_empty
    }
    stackDataOut(stack->top, cvalue, stack->ele_size);
    stack->top += stack->ele_size;  
    return 0;
}

//释放栈空间
void stackDes(Stack *stack)
{
    free(stack->base);
    stack->base = stack->top = 0;
    stack->stack_size = 0;
}

//计数栈中元素的个数
int stackEleNum(Stack *stack)
{
    return (stack->top - stack->base) / stack->ele_size;
}

这些代码写完了之后，依次使用如下的命令

gcc -c stackInterface.c -O2
ar rc libstack.a stackInterface.o

就会生成一个静态库（不要在意Makefile文件，下一节讲）

23333.png

然后如果哪一天要用到这个库了，记得在程序里面包含stack.h这个头文件然后按照上面的命令就ok了。