浅了解c/c++头文件、链接、动态和静态链接库

一个或几个c文件从源文件到可执行文件大致经历步骤如下

下面以具体例子说明一下各个阶段（本文用c++举例，事实上c/c++是一样的）

源文件

这是我用c++简单写的一个单链的实现（水平有限，算法爹轻喷ww)，部分参考单链表的基本操作C++

一共有三个文件

head.h用于声明函数/变量/类。这里不得不说一下声明（declaration）和定义（definition）的区别。

注意这里提到了两个概念，一个是"定义"，一个是"声明"。简单地说，"定义"就是把一个符号完完整整地描述出来：它是变量还是函数，返回什么类型，需要什么参数等等。而"声明"则只是声明这个符号的存在，即告诉编译器，这个符号是在其他文件中定义的，我这里先用着，你链接的时候再到别的地方去找找看它到底是什么吧。定义的时候要按 C++ 语法完整地定义一个符号（变量或者函数），而声明的时候就只需要写出这个符号的原型了。需要注意的是，一个符号，在整个程序中可以被声明多次，但却要且仅要被定义一次。试想，如果一个符号出现了两种不同的定义，编译器该听谁的？

也就是说.h文件通常只用于声明用到的函数和变量，在其他地方引用时只需include一下。这里就会有一个小问题，如果我们的头文件在很多地方被引用了，那就可能导致重复声明而编译报错。解决方法是

#ifndef xxx
#define xxx
// 函数/变量的声明
#endif

使用这样一个宏可以在第二次被引用的时候告诉编译器什么也别做。

完整的head.h如下，具体而言定义了Node类和List类

#ifndef LINKEDTABLE_HEAD_H
#define LINKEDTABLE_HEAD_H

class Node{
public:
    int value;
    Node* next;
    Node(int value,Node* next);
};

class List{
private:
    int length;
    Node* head;
public:
    List(Node*);           //初始化
    void insertHead(Node*);  //头插法
    void insertTail(Node*);  //尾插法
    Node* findByIndex(int);  //根据索引查找节点，并返回节点的指针，注意0返回头节点
    Node* findByValue(int);  //根据值查找节点，并返回节点的指针
    void deleteByIndex(int); //根据索引删除节点
    Node* deleteByNode(Node*); //根据node指针删除节点
    void deleteByValueOnce(int); //根据节点值删除第一个节点
    void deleteByValueAll(int);//根据节点值删除所有节点
    void editByIndex(int,int);   //根据索引修改节点的值
    void dump();
};
#endif //LINKEDTABLE_HEAD_H

这些函数/变量在声明之后，需要在一个地方实现。比如这里就是head.cpp（文件名不一定要是head）。

head.cpp

#include "head.h"
#include <iostream>
Node::Node(int value,Node* next){
    this->value=value;
    this->next=next;
}

List::List(Node* p) {
    this->head=p;
    this->length=1;
}
void List::insertHead(Node * p) {
    p->next=this->head;
    this->head=p;
    this->length++;
}
void List::insertTail(Node* p){
    Node* tail=this->findByIndex(this->length-1);
    tail->next=p;
    this->length++;
}
Node* List::findByIndex(int index) {
    if(index>length-1||index<0){
        std::cout<<"index error"<<std::endl;
        return 0;
    }
    Node* p=this->head;
    for(int cnt=0;cnt<index;cnt++){
        p=p->next;
    }
    return p;
}
Node* List::findByValue(int value){
    Node* p=this->head;
    for(int i=0;i<this->length;i++){
        if(p->value==value){
            return p;
        }
        p=p->next;
    }
    std::cout<<"not found"<<std::endl;
    return 0;
}
Node* List::deleteByNode(Node* p){
    if(!p->next){
        Node* newTail=this->findByIndex(this->length-2);
        free(newTail->next);
        newTail->next=0;
        this->length--;
        return newTail;
    }
    else if(p==this->head){
        Node* tmp=this->head;
        this->head=this->head->next;
        free(tmp);
        this->length--;
        return this->head;
    }
    else{
        p->value=p->value^p->next->value;
        p->next->value=p->value^p->next->value;
        p->value=p->value^p->next->value;
        Node* tmp=p->next->next;
        free(p->next);
        p->next=tmp;
        this->length--;
        return p;
    }
}
void List::deleteByIndex(int index){
    if(index>length-1||index<0){
        std::cout<<"index error"<<std::endl;
        return;
    }
    if(this->length==1){
        std::cout<<"You can't delete all nodes."<<std::endl;
        return;
    }
    deleteByNode(findByIndex(index));
}
void List::deleteByValueOnce(int value){
    Node* p=this->head;
    for(bool goon;;){
        if(p->value==value){
            deleteByNode(p);
            return;
        }
        if(!goon)break;
        goon=p->next?true:false;
        p=p->next;
    }
    std::cout<<"not found\n";
}
void List::deleteByValueAll(int value) {
    int tmpLength=length;
    Node* p=this->head;
    int deleted=0;
    for(bool goon=true;goon;){
        bool equal=false;
        goon=p->next?true:false;
        if(p->value==value){
            if(deleted+1==tmpLength){
                puts("You can't delete all nodes.");
                return;
            }
            p=deleteByNode(p);
            equal=true;
            deleted++;
        }
        p=equal?p:p->next;
    }
    if(deleted){
        std::cout<<"deleted "<<deleted<<" node(s)"<<std::endl;
    }
    else{
        std::cout<<"not found\n"<<std::endl;
    }
}
void List::editByIndex(int index,int value){
    if(index>length-1||index<0){
        std::cout<<"index error"<<std::endl;
    }
    this->findByIndex(index)->value=value;
}
void List::dump(){
    Node *p=this->head;
    for(int i=0;i<this->length;i++){
        printf("[%d] => [%d]\n",i,p->value);
        p=p->next;
    }
}

最后再写一个main.cpp，这是主程序的入口。这里用来和用户交互

main.cpp

#include <iostream>
#include "head.h"
using namespace std;
int main(){
    puts("input head node's value:\n");
    int headValue;
    cin>>headValue;
    List list(new Node(headValue,0));
    while(1){
        puts("1: insertHead\n2: insertTail\n3: findByIndex\n4: findByValue\n5: deleteByIndex\n6: deleteByValueOnce\n7. deleteByValueAll\n8. editByIndex\n9. dump\n10. exit");
        int choice;
        cin>>choice;
        switch(choice){
            case 1:{
                cout<<"input value:\n";
                int value;
                cin>>value;
                list.insertHead(new Node(value,0));
                break;
            }
            case 2:{
                cout<<"input value:\n";
                int value;
                cin>>value;
                list.insertTail(new Node(value,0));
                break;
            }
            case 3:{
                cout<<"input index:\n";
                int index;
                cin>>index;
                cout<<list.findByIndex(index)<<endl;
                break;
            }
            case 4:{
                cout<<"input value:\n";
                int value;
                cin>>value;
                cout<<list.findByValue(value)<<endl;
                break;
            }
            case 5:{
                cout<<"input index:\n";
                int index;
                cin>>index;
                list.deleteByIndex(index);
                break;
            }
            case 6:{
                cout<<"input value:\n";
                int value;
                cin>>value;
                list.deleteByValueOnce(value);
                break;
            }
            case 7:{
                cout<<"input value:\n";
                int value;
                cin>>value;
                list.deleteByValueAll(value);
                break;
            }
            case 8:{
                cout<<"input index value:\n";
                int index,value;
                cin>>index>>value;
                list.editByIndex(index,value);
                break;
            }
            case 9:{
                list.dump();
                break;
            }
            case 10:{
                goto EXIT;
            }
            default:{
                puts("?\n");
                break;
            }
        }
    }
    EXIT:
    return 0;
}