头文件是用于声明函数、类等等的一些数据，当程序需要调用这个头文件的内容时候，只需要#include "file.h" 即可。事实上，c/cpp 支持分别编译，可以将一个程序的不同函数分在不同 .cpp 文件中，这时候，通过包含头文件的方式对函数进行链接就非常重要了。
假设有一个程序内有一个类为Class1 ，Class1内有函数 Class1,fn和~Classs1以及 int 变量 a 和 b，fn的作用是进行a++。如果单纯用一个 cpp 文件进行编写，那么这个文件就会很复杂。
示例程序如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#include <iostream>
class Class1
{
public:
Class1(int init){
a = init;
}
int fn(){
if (a < 50){
a++;
std::cout << "Varible a have plus 1." << std::endl;
}
return a;
}
~Class1(){
std::cout << "Now, varible a is " << a << std::endl;
}
private:
int a;
char b;
};
int main (int argc, char *argv[]) {
Class1 c1{40};
c1.fn();
c1.fn();
return 0;
}
|
如果将这个类分离到另外一个 cpp 文件，那么情况会好很多。
首先，我们先创建 class.h 和class.cpp
1
2
|
touch classs.h
touch class.cpp
|
头文件的主要作用就是声明，我们将以上程序的声明放置到 class.h 是这样的：
1
2
3
4
5
6
7
8
9
10
11
12
|
#pragma once
class Class1{
public:
Class1(int init);
int fn();
~Class1();
private:
int a;
int b;
};
|
只需要声明修饰，不需要完善内容结构，结构在 class.cpp中编写。这里的#pragma once是让编译器知道只需要编译一次，而当再次调用时如果已经编译了相同内容就跳过编译。
接下来就和原来差不多了。
在 class.cpp 中，只需要用作用域运算符::来引用就可以修饰函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#include "class.h"
#include <iostream>
Class1::Class1(int init){
Class1::a = init;
std::cout << "A is " << Class1::a << std::endl;
}
int Class1::fn(){
if (Class1::a < 50){
Class1::a++;
std::cout << "Varible a have plus 1." << std::endl;
}
return a;
}
Class1::~Class1(){
std::cout << "Now, varible a is " << a << std::endl;
}
|
如上述代码，首先需要 #include "class.h"以表明使用 class.h 内的声明(以后在 main.cpp也需要做如此的声明来链接代码)之后就是编写函数内容了，比如Class1::Class1(int init){}这个类构造函数的具体代码等等.
最后，我们要在 main.cpp 中应用我们编写的类 ,也是一样用 #include "class.h"，此时，定义完对象后用域操作符就可以引用函数啦：
1
2
3
4
5
6
7
8
|
#include "class.h"
int main (int argc, char *argv[]) {
Class1 c1{40};
c1.fn();
c1.fn();
return 0;
}
|
但是在 Linux 中，我们要对其进行编译就有些许技巧，比如要编译 main.cpp 和 class.cpp 我们可以用以下命令:
1
|
g++ main.cpp class.cpp -o ./main
|
输出如下:
1
2
3
4
|
A is 40
Varible a have plus 1.
Varible a have plus 1.
Now, varible a is 42
|