extern｜LOFTER（乐乎） - 让兴趣，更有趣
LOFTER for ipad —— 让兴趣，更有趣
下载移动端
关注最新消息
&nbsp&nbsp被喜欢
&nbsp&nbsp被喜欢
{list posts as post}
{if post.type==1 || post.type == 5}
{if !!post.title}${post.title|escape}{/if}
{if !!post.digest}${post.digest}{/if}
{if post.type==2}
{if post.type == 3}
{if !!post.image}
{if post.type == 4}
{if !!post.image}
{if !!photo.labels && photo.labels.length>0}
{var wrapwidth = photo.ow < 500?photo.ow:500}
{list photo.labels as labs}
{var lbtxtwidth = Math.floor(wrapwidth*(labs.ort==1?labs.x:(100-labs.x))/100)-62}
{if lbtxtwidth>12}
{if !!labs.icon}
{list photos as photo}
{if photo_index==0}{break}{/if}
品牌${make||'-'}
型号${model||'-'}
焦距${focalLength||'-'}
光圈${apertureValue||'-'}
快门速度${exposureTime||'-'}
ISO${isoSpeedRatings||'-'}
曝光补偿${exposureBiasValue||'-'}
镜头${lens||'-'}
{if data.msgRank == 1}{/if}
{if data.askSetting == 1}{/if}
{if defined('posts')&&posts.length>0}
{list posts as post}
{if post_index < 3}
{if post.type == 1 || post.type == 5}
{if !!post.title}${post.title|escape}{/if}
{if !!post.digest}${post.digest}{/if}
{if post.type == 2}
{if post.type == 3}
{if post.type == 4}
{if post.type == 6}
{if drlist.length>0}
更多相似达人：
{list drlist as dr}{if drlist.length === 3 && dr_index === 0}、{/if}{if drlist.length === 3 && dr_index === 1}、{/if}{if drlist.length === 2 && dr_index === 0}、{/if}{/list}
暂无相似达人，
{if defined('posts')&&posts.length>0}
{list posts as post}
{if post.type == 2}
{if post.type == 3}
{if post.type == 4}
{if post.type == 6}
this.p={ currentPage:1,pageNewMode:true,isgooglead3:false,ishotrecompost:false,visitorId:0, first:'',tag:'extern',recommType:'new',recommenderRole:0,offset:8,type:0,isUserEditor:0,};全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是怎么知道的？
全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是怎么知道的？
区别就是作用域的区别，局部变量局部可见，全局变量，所有参与链接的模块都可以通过extern来操作该变量.
内部定义的非静态变量都是局部变量了
全局变量：在函数外部定义的非静态变量就是全局变量了
操作系统不需要知道谁是局部，谁是全局的。编译器根据变量定义的位置，类型来判断是全局的还是局部的变量
生命周期，访问范围
数据段，栈
操作系统为什么需要知道？（可执行文件格式
编译器根据声明的位置
全局变量为外部变量,其作用域是从定义点到程序结束..
局部变量就表示局限于某个作用域的变量，它可以在函数内以函数作为作用域，可以在for\while\if语句中，以语句块作为作用域，还可以在namespace中，以命名空间作为作用域.
在操作系统中,全局变量存储在内存的静态存储区域,而局部变量存放在内存的栈区.
全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是怎么知道的？
全局变量和局部变量的区别是作用域不同,全局变量从定义位置开始到程序结束,而局部变量只限定义的函数内可使用,全局变量在数据段,而局部变量在栈,局部变量在函数结束时内存空间就被系统收回,所以要返回的数组或字符串不要用局部变量定义.extren和在main()函数外定义的变量都称为全局变量,操作系统和编译器从定义变量为变量分配内存时,从变量的定义和存储区域来分别局部变量和全局变量.
这是编程之基本啊~~，1楼正解！
全局都放在静态存储区，局部一般临时分配在栈里，生命周期到，自动释放内存！
去看下函数中的变量，auto,static,extern,register!~~
操作系统和编译器通过内存分配的位置来知道的全局变量分配在全局数据段，并且在程序被运行的时候就被加载。
编译器通过语法词法的分析，判断出是全局变量还是局部变量。如果是全局变量的话，编译器在将源代码翻译成二进制代码时就为全局变量分配好一个虚拟地址
(windows下0x以上的地址，也就是所说的全局区)，所以程序在对全局变量的操作时是对一个硬编码的地址操做。
局部变量的话，编译时不分配空间，而是以相对于ebp或esp的偏移来表示局部变量的地址，所以局部变量内存是在局部变量所在的函数被调用时才真正分配。以汇编的角度来看：函数执行时，局部变量在栈中分配，函数调用完毕释放局部变量对应的内存，另外局部变量可以直接分配在寄存器中。
操作系统通过变量的分配地址就可以判断出是局部变量和全局变量。
本文来自CSDN博客，转载请标明出处：
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。关于c++中用extern引用的变量类型与定义类型不一致的一个疑问？ - 知乎82被浏览7370分享邀请回答#include "stdio.h"
extern long i;
extern void printfi();
int main() {
i = 239084;
printfi();
然后b.c#include "stdio.h"
int i = 690;
int f = 100;
void printfi() {
printf("%d\n", i);
printf("%d\n", f);
在64的环境下, gcc-4.9, 输出:
可见f被不可预期的给修改了..----后记--------题主又追问了我一个问题: "请教一下，既然有这种隐患，对于规则4，为什么链接器不报错呢？这是有什么特殊的应用场景吗？"说实话, 这是个很好的问题, 他要是不问, 我还真的没有考虑过这个问题..... 以下是我对这个问题的推断,
有不正确的欢迎指正:我们把题主的问题换一下: "linker能不能实现在:如果发现一个强符号, 和一个弱符号, 在他们尺寸不匹配的时候, 产生warning".那么首先, 我们来看, linker作用的目标是目标文件(.o),
那核心的点就在于,
我们能不能在目标文件中得到extern long i的"类型(占用内存多少)"的信息呢?以a.c 为例,
gcc -c a.c && objdump -x a.o:SYMBOL TABLE:
df *ABS* 0000 a.c
.text 0000 .text
.data 0000 .data
.bss 0000 .bss
.note.GNU-stack 0000 .note.GNU-stack
.eh_frame 0000 .eh_frame
.comment 0000 .comment
F .text 0020 main
*UND* 0000 i
*UND* 0000 printfi
未定义的符号, 并没有SIZE信息, 也就说, Linker不知道i到底申明是个什么类型, 所以....此路不通. (实际上, extern仅仅是给了编译器一个提示, 这个信息只是用在编译期)但是如果我们把a.c中的extern去掉, 再次编译:$ gcc -c a.c && objdump -x a.o
SYMBOL TABLE:
df *ABS* 0000 a.c
.text 0000 .text
.data 0000 .data
.bss 0000 .bss
.note.GNU-stack 0000 .note.GNU-stack
.eh_frame 0000 .eh_frame
.comment 0000 .comment
O *COM* 0008 i
F .text 0020 main
*UND* 0000 printfi
可以看到, 此时i是已经定义的符号(弱), 有size信息.那么此时link的时候就可以得到警告信息了:$ gcc -Wl,--warn-common
/tmp/ccdYhCJV.o: warning: definition of `i' overriding common
/tmp/ccY3DiiS.o: warning: common is here
/usr/bin/ld: Warning: alignment 4 of symbol `i' in /tmp/ccdYhCJV.o is smaller than 8 in /tmp/ccY3DiiS.o
/usr/bin/ld: Warning: size of symbol `i' changed from 8 in /tmp/ccY3DiiS.o to 4 in /tmp/ccdYhCJV.o
好吧, 我今天真的是有点闲了.......... :)6322 条评论分享收藏感谢收起#include &iostream&
using namespace std;
int main()
int x=690;
double y=*(double*)(&x);
cout&&y&&endl; //3.4
cout&&x&&endl; //690
至于为什么是3.4
而题主误认为是0，是因为690对应的二进制序列转化成double类型是一个denormalized number，不是普通的含有尾数和阶码的normalized number。119 条评论分享收藏感谢收起查看更多回答c++高级---C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间以及编译器编译链接过程,C++编译链接过程 - c++ - ITkeyowrd
c++高级---C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间以及编译器编译链接过程,C++编译链接过程
编译单元，一个.cc，或.cpp作为一个编译单元.生成.o 2.
普通数据类型的定义，声明，函数的定义声明（类函数是一样的) //变量是声明，并未实
C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间 转自：/rocketfan/archive//1577361.html首先说我的补充：（对声明和定义的深入理解和总结） 关于声明和定义，具体指类、函数和变量（或对象）的声明和定义。（这里讨论的变量和函数都是全局的，不是类成员） 相同点：对编译器来说都是符号（编译器也只能识别他是个符合），声明就会在符合表中留下一列等待填充的空白，即不完整的等待填充一行，而定义就是符合表中完整的一行。在编译cpp成obj时，这里面变量、函数和类三种东西看成并列地位，即都是一个名字，符号表中的一列（可以先简单认为obj的符号表中只有两列即符号名字和地址） 不同点，在使用上这三种符合的声明和定义有所区分：【定义类和变量是原子性，定义类不是原子性，还要用这个类去定义别的东西】 （1）对于变量，由于变量的定义和声明是同一语句如 所以规定声明必须使用extern关键字以区别是声明而不是定义。 （2）对于函数，由于定义有个大括号包住的函数体，而声明没有大括号的函数体，所以它的声明和定义不需要多余的如extern关键字，即带大括号的是定义，不带的是声明。 （3）对与类，在形式上和函数一样，名子带上大括号就是定义（定义一个类型），不带大括号的是声明。但他有特殊之处，即不能先声明类（即不带大括号），然后定义这个声明的类的实例，再在后面或在其它cpp文件中定义具体的类，而变量和函数是可以先声明然后在链接的时候从其它文件中找的。 类之所以不能这样干，是因为，定义一个东西的干的事情主要就是为这个东西分配具体大小的内存，如果先声明一个类，然后定义这个类的实例，编译时（还没链接），就无法确定给这个实例到底分配多大的内存空间。变量和函数可以这样干是因为不需要再定义这两个东西的实例，即他们两个本事就是原子性的实体了，不需要用他们去创建一个原子实体。从上面分析可以看出，只要不涉及分配内存的事情，都可以先声明类，然后使用类，定义类在后面或在其它cpp文件中，实际上类的声明主要用在先声明，然后定义这个声明好的类的指针或引用（这个两个东西实体一般都固定分配4个字节）。关于类的声明和定义参见：http://blog.csdn.net/abc/article/details/7599466正是因为类的这个方面的特殊性，所以规定类的定义可以在多个cpp中，编译器不检查这中冲突（不得不这样做），而变量和函数是不行的（有的书上说类定义不占内存空间而函数和变量定义占内存空间，我认为这中说法不太好，实际上类和函数都在代码区也占内存空间，变量在数据区）。使用时也是把类定义在一个头文件中，在不同的cpp中展开，即完成了在不同的cpp中定义同一个类。我进一步猜测，也正因为这样，类定义体中不能像c#或java那样直接包含成员变量的定义并初始化，实际上类定义体中的所有东西都被认为是声明（要不然的话定义类的同时就会定义一堆其它的东西，就乱了，类体的作用就是为了描述定义这个类的实例时要分配多大的内存空间），即使函数实现在了类体中也被默认是inline内联的函数（对外不导出，也就是说其它cpp中看不见）。当然如果都用inline浪费空间，所以常常把函数声明写在类体中（达到描述这个类的作用就行了），而把成员函数具体定义（包括函数体）放在和这个类定义的头文件对应的cpp文件中，这也是为什么c++在定义类的时候分头文件和cpp文件，甚至有的书上说头文件中是类的声明，cpp文件中是类的实现（当然这种说法我也不很认同，他没分清是类的定义还是类体中东西的定义，严格的说头文件是类体中所有东东都必然是声明，cpp中是所有类体中东东的实现，类的实现完全可以不要，完全可以把函数全部称为inline的，完全可以把成员变量在构造函数被调用的时候分配内存并填充数据。类的定义就是类名加上大括号，所以类的定义都在头文件中，cpp才是这个类定义所在的头文件的附属，因为完全可以不要cpp而把函数实现都写成inline的）。 也正是因为类的这个方面的特殊性，类定义（类名加上大括号）中的所要成员变量都不能直接初始化，因为他们被认为是声明（虽然没有extern），只起描述这个类的作用。对于类中的静态成员变量和常量成员变量也是先声明，然后在cpp中定义静态变量和常变量并初始化（这里要注意声明static和const的变量不用初始化，而定义这两个东西的时候必须同时初始化，引用和他们两个类似）说了这么多，有点绕，简单点可以认为，类定义体中（即大括号中）包含的全部是其它实体的描述，不能定义类的同时定义了其它的东西（个别少见情况除外，但不违背这里描述的原理），在使用类的成员时，再根据这个描述去其它obj中找到对应的实体。而包含在类体中的成员就看成是个描述（或就是个头衔名），这个描述具体定义在外部，只不过定义在外部的成员的名字都加上了一个姓：类名。从编译器和连接器的角度来看，这个头衔名包含在类体中的姓类名的成员函数（或变量）和全局的函数（或变量）没什么区别，都是函数（或变量）。而类定义体中也不是定义了新的东西，他只不过包含了在其它地方定义好了的东西的描述或引用头衔而已。总之类定义就是描述作用（这个描述就是给new关键字看的），描述这个类的实例将占多大内存，将具有什么功能而已。类体中并没有定义新的东西，类体也是个外包，包含了在其它地方定义好了的东西的描述。下面是原网页的内容：1.编译单元，一个.cc，或.cpp作为一个编译单元.生成.o 2.普通数据类型的定义，声明，函数的定义声明（类函数是一样的) //变量是声明，并未实际分配地址，未产生实际目标代码void print(); // 函数声明，未产生实际目标代码如 int x = 3 ; void print() {}; //均为定义产生了实际目标代码。 声明不产生实际的目标代码，它的作用是告诉编译器，OK，我在该编译单元后面，或者其它编译单元会有这个x变量，print函数的定义。否则编译器如果发现程序用到x，print，而前面没有声明会报错。如果有声明，而没有定义，那么链接的时候会报错未定义。 比较常见的是我在source.cc中调用print()，而head.h中声明print（），而source.cc 中includehead.h从而就有了print的声明，可以通过编译，但是如果在所有编译单元中没有print函数的定义，那么链接的时候source.o单元就会出错，因为它试图用print函数但是找不到print的定义。//head.hvoid pirnt();//source.ccvoid foo() {print();} 由于声明不产生实际代码，所以可以有多个重复声明的存在。//source1.cc//source2.cc甚至同一个编译单元也可以有多各个重复声明//source1.cc而普通变量定义，函数定义是不允许的。 3. 同一编译单元内部的重名符号在编译期就被阻止了，而不同编译单元之间的重名符号要到链接器才会被发现。如果你在一个 source1.cc中//source1.cc出现两次即两个x的定义，会编译报错,x重复定义。如果你的//source1.cc//source2.ccg++ –o test source1.cc source2.cc那么编译过程不会出错，在链接过程，由于目标代码中有两个全局域的x，会链接出错，x重定义。不同的编程人员可能会写不同的模块，那么很容易出现这种情况，如何避免呢，namespace可以避免重名。google 编程规范鼓励使用不具名空间//source1.ccnamespace {}//source2.ccnamespace {}OK,现在不会链接出错了因为两个x不重名了，当然对于这个简单的例子只在source1.cc中用不具名命名空间就可避免链接出差了。//注//source1.ccnamespace {}//source1.cc有什么区别呢，看上去效果一样，区别在于不具名空间的x仍然具有外链接，但是由于它是不具名的，所以别的单元没办法链接到，如果namespace haha{}则在别的单元可以用haha::x访问到它，static 则因为是内部链接特性，所以无法链接到。 C++ 中 static 和 anonymouse namespace 的差别
14:54|分类： 桌面应用开发 记得以前一个同事问我为什么程序里使用了 anonymouse namespace ，想了想 就回答说其实就是保持局部性（这也是我的目的），然后就有人说为什么不用static，嗯 似乎这两个东西乍一看没什么区别，自己便Google了一下，发现有一个原因就是 anonymousenamespace 里的 member 都是有外部链接的，只不过永远都不能被外部link到！而 static 就明确为根本没有外部链接！此时就出现问题了，在模板里无类型的参数必须是有外部链接的才可以，否则编译无法通；比如： template &void fn()& class Foobar {}; namespace { void abc() { wcout&&_T(”abc”)&& }; } static void efg() { wcout&&_T(”efg”)&& }; int _tmain(int argc, _TCHAR* argv[]) { Foobar&abc&xyz //! ;这一行可以通过 Foobar&efg& //! 注意这一行编译不过 return 0; } 也有人认为使用 anon namespace比较好，因为static的方式被C++98标准所批评，呵呵 总体来说 ，其实你完全可以用anony namespace代替static。 4.关于头文件。//head.h//source1.cc#include “head.h”//source2.cc#include “head.h”头文件不被编译，.cc中的引用 include “ head.h”其实就是在预编译的时候将head.h中的内容插入到.cc中。所以上面的例子如果g++ –o test source1.cc source2.cc， 同样会链时发现重复定义的全局变量x。因此变量定义，包括函数的定义不要写到头文件中，因为头文件很可能要被多个.cc引用。那么如果我的head.h如下这么写呢，是否防止了x的链接时重定义出错呢？//head.h#ifndef _HEAD_H_#define _HEAD_H_#endif//source1.cc#include “head.h”//source2.cc#include “head.h”现在是否g++ –o test source1.cc source2.cc就没有问题了呢，答案是否定的。所有的头文件都是应该如上加#ifndef#endif的，但它的作用是防止头文件在同一编译单元被重复引用。就是说防止可能的//source1.cc#include “head.h”#include “head.h”这种情况，当然我们不会主动写成上面的形式但是，下面的情况很可能发送//source1.cc#include “head.h”#inlcude “a.h”//a.h#include “head.h”这样就在不经意见产生了同一编译单元的头文件重复引用，于是soruc1.cc 就出现了两个定义。但是对于不同的编译单元source1.cc,source2.cc他们都是还会引用head.h的，即使#ifndef #endif的存在。 5. 关于类的声明和定义。class A;//类的声明类的声明和普通变量声明一样，不产生目标代码，可以在同一，以及多个编译单元重复声明。class A {};//类的定义类的定义就特殊一点了，可能会有疑问，为什么不能把这样的变量定义放到.h中（见4）但是可以把类的定义放在头文件中重复引用呢？同时类的函数非inline定义(写在类定义里面的函数是inline，除外）不能写在头文件中呢。这是因为类的定义，只是告诉编译器，类的数据格式是如何的，实例话后对象该占多大空间。类的定义也不产生目标代码。因此它和普通变量的声明唯一的区别是不能在同一编译单元内出现多次。//source1.ccclass A;class A;//类重复声明，OKclass A{};class A{};class A{};//同一编译单元内，类重复定义，会编译时报错,因为编译器不知道在该编译单元，A a；的话要生产怎样的a.//如果class A{};定义在head.h ，而head.h 没有//#ifndef#endif 就很可能在同一编译单元出现类重复定义的编译错误情况。但是在不同编译单元内，类可以重复定义,因为类的定义未产生实际代码。//source1.ccclass A{}//source2.ccclass A{}//不同编译单元，类重复定义，OK。所以类的定义可以写在头文件中！//source1.ccclass A{}//source2.ccclass A{}//不同编译单元,OK6. 总结1.在头文件中写变量的声明，函数声明，类的定义，inline函数，不要出现变量定义，类的函数非inline定义，函数定义。即在头文件中不要出现可能产生目标代码的东东。2.为了防止在一个编译单元内部头文件重复引用，所有头文件都要加上#ifndef#endif3.鼓励在.cc中使用不具名namespace，可以有效防止不同编译单元命名冲突。4.相关更专业详细的介绍可以看&&大规模C++程序设计&&的第一章，会有极其好的完整介绍。其中提到类的定义是具有内部链接特性的，即它不是声明不能在同一编译单元重复出现，但是它具有内部链接，（所谓内部链接指的是该名称对于所在编译单元是局部的，在链接时不会与其他编译单元中同样的名称产生命名冲突）,所以类如果要在单个编译单元之外使用它必须被定义在一个头文件中。对于声明和定义，书中给出的定义是：一个声明将一个名称引入程序，一个定义提供了一个实体（例如，类型，实例，函数）在一个程序中的唯一描述。5. 前面第一条说的不是很确切，按照&&大规模C++程序设计&&中的说法理论上头文件中可以放所有具有内部链接的东西，包括具有内部链接的定义。如static void print() {};但是不提倡这么做，因为每一个包含这个头文件的.cc就对应要开辟一个空间存储这个x，就是说不同编译单元都引入由于是内部链接，所以互不影响彼此。甚至你采用namespace也是如此，如在.h中namespace myspace {}不同.cc文件中都引入该头文件，在各自编译单元中调用的myspace::x也是不同的互不影响的！书中提到const int width = 3;//见书的23页这样的const变量也要避免出现在头文件中，不过类似以前c语言中在头文件中#define width3还是很常用的啊。难道也要在.h中ex.cc中const int width = 5;这样虽然可以，不过好麻烦啊，我倒觉得在.h中定义类似const int width =3 问题不大，难道编译器不会做些特殊的处理优化吗，也要每个单元分配一个单独空间？不过倒是也可以利用下面的方法在.h中声明一批const 变量。注意和普通static 变量不同，类的成员静态变量，静态函数是具有外部链接的。如果 static constintSUCCESS = 0; ,SUCCESS不是 const 仅仅是 static int，那么是不可以在类内初始化的（编译出错)，需要在某个.cc文件中初始话，因为它是具有外部链接的。(在GOOGLE编程规范中，提到禁止使用类类型的全局变量，静态成员变量视为全局变量，也禁止使用类类型）class code{ public:static const result_code SUCCESS = 0;//program ended successfullystatic const result_code INVALID_ADDRESS = 1;//wrong addresstatic const result_code READ_FAIL = 2;//cannot readstatic const result_code WRITE_FAIL = 3;//cannot writestatic const result_code UNKNOWN_ACTION = 4;//dunno...static const result_code NOT_FOUND = 5;//key not found in paragraphstatic const result_code NO_WRITE = 6;//no write since modificationstatic const result_code SYNTAX_ERR = 7;//command syntax errorstatic const result_code EMPTY_CLIP = 8;//the clipboard is empty};下面是C++编译链接过程 转自：http://blog.csdn.net/changyang208/article/details/8642288 GCC的编译过程 总体来说，C/C++源代码要经过：预处理、编译、汇编和链接，四步才能变成相应平台下的可执行文件。 File: hw.c[cpp]view plain copy #include &stdio.h&int main(int argc, char *argv[]){printf(&Hello World!\n&);return 0;}如果用gcc编译，只需要一个命令就可以生成可执行文件hw： gcc -o hw.exehw.c 接下来我们按照编译顺序看看编译器每一步都做了什么： cpp hw.c -o hw.i// 预处理 gcc -E hello.c -o hello.i cc1 hw.i -o hw.s// 编译 gcc -S hello.i -o hello.sas hw.s -o hw.o// 汇编 gcc -c hello.s -o hello.o ld hw.o -o hw.exe// 链接 gcc hello.o -o hello.exe 第一步，预处理，主要处理以下指令：宏定义指令，条件编译指令，头文件包含指令。 预处理所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令，头文件都被展开（递归展开）的文件。 第二步，编译，就是把C/C++代码“翻译”成汇编代码。 第三步，汇编，就是将生成的汇编代码翻译成符合一定格式的机器代码，在Linux上一般表现为ELF目标文件。 第四步，链接，将生成的目标文件和系统库文件进行链接，最终生成了可以在特定平台运行的可执行文件。为什么还要链接系统库中的某些目标文件（crt1.o, crti.o等）呢？这些目标文件都是用来初始化或者回收C运行时环境的，比如说堆内存分配上下文环境的初始化等，实际上crt也正是C RunTime的缩写。这也暗示了另外一点：程序并不是从main函数开始执行的，而是从crt中的某个入口开始的，在Linux上此入口是_start。而且默认情况下，ld是将这些系统库文件（本身也是动态库）都是以动态链接方式加入应用程序的，如果要以静态连接的方式进行，需要显示的指定ld命令的参数-static。 此外，还有一个优化阶段。优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。 这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。对于前一种优化，主要的工作是删除公共表达式、循环优化（代码外提、强度削弱、变换循环控制条件、已知量的合并等）、复写传播，以及无用赋值的删除，等等。 后 一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何 根据机器硬件执行指令的特点（如流水线、RISC、CISC、VLIW等）而对指令进行一些调整使目标代码比较短，执行的效率比较高。 目标文件的三个表：未解决符号表，导出符号表和地址重定向表 1、编译：编译器对源文件进行编译，就是把源文件中以文本形式存在的源代码翻译成机器语言形式的目标文件的过程，在这个过程中，编译器会进行一系列的语法检查。如果编译通过，就会把对应的CPP转换成OBJ文件。 2、目标文件：由编译所生成的文件，以机器码的形式包含了编译单元里所有的代码和数据，还有一些其它信息，如未解决符号表，导出符号表和地址重定向表等。目标文件是以二进制的形式存在的。 目标文件由段组成。通常一个目标文件中至少有两个段：代码段：该段中所包含的主要是指令，该段一般是可读和可执行的，但一般却不可写。数据段：主要存放程序中要用到的各种全局变量或静态数据。一般数据段都是可读，可写，可执行的。根据C++标准，一个编译单元（Translation Unit）是指一个.cpp文件以及它所include的所有.h文件，.h文件里面的代码将会被扩展到.cpp文件里，然后编译器编译该.cpp文件生成一个.obj文件。当编译器将一个工程里的所有.cpp文件都编译完毕后，再由链接器进行链接，成为一个.exe或库文件。 下面让我们来分析一下编译器的工作过程，假设我们有一个A.cpp文件，如下定义：int n =1;void FunA(){++n;}它编译出来的目标文件A.obj就会有一个区域（或者说是段），包含以上的数据和函数，其中就有n、FunA，以文件偏移量形式给出可能就是下面这种情况：偏移量内容长度0x0000n40x0004FunA??注意：这只是说明，与实际目标文件的布局可能不一样，??表示长度未知，目标文件的各个数据可能不是连续的，也不一定是从0x0000开始。FunA的内容可能如下：0x0004 inc DWORD PTR[0x0000]0x00?? ret有另外一个B.cpp文件，定义如下：voidFunB(){++n;}它对应的B.obj的二进制应该是：偏移量内容长度0x0000FunB??这里为什么没有n的空间呢，因为n被声明为extern，这个extern关键字就是告诉编译器n已经在别的编译单元里定义了，在这个单元里就不要定义了。由于编译单元之间是互不相关的，所以编译器就不知道n究竟在哪里，所以在函数FunB就没有办法生成n的地址，那么函数FunB中就是这样的：0x0000 inc DWORD PTR[????]0x00?? ret解析????的工作就只能由链接器来完成了。为了能让链接器知道哪些地方的地址没有填好（????），目标文件中有一个表来告诉链接器，这个表就是“未解决符号表”，也就是unresolved symbol table。同样，提供n的目标文件也要提供一个“导出符号表”，也就是exprot symbol table，来告诉链接器自己可以提供哪些地址。到这里我们已经知道，一个目标文件不仅要提供数据和二进制代码，还至少要提供两个表：未解决符号表和导出符号表，来告诉链接器自己需要什么和自己能提供些什么。那么这两个表是怎么建立对应关系的呢？这里就有一个新的概念：符号。在C/C++中，每一个变量及函数都会有自己的符号，如变量n的符号就是n，函数的符号会更加复杂，假设FunA的符号就是_FunA（根据编译器不同而不同）。A.obj的导出符号表为符号地址n0x0000_FunA0x0004未解决符号为空（因为他没有引用别的编译单元里的东西）。B.obj的导出符号表为符号地址 _FunB0x0000未解决符号表为符号地址n0x0001这个表告诉链接器，在本编译单元0x0001位置有一个地址，该地址不明，但符号是n。在链接的时候，链接在B.obj中发现了未解决符号，就会在所有的编译单元中的导出符号表去查找与这个未解决符号相匹配的符号名，如果找到，就把这个符号的地址填到B.obj的未解决符号的地址处。如果没有找到，就会报链接错误。在此例中，在A.obj中会找到符号n，就会把n的地址填到B.obj的0x0001处。但是，这里还会有一个问题，如果是这样的话，B.obj的函数FunB的内容就会变成inc DWORDPTR[0x000]（因为n在A.obj中的地址是0x0000）。由于每个编译单元的地址都是从0x0000开始，那么最终多个目标文件链接时就会导致地址重复。所以链接器在链接时就会对每个目标文件的地址进行调整。在本例中，假如B.obj的0x0000被定位到可执行文件的0x上，而A.obj的0x0000被定位到可执行文件的0x上，那么实现上对链接器来说，A.obj的导出符号地地址都会加上0x，B.obj所有的符号地址也会加上0x。这样就可以保证地址不会重复。既然n的地址会加上0x，那么FunA中的inc DWORDPTR[0x0000]就是错误的，所以目标文件还要提供一个表，叫地址重定向表，address redirect table。总结一下：目标文件至少要提供三个表：未解决符号表，导出符号表和地址重定向表。未解决符号表：列出了本单元里有引用但是不在本单元定义的符号及其出现的地址。导出符号表：提供了本编译单元具有定义，并且可以提供给其他编译单元使用的符号及其在本单元中的地址。地址重定向表：提供了本编译单元所有对自身地址的引用记录。 链接器的工作顺序：当链接器进行链接的时候，首先决定各个目标文件在最终可执行文件里的位置。然后访问所有目标文件的地址重定义表，对其中记录的地址进行重定向（加上一个偏移量，即该编译单元在可执行文件上的起始地址）。然后遍历所有目标文件的未解决符号表，并且在所有的导出符号表里查找匹配的符号，并在未解决符号表中所记录的位置上填写实现地址。最后把所有的目标文件的内容写在各自的位置上，就生成一个可执行文件。实际链接的时候会更加复杂，目标文件都会把数据，代码分成好几个区，重定向是按区进行，但原理都是一样的。 重温C/C++中的特性：extern：这就是告诉编译器，这个变量或函数在别的编译单元里定义了，也就是要把这个符号放到未解决符号表里面去。static：如果static位于全局函数或者全局变量的声明前面，表明该编译单元不导出这个函数或变量，因此这个符号不能在别的编译单元中使用。 默认链接属性：对于函数和变量，默认链接是外部链接，对于const变量，默认内部链接。 外部链接的利弊：外部链接的符号在整个程序范围内都是可以使用的，这就要求其他编译单元不能导出相同的符号（不然就会报duplicated external symbols）。 内部链接的利弊：内部链接的符号不能在别的编译单元中使用。但不同的编译单元可以拥有同样的名称的符号。为什么常量默认为内部链接，而变量不是?这就是为了能够在头文件里如const int n = 0这样的定义常量。由于常量是只读的，因此即使每个编译单元都拥有一份定义也没有关系。如果一个定义于头文件里的变量拥有内部链接，那么如果出现多个编译单元都定义该变量，则其中一个编译单元对该变量进行修改，不会影响其他单元的同一变量，会产生意想不到的后果。 为什么头文件里一般只可以有声明不能有定义?头文件可以被多个编译单元包含，如果头文件里面有定义的话，那么每个包含这头文件的编译单元都会对同一个符号进行定义，如果该符号为外部链接，则会导致duplicatedexternal symbols链接错误。因此如果头文件里要定义，必须保证定义的符号只能具有内部链接。 为什么类的静态成员变量不可以就地初始化?由于class的声明通常是在头文件里，如果允许这样做，其实就相当于在头文件里定义了一个非const变量。头文件里内联函数被拒绝会怎样？如果定义于头文件里的内联函数被拒绝，那么编译器会自动在每个包含了该头文件的编译单元里定义这个函数，并且不导出符号。 如果被拒绝的内联函数里定义了静态局部变量，这个变量会被定义于何处？早期的编译器会在每个编译单元里定义一个，并因此产生错误的结果，较新的编译器会解决这个问题，手段未知。 在C++环境下使用C函数的时候，常常会出现编译器无法找到C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢？C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。例如，假设某个函数的原型为：void foo( int x, int y );该函数被C编译器编译后在符号表中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。
推荐：声明是告诉编译器一些信息，以协助编译器进行语法分析，避免编译器报错。而定义是告诉编译器生成一些代码，并且这些代码将由连接器使用。即：声明是给编译 器用
C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间 转自：/rocketfan/archive//1577361.html
首先说我的补充：（对声明和定义的深入理解和
相关阅读排行
相关内容推荐
请激活账号
为了能正常使用评论、编辑功能及以后陆续为用户提供的其他产品，请激活账号。
您的注册邮箱：
如果您没有收到激活邮件，请注意检查垃圾箱。