C++程序的编译过程
来源:互联网 发布:太阳花 知乎 编辑:程序博客网 时间:2024/06/07 05:05
转自http://www.cnblogs.com/zhaoxb1982/archive/2009/08/07/1540713.html
目前正在学习《C++ Templates》一书。在有了一个初步的概念以后,我觉得有必要了解一下模板的编译过程。而要了解模板的编译过程就必须从普通的C++应用程序开始。下面是我对C++应用程序的编译过程的理解。敬请指教!
一:一般的C++应用程序的编译过程。
一般说来,C++应用程序的编译过程分为三个阶段。模板也是一样的。
- 在cpp文件中展开include文件。
- 将每个cpp文件编译为一个对应的obj文件。
- 连接obj文件成为一个exe文件(或者其它的库文件)。
1.include文件的展开。
include文件的展开是一个很简单的过程,只是将include文件包含的代码拷贝到包含该文件的cpp文件(或者其它头文件)中。被展开的cpp文件就成了一个独立的编译单元。在一些文章中我看到将.h文件和.cpp文件一起看作一个编译单元,我觉得这样的理解有问题。至于原因,看看下面的几个注意点就可以了。
1):没有被任何的其它cpp文件或者头文件包含的.h文件将不会被编译。也不会最终成为应用程序的一部分。先看一个简单的例子:
2 // 注意,后面没有分号。也就是说,如果编译的话这里将产生错误。
3 void foo()
2):存在一种可能性,即一个cpp文件直接的或者间接的包括了多次同一个.h文件。下面就是这样的一种情况:
2 // 定义一个变量
3 int i;
4
5 // ===========test1.h===========
6 // 包含了test.h文件
7 #include "test.h"
8
9 // ===========main.cpp=========
10 // 这里同时包含了test.h和test1.h,
11 // 也就是说同时定义了两个变量i。
12 // 将发生编译错误。
13 #include "stdafx.h"
14 #include "test.h"
15 #include "test1.h"
16
17 void foo();
18 void foo();
19
20 int _tmain(int argc, _TCHAR* argv[])
21 {
22 return 0;
23 }
3):还要注意一点的是,include文件是按照定义顺序被展开到cpp文件中的。关于这个,请看下面的示例。
2 // 声明一个函数。注意后面没有分号。
3 void foo()
4
5 // ===========test1.h===========
6 // 仅写了一个分号。
7 ;
8
9 // ===========main.cpp=========
10 // 注意,这里按照test.h和test1.h的顺序包含了头文件。
11 #include "stdafx.h"
12 #include "test.h"
13 #include "test1.h"
14
15 int _tmain(int argc, _TCHAR* argv[])
16 {
17 return 0;
18 }
有的人也许看见了,上面的示例中虽然声明了一个函数,但没有实现且仍然能通过编译。这就是下面cpp文件编译时的内容了。
2.CPP文件的编译和链接。
大家都知道,C++的编译实际上分为编译和链接两个阶段,由于这两个阶段联系紧密。因此放在一起来说明。在编译的时候,编译器会为每个cpp文件生成一个obj文件。obj文件拥有PE[Portable Executable,即windows可执行文件]文件格式,并且本身包含的就已经是二进制码,但是,不一定能够执行,因为并不保证其中一定有main函数。当所有的cpp文件都编译好了之后将会根据需要,将obj文件链接成为一个exe文件(或者其它形式的库)。看下面的代码:
2 // 声明一个函数。
3 void foo();
4
5 // ============test.cpp=============
6 #include "stdafx.h"
7 #include <iostream>
8 #include "test.h"
9
10 // 实现test.h中定义的函数。
11 void foo()
12 {
13 std::cout<<"foo function in test has been called."<<std::endl;
14 }
15
16 // ============main.cpp============
17 #include "stdafx.h"
18 #include "test.h"
19
20 int _tmain(int argc, _TCHAR* argv[])
21 {
22 foo();
23
24 return 0;
25 }
简要的说来,编译main.cpp时,编译器不知道f的实现,所有当碰到对它的调用时只是给出一个指示,指示连接器应该为它寻找f的实现体。这也就是说main.obj中没有关于f的任何一行二进制代码。编译test.cpp时,编译器找到了f的实现。于是乎foo的实现[二进制代码]出现在test.obj里。连接时,连接器在test.obj中找到foo的实现代码[二进制]的地址[通过符号导出表]。然后将main.obj中悬而未决的jump XXX地址改成foo实际的地址。
现在做个假设,foo()的实现并不真正存在会怎么样?先看下面的代码:
2 //#include "test.h"
3
4 void foo();
5
6 int _tmain(int argc, _TCHAR* argv[])
7 {
8 foo();
9
10 return 0;
11 }
LINK : 没有找到 E:\CPP\CPPTemplate\Debug\CPPTemplate.exe 或上一个增量链接没有生成它;
再看下面的一个例子:
2 //#include "test.h"
3
4 void foo();
5
6 int _tmain(int argc, _TCHAR* argv[])
7 {
8 // foo();
9
10 return 0;
11 }
这里只有foo的声明,我们把原来的foo的调用也去掉了。上面的代码能编译通过。原因就是由于没有调用foo函数,main.cpp没有真正的去找foo的实现(main.obj内部或者main.obj外部),编译器也就不会在意foo是不是已经实现了。
二:模板的编译过程。
在明白了C++程序的编译过程后再来看模板的编译过程。大家知道,模板需要被模板参数实例化成为一个具体的类或者函数才能使用。但是,类模板成员函数的调用且有一个很重要的特征,那就是成员函数只有在被调用的时候才会被初始化。正是由于这个特征,使得类模板的代码不能按照常规的C++类一样来组织。先看下面的代码:
2 template<typename T>
3 class MyClass{
4 public:
5 void printValue(T value);
6 };
7
8 // =========testTemplate.cpp===========
9 #include "stdafx.h"
10 #include "testTemplate.h"
11
12 template<typename T>
13 void MyClass<T>::printValue(T value)
14 {
15 //
16 }
1 #include <iostream>
2 #include "testTemplate.h"
3
4 int main()
5 {
6 // 1:实例化一个类模板。
7 // MyClass<int> myClass;
8
9 // 2:调用类模板的成员函数。
10 // myClass.printValue(2);
11
12 std::cout << "Hello world!" << std::endl;
13 return 0;
14 }
1):我们将testTemplate.cpp文件从工程中拿掉,即删除testTemplate.cpp的定义。然后直接编译上面的文件,能编译通过。这说明编译器在展开testTemplate.h后编译main.cpp文件的时候并没有去检查模板类的实现。它只是记住了有这样的一个模板声明。由于没有调用模板的成员函数,编译器链接阶段也不会在别的obj文件中去查找类模板的实现代码。因此上面的代码没有问题。
2):把main.cpp文件中,第7行的注释符号去掉。即加入类模板的实例化代码。在编译工程,会发现也能够编译通过。回想一下这个过程,testTemplate.h被展开,也就是说main.cpp在编译是就能找到MyClass<T>的声明。那么,在编译第7行的时候就能正常的实例化一个类模板出来。这里注意:类模板的成员函数只有在调用的时候才会被实例化。因此,由于没有对类模板成员函数的调用,编译器也就不会去查找类模板的实现代码。所以,上面的函数能编译通过。
3):把上面第10行的代码注释符号去掉。即加入对类模板成员函数的调用。这个时候再编译,会提示一个链接错误。找不到printValue的实现。道理和上面只有函数的声明,没有函数的实现是一样的。即,编译器在编译main.cpp第10行的时候发现了对myClass.PrintValue的调用,这时它在当前文件内部找不到具体的实现,因此会做一个标记,等待链接器在其他的obj文件中去查找函数实现。同样,连接器也找不到一个包括MyClass<T>::PrintValue声明的obj文件。因此报告链接错误。
4):既然是由于找不到testTemplate.cpp文件,那么我们就将testTemplate.cpp文件包含在工程中。再次编译,在VS中会提示一个链接错误,说找不到外部类型_thiscall MyClass<int>::PrintValue(int)。也许你会觉得很奇怪,我们已经将testTemplate.cpp文件包含在了工程中了阿。先考虑一个问题,我们说过模板的编译实际上是一个实例化的过程,它并不编译产生二进制代码。另外,模板成员函数也只有在被调用的时候才会初始化。在testTemplate.cpp文件中,由于包含了testTemplate.h头文件,因此这是一个独立的可以编译的类模板。但是,编译器在编译这个testTemplate.cpp文件的时候由于没有任何成员函数被调用,因此并没有实例化PrintValue成员。也许你会说我们在main.cpp中调用了PrintValue函数。但是要知道testTemplate.cpp和main.cpp是两个独立的编译单元,他们相互间并不知道对方的行为。因此,testTemplate.cpp在编译的时候实际上还是只编译了testTemplate.h中的内容,即再次声明了模板,并没有实例化PrintValue成员。所以,当main.cpp发现需要PrintValue成员,并在testTemplate.obj中去查找的时候就会找不到目标函数。从而发出一个链接错误。
5):由此可见,模板代码不能按照常规的C/C++代码来组织。必须得保证使用模板的函数在编译的时候就能找到模板代码,从而实例化模板。在网上有很多关于这方面的文章。主要将模板编译分为包含编译和分离编译。其实,不管是包含编译还是分离编译,都是为了一个目标:使得实例化模板的时候就能找到相应的模板实现代码。大家可以参照这篇文章。
最后,作一个小总结。C++应用程序的编译一般要经历展开头文件->编译cpp文件->链接三个阶段。在编译的时候如果需要外部类型,编译器会做一个标记,留待连接器来处理。连接器如果找不到需要的外部类型就会发生链接错误。对于模板,单独的模板代码是不能被正确编译的,需要一个实例化器产生一个模板实例后才能编译。因此,不能寄希望于连接器来链接模板的成员函数,必须保证在实例化模板的地方模板代码是可见的。
上面只是我的个人理解。有不对的地方还请赐教!
- C程序的编译过程
- C程序的编译过程
- C程序的编译过程
- C程序的编译过程
- c程序的编译过程
- C程序的编译过程
- C程序的编译过程
- C程序的编译过程
- c程序的编译过程
- C程序的编译过程
- C程序的编译过程
- C程序编译过程
- C程序编译过程
- C程序编译过程
- C程序编译过程
- C程序编译过程
- C程序编译过程
- C程序编译过程
- 有了CSDN的博客了 可。呵呵
- java类库的阅读笔记_jdk1.7.0_40_java.util.Collections
- 通过邮件找回密码功能的实现
- Django 1.5.4 专题22 Signals
- [分享]未注册5位数字.cn
- C++程序的编译过程
- 从程序员到项目经理(一)
- 学习ARM9
- 原子stm32 mini开发板模版
- OpenLayer(Sphercial Mercator)
- Ubuntu中文目录下vim退出后乱码
- C#文件帮助类FoderHelper
- 这学期的计划以及上学期的总结
- 【进村记】品牌选择与如何鉴定你所购买的东西