重写编译器

1. C语言为什么可以重写标准库函数

这个问题是一个好问题，我之前也没思索过或者尝试过，
首先我们弄清楚一件事，函数声明可以放在任何头文件，实现可以放在任何实现该函数的源文件中，那么就存在一个问题：
编译时，到底优先去使用哪一个，为什么没有把标准库中的函数扩展过来；在windows下标准库被编译成了msvcr120.dll(msvcr100.dll，这里指release版)，所以并不是扩展到代码中，而是在调用时动态链接；
而题主在其中自定义文件中实现了该函数，所以编译时找到了该函数的实现，并不会去链接dll（这应该是编译器做的一些工作，确定系统的dll需要加载哪些），所以题主的程序执行时就只有一份fputc了，并不冲突。
题主可以通过快捷键跳转声明就知道了，VS下，点选fputc实现函数按F12跳转到声明，指向的是stdio.h，再按一次跳转到你自己的定义了。Qt的话使用F2。
大概就是这样子了，可追问。

2. 谁能详细告诉我有关java中的方法重载和重写有什么区别

public void speak(){
System.out.println("Father");}}public class Son extends Father{
public void speak(){
System.out.println("son");}}这也叫做多态性,重写方法只能存在于具有继承关系的类中,重写方法只能重写父类非私有的方法,当上例中Father类的speak()方法为private时,Son类不能重写speak()方法,此时在Son类中定义的speak()方法相当于一个新的方法，与Father中的speak()方法没有任何关系.
当Father类的speak()方法声明为final时,无论该方法的修饰符是public,protected还是默认,Son类根本不能重写speak()方法,试图编译代码时,编译器会报错.例:
public class Father{
final void speak(){
System.out.println("Father");}}public class Son extends Father{
public void speak(){
System.out.println("son");}}//编译器错误信息：Son 中的 speak() 无法覆盖 Father 中的 speak()；被覆盖的方法为 final
重写方法的规则:
1.参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载；
2.返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载；
3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）；
4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常．例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常（unchecked exception，如运行时异常）.
重载方法的规则：
1.必须具有不同的参数列表；
2.可以有不同的返回类型，只要参数列表不同就可以了；
3.可以有不同的访问修饰符；

3. 预处理指令#pragma db code是什么意思

一、作用是设定编译器的状态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法,在保持与C和 C++语言完全兼容的情况下,给出主机或操作系统专有的特征。依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。

二、常用的pragma指令的详细解释。
1.#pragma once。保证所在文件只会被包含一次，它是基于磁盘文件的，而#ifndef则是基于宏的。
2.#pragma warning。允许有选择性的修改编译器的警告消息的行为。有如下用法：
#pragma warning(disable:4507 34; once:4385; error:164) 等价于：
#pragma warning(disable:4507 34) // 不显示4507和34号警告信息
#pragma warning(once:4385) // 4385号警告信息仅报告一次
#pragma warning(error:164) // 把164号警告信息作为一个错误
#pragma warning(default:176) // 重置编译器的176号警告行为到默认状态
同时这个pragma warning也支持如下格式,其中n代表一个警告等级(1---4)：
#pragma warning(push) // 保存所有警告信息的现有的警告状态
#pragma warning(push,n) // 保存所有警告信息的现有的警告状态，并设置全局报警级别为n
#pragma warning(pop) // 恢丛 鹊木 孀刺 趐ush和pop之间所做的一切改动将取消
例如：
#pragma warning(push)
#pragma warning(disable:4705)
#pragma warning(disable:4706)
#pragma warning(disable:4707)
#pragma warning(pop)
在这段代码后，恢复所有的警告信息(包括4705，4706和4707)。
3.#pragma hdrstop。表示预编译头文件到此为止，后面的头文件不进行预编译。BCB可以预编译头文件以 加快链接的速度，但如果所有头文件都进行预编译又可能占太多磁盘空间，所以使用这个选项排除一些头文 件。
4.#pragma message。在标准输出设备中输出指定文本信息而不结束程序运行。用法如下：
#pragma message("消息文本")。当编译器遇到这条指令时就在编译输出窗口中将“消息文本”打印出来。
5.#pragma data_seg。一般用于DLL中，它能够设置程序中的初始化变量在obj文件中所在的数据段。如果未指定参数，初始化变量将放置在默认数据段.data中，有如下用法：
#pragma data_seg("Shared") // 定义了数据段"Shared"，其中有两个变量a和b
int a = 0; // 存储在数据段"Shared"中
int b; // 存储在数据段".bss"中，因为没有初始化
#pragma data_seg() // 表示数据段"Shared"结束，该行代码为可选的
对变量进行专门的初始化是很重要的，否则编译器将把它们放在普通的未初始化数据段中而不是放在shared中。如上述的变量b其实是放在了未初始化数据段.bss中。
#pragma data_seg("Shared")
int j = 0; // 存储在数据段"Shared"中
#pragma data_seg(push, stack1, "Shared2") //定义数据段Shared2，并将该记录赋予别名stack1，然后放入内部编译器栈中
int l = 0; // 存储在数据段"Shared2"中
#pragma data_seg(pop, stack1) // 从内部编译器栈中弹出记录，直到弹出stack1，如果没有stack1，则不做任何操作
int m = 0; // 存储在数据段"Shared"中，如果没有上述pop段，则该变量将储在数据段"Shared2"中
6.#pragma code_seg。它能够设置程序中的函数在obj文件中所在的代码段。如果未指定参数，函数将放置在默认代码段.text中，有如下用法：
void func1() { // 默认存储在代码段.text中
}
#pragma code_seg(".my_data1")
void func2() { // 存储在代码段.my_data1中
}
#pragma code_seg(push, r1, ".my_data2")
void func3() { // 存储在代码段.my_data2中
}
#pragma code_seg(pop, r1)
void func4() { // 存储在代码段.my_data1中
}
7.#pragma pack。用来改变编译器的字节对齐方式。常规用法为：
#pragma pack(n) //将编译器的字节对齐方式设为n，n的取值一般为1、2、4、8、16，一般默认为8
#pragma pack(show) //以警告信息的方式将当前的字节对齐方式输出
#pragma pack(push) //将当前的字节对齐方式放入到内部编译器栈中
#pragma pack(push,4) //将字节对齐方式4放入到内部编译器栈中，并将当前的内存对齐方式设置为4
#pragma pack(pop) //将内部编译器栈顶的记录弹出，并将其作为当前的内存对齐方式
#pragma pack(pop,4) //将内部编译器栈顶的记录弹出，并将4作为当前的内存对齐方式
#pragma pack(pop,r1) //r1为自定义的标识符，将内部编译器中的记录弹出，直到弹出r1，并将r1的值作为当前的内存对齐方式；如果r1不存在，当不做任何操作
8.#pragma comment。将一个注释记录放置到对象文件或可执行文件中。
其格式为：#pragma comment( comment-type [,"commentstring"] )。其中，comment-type是一个预定义的标识符，指定注释的类型，应该是compiler，exestr，lib，linker，user之一。
compiler：放置编译器的版本或者名字到一个对象文件，该选项是被linker忽略的。
exestr：在以后的版本将被取消。
lib：放置一个库搜索记录到对象文件中，这个类型应该与commentstring（指定Linker要搜索的lib的名称和路径）所指定的库类型一致。在对象文件中，库的名字跟在默认搜索记录后面；linker搜索这个这个库就像你在命令行输入这个命令一样。你可以在一个源文件中设置多个库搜索记录，它们在obj文件中出现的顺序与在源文件中出现的顺序一样。
如果默认库和附加库的次序是需要区别的，使用/Zl编译开关可防止默认库放到object模块中。
linker：指定一个连接选项，这样就不用在命令行输入或者在开发环境中设置了。只有下面的linker选项能被传给Linker：
/DEFAULTLIB
/EXPORT
/INCLUDE
/MANIFESTDEPENDENCY
/MERGE
/SECTION
(1)/DEFAULTLIB:library
/DEFAULTLIB选项将一个library添加到LINK在解析引用时搜索的库列表。用/DEFAULTLIB指定的库在命令行上指定的库之后和obj文件中指定的默认库之前被搜索。
忽略所有默认库(/NODEFAULTLIB)选项重写/DEFAULTLIB:library。如果在两者中指定了相同的library名称，忽略库(/NODEFAULTLIB:library)选项将重写/DEFAULTLIB:library。
(2)/EXPORT:entryname[,@ordinal[,NONAME]][,DATA]
使用该选项，可以从程序导出函数以便其他程序可以调用该函数，也可以导出数据。通常在DLL中定义导出。
entryname是调用程序要使用的函数或数据项的名称。ordinal为导出表的索引，取值范围在1至65535；如果没有指定ordinal，则LINK将分配一个。NONAME关键字只将函数导出为序号，没有entryname。DATA 关键字指定导出项为数据项。客户程序中的数据项必须用extern __declspec(dllimport)来声明。
有三种导出定义的方法，按照建议的使用顺序依次为：
源代码中的__declspec(dllexport)
.def文件中的EXPORTS语句
LINK命令中的/EXPORT规范
所有这三种方法可以用在同一个程序中。LINK在生成包含导出的程序时还要创建导入库，除非在生成过程中使用了.exp 文件。
LINK使用标识符的修饰形式。编译器在创建obj文件时修饰标识符。如果entryname以其未修饰的形式指定给链接器（与其在源代码中一样），则LINK将试图匹配该名称。如果无法找到唯一的匹配名称，则LINK发出错误信息。当需要将标识符指定给链接器时，请使用Dumpbin工具获取该标识符的修饰名形式。
(3)/INCLUDE:symbol
/INCLUDE选项通知链接器将指定的符号添加到符号表。若要指定多个符号，请在符号名称之间键入逗号(,)、分号(;)或空格。在命令行上，对每个符号需指定一次/INCLUDE:symbol。
链接器通过将包含符号定义的对象添加到程序来解析symbol。该功能对于添加不会链接到程序的库对象非常有用。
用该选项所指定的符号将覆盖通过/OPT:REF对该符号进行的移除操作。
(4)/MANIFESTDEPENDENCY:manifest_dependency
/MANIFESTDEPENDENCY允许你指定位于manifest文件的段的属性。/MANIFESTDEPENDENCY信息可以通过下面两种方式传递给LINK:
直接在命令行运行/MANIFESTDEPENDENCY
通过#pragma comment
(5)/MERGE:from=to
/MERGE选项将第一个段(from)与第二个段(to)进行联合，并将联合后的段命名为to的名称。
如果第二个段不存在，LINK将段(from)重命名为to的名称。
/MERGE选项对于创建VxDs和重写编译器生成的段名非常有用。
(6)/SECTION:name,[[!]{DEKPRSW}][,ALIGN=#]
/SECTION选项用来改变段的属性，当指定段所在的obj文件编译的时候重写段的属性集。
可移植的可执行文件(PE)中的段(section)与新可执行文件(NE)中的节区(segment)或资源大致相同。
段(section)中包含代码或数据。与节区(segment)不同的是，段(section)是没有大小限制的连续内存块。有些段中的代码或数据是你的程序直接定义和使用的，而有些数据段是链接器和库管理器(lib.exe)创建的，并且包含了对操作系统来说很重要的信息。
/SECTION选项中的name是大小写敏感的。
不要使用以下名称，因为它们与标准名称会冲突，例如，.sdata是RISC平台使用的。
.arch
.bss
.data
.edata
.idata
.pdata
.rdata
.reloc
.rsrc
.sbss
.sdata
.srdata
.text
.xdata
为段指定一个或多个属性。属性不是大小写敏感的。对于一个段，你必须将希望它具有的属性都进行指定；如果某个属性未指定，则认为是不具备这个属性。如果你未指定R，W或E，则已存在的读，写或可执行状态将不发生改变。
要对某个属性取否定意义，只需要在属性前加感叹号(!)。
E：可执行的
R：可读取的
W：可写的
S：对于载入该段的镜像的所有进程是共享的
D：可废弃的
K：不可缓存的
P：不可分页的
注意K和P是表示否定含义的。
PE文件中的段如果没有E，R或W属性集，则该段是无效的。
ALIGN=#选项让你为一个具体的段指定对齐值。
user：放置一个常规注释到一个对象文件中，该选项是被linker忽略的。
9.#pragma section。创建一个段。
其格式为：#pragma section( "section-name" [, attributes] )
section-name是必选项，用于指定段的名字。该名字不能与标准段的名字想冲突。可用/SECTION查看标准段的名称列表。
attributes是可选项，用于指定段的属性。可用属性如下，多个属性间用逗号(,)隔开：
read：可读取的
write：可写的
execute：可执行的
shared：对于载入该段的镜像的所有进程是共享的
nopage：不可分页的，主要用于Win32的设备驱动程序中
nocache：不可缓存的，主要用于Win32的设备驱动程序中
discard：可废弃的，主要用于Win32的设备驱动程序中
remove：非内存常驻的，仅用于虚拟设备驱动(VxD)中
如果未指定属性，默认属性为read和write。
在创建了段之后，还要使用__declspec(allocate)将代码或数据放入段中。
例如：
//pragma_section.cpp
#pragma section("mysec",read,write)
int j = 0;
__declspec(allocate("mysec"))
int i = 0;
int main(){}
该例中, 创建了段"mysec"，设置了read,write属性。但是j没有放入到该段中，而是放入了默认的数据段中，因为它没有使用__declspec(allocate)进行声明；而i放入了该段中，因为使用__declspec(allocate)进行了声明。
10.#pragma push_macro与#pragma pop_macro。前者将指定的宏压入栈中，相当于暂时存储，以备以后使用；后者将栈顶的宏出栈，弹出的宏将覆盖当前名称相同的宏。例如：
#include
#define X 1
#define Y 2
int main() {
printf("%d",X);
printf("\n%d",Y);
#define Y 3 // C4005
#pragma push_macro("Y")
#pragma push_macro("X")
printf("\n%d",X);
#define X 2 // C4005
printf("\n%d",X);
#pragma pop_macro("X")
printf("\n%d",X);
#pragma pop_macro("Y")
printf("\n%d",Y);
}
输出结果：
1
2
1
2
1
3

4. 编译器错误消息: CS0115: “ASP.XXX.aspx.GetTypeHashCode()”: 没有找到适合的方法来重写

就是当前类的 GetTypeHashCode() 方法不存在或者不允许Override。

5. C#重载，C#重写和C#隐藏的区别

重载：相同的函数名称，参数列表不同的函数，可以根据不同的参数来实现不同的逻辑。

重写：子类重写基类的虚函数，这样不同的子类就可以以不同的方式实现同一个功能。比如定义一个鸟类基类，在基类中定义一个飞翔的虚函数，实现子类燕子与蜂鸟，显然燕子与蜂鸟的飞行方式是不同的，这时就可以用到重写了。

隐藏：子类使用new字定义字段、属性或函数，则子类的该字段、属性或函数隐藏了基类的同名字段、属性或函数。

可以在VS里运行以下代码，通过查看输出来加深理解：

publicclassBaseClass{
	///<summary>
	///重载函数1
	///</summary>
	///<returns></returns>
	publicstringGetString(){
		return"我是重载函数1";
	}

	///<summary>
	///重载函数2
	///</summary>
	///<paramname="obj"></param>
	///<returns></returns>
	publicstringGetString(objectobj){
		return"我是重载函数2";
	}

	///<summary>
	///待重写的函数
	///</summary>
	(){
		return"我是基类待重写的函数";
	}

	///<summary>
	///被隐藏的函数
	///</summary>
	///<returns></returns>
	publicstringHideFunction(){
		return"我是基类的被隐藏函数";
	}
}

publicclassChildClass:BaseClass{
	///<summary>
	///子类重写函数
	///</summary>
	///<returns></returns>
	(){
		return"我是子类重写的函数";
	}

	///<summary>
	///隐藏基类函数
	///</summary>
	///<returns></returns>
	publicnewstringHideFunction(){
		return"我是子类的函数，我隐藏了基类HideFunction";
	}
}

staticvoidMain(string[]args){
	ChildClasschild=newChildClass();
	Console.WriteLine("ChildClass.GetString():"+child.GetString());
	Console.WriteLine("ChildClass.GetString(objectobj):"+child.GetString(newobject()));
	Console.WriteLine("ChildClass.OverideFunction():"+child.OverideFunction());
	Console.WriteLine("ChildClass.HideFunction():"+child.HideFunction());

	BaseClassbaseClass=childasBaseClass;
	Console.WriteLine("BaseClass.OverideFunction():"+baseClass.OverideFunction());
	Console.WriteLine("BaseClass.HideFunction():"+baseClass.HideFunction());

	baseClass=newBaseClass();
	Console.WriteLine("BaseClass.OverideFunction():"+baseClass.OverideFunction());
}

6. Java中的重载与重写有什么区别（请举两个简单的例子）

Java中的重载与重写的区别：

首先讲讲：重载(Overloading)

（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。

（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

下面是重载的例子：
package c04.answer;//这是包名
//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。
不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
package c04.answer;
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()方法是重载方法
{
System.out.println(\"no barking!\");
this.bark(\"female\", 3.4);
}
void bark(String m,double l)//注意：重载的方法的返回值都是一样的，
{
System.out.println(\"a barking dog!\");
this.bark(5, \"China\");
}
void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println(\"a howling dog\");
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark(); [Page]
//dog.bark(\"male\", \"yellow\");
//dog.bark(5, \"China\");

然后谈谈：重写（Overriding）

（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。

（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

（3）子类函数的访问修饰权限不能少于父类的；
下面是重写的例子：

概念：即调用对象方法的机制。

动态绑定的内幕：
1、编译器检查对象声明的类型和方法名，从而获取所有候选方法。试着把上例Base类的test注释掉，这时再编译就无法通过。

2、重载决策：编译器检查方法调用的参数类型，从上述候选方法选出唯一的那一个（其间会有隐含类型转化）。
如果编译器找到多于一个或者没找到，此时编译器就会报错。试着把上例Base类的test(byte b)注释掉，这时运行结果是1 1。

3、若方法类型为priavte static final ，java采用静态编译，编译器会准确知道该调用哪
个方法。

4、当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本。
在例子中，b所指向的实际类型是TestOverriding，所以b.test(0)调用子类的test。
但是，子类并没有重写test(byte b)，所以b.test((byte)0)调用的是父类的test(byte b)。
如果把父类的(byte b)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(int i)。

总结：
多态性是面向对象编程的一种特性，和方法无关，
简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的
重载——有不同的参数列表（静态多态性）
而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，
即在子类中重写该方法——相同参数，不同实现（动态多态性）

OOP三大特性：继承，多态，封装。
public class Base
{
void test(int i)
{
System.out.print(i);
}
void test(byte b)
{
System.out.print(b);
}
}
public class TestOverriding extends Base
{
void test(int i)
{
i++;
System.out.println(i);
}
public static void main(String[]agrs)
{
Base b=new TestOverriding();
b.test(0)
b.test((byte)0)
}
}

这时的输出结果是1 0，这是运行时动态绑定的结果。

重写的主要优点是能够定义某个子类特有的特征：
public class Father{
public void speak(){
System.out.println(Father);
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
}
这也叫做多态性，重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。
当上例中Father类speak()方法被private时，Son类不能重写出Father类speak()方法，此时Son类speak()方法相当与在Son类中定义的一个speak()方法。
Father类speak()方法一但被final时，无论该方法被public,protected及默认所修饰时，Son类根本不能重写Father类speak()方法，
试图编译代码时，编译器会报错。例：
public class Father{
final public void speak(){
System.out.println("Father");
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
} //编译器会报错；

Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。
Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。

重写方法的规则：
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

而重载的规则：
1、必须具有不同的参数列表；
2、可以有不责骂的返回类型，只要参数列表不同就可以了；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；

重写与重载的区别在于：
重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.

7. (急！！！)go语言编译器如何重写

你还是找个qq群问一下

8. 为什么Finalize不能重写

不能重写只是编译器干的事儿，实际上它就是想让你只能写析构函数，而写析构函数就相当于重写了Finalize。
这只是一种设计方式。

你可以改Assembly的代码，直接写IL，会发现是可以override的。

你可以上网搜索一下Mono.cecil，有相关的内容。
举个例子，按照C#的规范，一个类里面是不可能有两个方法名相同，参数相同，而仅仅是返回值不同的方法的，例如：
public class MyClass
{
public string Foo()
{
}

public int Foo()
{
}
}
直接写上述C#代码，编译无法通过，编译器会告诉你这两个方法签名是不明确的。
但是如果是IL（即Assembly中编译后的内容），是可以有这么两个方法的。
因为IL中描述的方法其实就是个方法的地址，根本不管你的方法是叫啥名字。只要知道地址，就能调用。

================================
再补充一下，你可以自己做这个实验：
首先写一个类：
public class SampleClass
{
public SampleClass()
{
}

~SampleClass()
{
}
}
编译。
然后使用Visual Studio自带的工具IL Disassembler，一般位于开始菜单的 Microsoft VisualStudio 2010（看你自己的安装版本）\Microsoft Windows SDK Tools\ 下面
打开刚才编译好的dll或者exe,在左边会有一个类型列表，找到刚才写的SampleClass，点开"+"，会看到下面有两个方法，
一个是：.ctor:void() 这个其实就是构造函数
另一个是：Finalize:void() 这个就是我们刚才写的析构函数。
这说明什么呢？说明其实析构函数就是重载的Finalize。也就是编译器给我们玩儿的小把戏而已。
再双击这个Finalize:void(),可以看到里面的IL代码：
.method family hidebysig virtual instance void
Finalize() cil managed
{
// Code size 14 (0xe)
.maxstack 1
.try
{
IL_0000: nop
IL_0001: nop
IL_0002: leave.s IL_000c
} // end .try
finally
{
IL_0004: ldarg.0
IL_0005: call instance void [mscorlib]System.Object::Finalize()
IL_000a: nop
IL_000b: endfinally
} // end handler
IL_000c: nop
IL_000d: ret
} // end of method SampleClass::Finalize

注意这一句：
[mscorlib]System.Object::Finalize()
IL_000a: nop
IL_000b: endfinally
其实就是在调用基类的（即object）的Finalize方法

9. 这是什么编译器

汇编。这真的是最早最早的。准确的来说，这和编译器的开发有关，不用说太细，很麻烦怕你不懂。你现在假设第一个编译器是用会变写出来的，它的功能很简单，就是解释简单一种类似于C语言的高级语言，但是这种所谓的高级语言还没有完全拥有C语言的所有特性。只有比较简单核心功能，比如能把文本文件的高级语言转换成机器代码并且执行。有了这个原型之后，就可以用这个编译器来解释简单C程序，就可以用C重写编写一个新的编译器，这样就有更多的C的功能。于是，从此之后就用现有的编译器解释更复杂的语言，用更复杂的语言写出更好的编译器，然后不断这样迭代。这确实是编译器的演变。然后最后一个问题就是当一个新的CPU发明过后，怎么办，需要重写又从汇编开始写编译器吗？答案是不用。假设你有一个CPU A执行一些代码，你用汇编写了一个基础的C编译器，然后用C写出了更复杂的编译器，接受更复杂的C功能，然后不断循环演化。现在你有了CPU B，CPU B和CPU A执行两套完全不同的代码，那如何让CPU B的机器也可以变异C语言呢？因为现在A上面已经可以运行非常复杂的C语言程序了，所以你可以在A上面开发一个编译器把C语言程序转化为CPU B的执行代码。然后用这个程序，直接编译你的C语言编译器，再把这个程序转换到有B命令集的电脑上面，这样你就开发出了B电脑需要的C语言编译器。所以除非你真的是活在非常早起的人类。否在现在的编译器基本上都利用这种原理直接编译已经用C语言或者其它高级语言写好的代码来产生新的编译器就行了。理论上可以只使用C语言来开发C的编译器，不过处于一些历史原因和底层效率等因素的考量，部分代码还是使用汇编来实现的。我举得不过是一个例子，不一定是真实的C语言编译的进化，何况有这么多不同的C语言编译器，每一个的发展历史都有小的不同。但是基本上都是利用了这种编译器编译新的编译器的思想来实现了。而这样回溯回去，最早的编译器只能使用汇编来些。而其实最早的汇编语言的编译器就只能使用机器语言来写了。不过都是先处理简单的转换任务，有了这个核心功能过后，就可以写程序转换更复杂的语法。然后越来越复杂。就有了各种各样的高级语言编译器了。