CFoo *const pPointerConst=&Instance; //4
const CF00 *const pPointerConst=&Instance; 27.struct 和 class 的区别答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。
//5
12.What are top-down and bottom-up approach?How do you usually use them ?
13.Please use pseudo-code to design a set of stack operations with temp late
14.Please use pseudo-code to design a set of double linked list operati ons with template
Optional Questions:(for extra credits)
15.Please write a unix makefile for Question13 16.Please explain these common sections:text,data,bss 微软C,C++面试题大全版(二)
21. New delete 与malloc free 的联系与区别？ 答案：都是在堆（heap）上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor. 22. #define DOUBLE（x） x+x ，i = 5*DOUBLE（5）； i 是多少？
答案：i 为30.
23. 有哪几种情况只能用intialization list 而不能用assignment？
答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。 24. C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast）。C#是类型安全的。 25. main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行。 26. 描述内存分配方式以及它们的区别？
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。 3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服 务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在 的！）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。
28.当一个类A 中没有生命任何成员变量与成员函数，这时sizeof（A）的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）
答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0]，A[1]?了。
29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
30. 比较C++中的4种类型转换方式？ 1、static_cast Operator MSDN: The expression static_cast < type-id > ( expression ) converts expression to the type of type-id based solely on the types present in the expression. No run-time type check is made to ensure the safety of the conversion. Syntax
static_cast < type-id > ( expression )
The static_cast operator can be used for operations such as converting a pointer to a base class to a pointer to a derived class. Such conversions are not always safe. For example: class B { ... };
class D : public B { ... }; void f(B* pb, D* pd) { D* pd2 = static_cast
// point to just B
B* pb2 = static_cast
In contrast to dynamic_cast, no run-time check is made on the static_cast conversion of pb. The object pointed to by pb may not be an object of type D, in which case the use of *pd2 could be disastrous. For instance, calling a function that is a member of the D class, but not the B class, could result in an access violation.
The dynamic_cast and static_cast operators move a pointer throughout a class hierarchy. However, static_cast relies exclusively on the information provided in the cast statement and can therefore be unsafe. For example: class B { ... };
class D : public B { ... }; void f(B* pb) {
D* pd1 = dynamic_cast
If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb == 0.
If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.
Consequently, static_cast can do the inverse of implicit conversions, in which case the results are undefined. It is left to the programmer to ensure that the results of a static_cast conversion are safe.
This behavior also applies to types other than class types. For instance, static_cast can be used to convert from an int to a char. However, the resulting char may not have enough bits to hold the entire int value. Again, it is left to the programmer to ensure that the results of a static_cast conversion are safe. The static_cast operator can also be used to perform any implicit conversion, including standard conversions and user-defined conversions. For example:
typedef unsigned char BYTE void f() {
char ch; int i = 65;
float f = 2.5; double dbl;
ch = static_cast
dbl = static_cast
i = static_cast
The static_cast operator can explicitly convert an integral value to an enumeration type. If the value of the integral type does not fall within the range of enumeration values, the resulting enumeration value is undefined.
The static_cast operator converts a null pointer value to the null pointer value of the destination type.
Any expression can be explicitly converted to type void by the static_cast operator. The destination void type can optionally include the const, volatile, or __unaligned attribute. The static_cast operator cannot cast away the const, volatile, or __unaligned attributes.
static_cast在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风 格的类型转换一样把struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属 性，因为另一个新的类型转换操作符const_cast有这样的功能。 2、const_cast Operator MSDN:
The const_cast operator can be used to remove the const, volatile, and __unaligned attribute(s) from a class. Syntax
const_cast < type-id > ( expression )
A pointer to any object type or a pointer to a data member can be explicitly converted to a type that is identical except for the const, volatile, and __unaligned qualifiers. For pointers and references, the result will refer to the original object. For pointers to data members, the result will refer to the same member as the original (uncast) pointer to data member. Depending on the type of the referenced object, a write operation through the resulting pointer, reference, or pointer to data member might produce undefined behavior.
The const_cast operator converts a null pointer value to the null pointer value of the destination type.
const_cast用于类型转换掉表达式的const或
volatileness属性。通过使用const_cast，你向人们和编译器强调你通 过类型转换想做的只是改变一些东西的constness或者 volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness 或者volatileness属性之外的事情，你的类型转换将被拒绝。
3、dynamic_cast Operator MSDN:
The expression dynamic_cast
dynamic_cast < type-id > ( expression )
If type-id is a pointer to an unambiguous accessible direct or indirect base class of expression, a pointer to the unique subobject of type type-id is the result. For example: class B { ... };
class C : public B { ... }; class D : public C { ... }; void f(D* pd) {
C* pc = dynamic_cast
// pc points to C subobject of pd
B* pb = dynamic_cast
// pb points to B subobject of pd ... }
This type of conversion is called an “upcast” because it moves a pointer up a class hierarchy, from a derived class to a class it is derived from. An upcast is an implicit conversion.
If type-id is void*, a run-time check is made to determine the actual type of expression. The result is a pointer to the complete object pointed to by expression. For example: class A { ... };
class B { ... }; void f() {
A* pa = new A; B* pb = new B;
void* pv = dynamic_cast
pv = dynamic_cast
// pv now points to an object of type B }
If type-id is not void*, a run-time check is made to see if the object pointed to by expression can be converted to the type pointed to by type-id. If the type of expression is a base class of the type of type-id, a run-time check is made to see if expression actually points to a complete object of the type of type-id. If this is true, the result is a pointer to a complete object of the type of type-id. For example:
class B { ... };
class D : public B { ... }; void f() {
B* pb = new D; // unclear but ok B* pb2 = new B;
D* pd = dynamic_cast
D* pd2 = dynamic_cast
// pd2 == NULL ... }
This type of conversion is called a “downcast” because it moves a pointer down a class hierarchy, from a given class to a class derived from it. dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转 换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型 转换时）。
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，也不能用它来转换掉constness。
4、reinterpret_cast Operator MSDN:
The reinterpret_cast operator allows any pointer to be converted into any other pointer type. It also allows any integral type to be converted into any pointer type and vice versa. Misuse of the
reinterpret_cast operator can easily be unsafe. Unless the desired conversion is inherently low-level, you should use one of the other cast operators. Syntax
reinterpret_cast < type-id > ( expression ) The reinterpret_cast operator can be used for conversions such as char* to int*, or One_class* to Unrelated_class*, which are inherently unsafe. The result of a reinterpret_cast cannot safely be used for anything other than being cast back to its original type. Other uses are, at best, nonportable. The reinterpret_cast operator cannot cast away the const, volatile, or __unaligned attributes.
使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。
reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。
比如转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型。
5、如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法： #define
static_cast(TYPE,EXPR) ((TYPE)(EXPR)) #define
const_cast(TYPE,EXPR) ((TYPE)(EXPR)) #define
reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR)) 这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。
没有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数 而你有必须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟 dynamic_cast的功能，就象模拟其它的类型转换一样：
#define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)
请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。
31.分别写出BOOL，int，float，指针类型的变量a 与“零”的比较语句。 答案： BOOL : if ( !a ) or if(a) int : if ( a == 0) float : const EXPRESSION EXP = 0.000001 if ( a < EXP && a >-EXP) pointer : if ( a != NULL) or if(a == NULL) 32.请说出const与#define 相比，有何优点？
答案：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。 33.简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。 （1）修改内容上的差别 char a[] = “hello”; a[0] = ‘X’; char *p = “world”; // 注意p 指向常量字符串 p[0] = ‘X’; // 编译器不能发现该错误，运行时错误 （2） 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof（p），p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。 char a[] = \char *p = a; cout<< sizeof(a) << endl; // 12 字节 cout<< sizeof(p) << endl; // 4 字节 计算数组和指针的内存容量 void Func(char a[100]) { cout<< sizeof(a) << endl; // 4 字节而不是100 字节 } 34.类成员函数的重载、覆盖和隐藏区别？ 答案：
a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。 b.覆盖是指派生类函数覆盖基类函数，特征是： （1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆） 35. There are two int variables： a and b， don‘t use “if”， “？ ：”， “switch”or other judgement statements， find out the biggest one of the two numbers.
答案：（ （ a + b ） + abs（ a - b ） ） / 2 36. 如何打印出当前源文件的文件名以及源文件的当前行号？ 答案： cout << __FILE__ ; cout<<__LINE__ ; __FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。 37. main 主函数执行完毕后，是否可能会再执行一段代码，给出说明？
答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行int fn1（void）， fn2（void）， fn3（void）， fn4 （void）； void main( void ) { String str(\_onexit( fn1 ); _onexit( fn2 ); _onexit( fn3 ); _onexit( fn4 ); printf( \} int fn1() { printf( \return 0; } int fn2() { printf( \return 0; }
int fn3() {
printf( \return 0; }
int fn4() {
printf( \return 0; }
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters. 38. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？ 答案： #ifdef __cplusplus cout<<\#else cout<<\#endif 39.文件中有一组整数，要求排序后输出到另一个文件中
答案： ＃i nclude