VC/C++的面试题

青旅半醒 2022-08-12 03:00 43阅读 0赞

1、估计一下广州有多少理发师，如果允许，你还需要那些调研工作？并给出你的推导过程。你认为你的 估算结果可信吗？

2、看过那些软件方面的书籍  
3、什么是软件，软件开发包括那些步骤，并说出你对这些步骤的理解  
4、OSI网络结构的七层模型分别是什么，并说出你认为划分为7层的理由。  
5、软件过程中了解、使用过版本控制或建模工具吗？对你工作有什么帮助？  
6、软件过程中你都写过什么文档？分别是什么目的及其对你的帮助？  
7、我们知道，C++将内存划分为三个逻辑区域：堆、栈和静态存储，请说出它们的区别及你的理解。  
8、字符串A是由n个小写英文字母（a ~ z）构成的，定义为char A\[n\]。你能用更少的空间表示这个字符串吗？请写出从char A\[n\]到你的新的储存格式的转换函数。（请用C/C++编程，不允许上机操作）  
12、对现在的Stack（栈）数据结构进行改进，加一个min()功能，使之能在常数，即O(1)，时间内给出栈中的最小值。可对push()和pop()函数进行修改，但要求其时间复杂度都只能是O(1)。  
9、C++构造函数为什么不能是虚函数？  
10、C++中virtual与inline的含义分别是什么？虚函数的特点；内联函数的特点；一个函数能否即是虚函数又是内联函数？  
12、请列出实现C++代码你认为需要注意的一些问题。  
11、你在原来的项目中有没有遇到什么困难，又是如何解决的？  
  
1 dll,lib处理实现 .lib文件中包含什么 dll在内存中被多个函数共享,有几个拷贝  
2 template,template等编译的时候作为几个类  
3 struct ,class的区别,联系  
4 MAcro,inline区别,实现.编译运行时  
5 进程与线程区别  
6 hdc-cdc区别联系  
7 model dialog,modeless dialog,从创建到销毁全过程具体描述  
8 各个线程new的内存,别的线程是否可以使用？  
9 RUNTIME\_CLASS, is what  
  
[http://www.sinoprise.com/simple/index.php t32.html][http_www.sinoprise.com_simple_index.php t32.html]  
1. 堆和栈的区别？  
栈区（stack）- 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。  
堆区（heap） - 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。  
2. 虚函数的本质和实现机制？  
虚函数的本质就是通过基类访问派生类定义的函数。虚函数只能借助于指针或者引用来达到多态的效果。  
3. C++中传递函数参数的方式及他们的优缺点？  
4. static关键字的作用？  
5. 引用和指针的区别？  
6. 函数重载和覆盖的区别？  
7. 深拷贝和浅拷贝的区别？  
8. 数组a\[4\]\[3\]的内存结构 并指出a\[2\]\[3\]和a\[3\]\[2\]在内存中的位置？  
9. 包含和私有继承的区别？  
10. 实现一个操作栈的模板（empty，push，pop，），并实现错误处理（对空栈的pop）  
11. ANSI和Unicode的区别？并指出C RunTime Library 和 Win32 API对他们的支持。  
12. 线程同步的四种方式的机制。  
13. 虚拟内存。  
14. DLL的实现机制和DLL的输出方式。  
15. D3D的顶点着色。  
16. 几种数据结构在游戏中的支持。  
17. 游戏引擎  
  
服务器程序员笔试题  
C++  
1.简述堆和栈的区别。  
2.简述虚函数的本质和实现机制。  
3.列举C++中向函数传递参数的各种方式，并比较它们之间的区别和优缺点。  
4.static关键字有几种用途？请简述每种用途。  
5.简述引用和指针的异同。  
6.简述函数重载（overloading）和覆盖（overriding）的区别。  
7.什么是深拷贝？什么是浅拷贝？  
8.请画出二维数组char a\[4\]\[3\]的内存结构图，并指出a\[3\]\[2\]和a\[2\]\[3\]在内存中的位置。  
9.简述包含和私有继承的异同。  
10.用模板实现一个通用的栈，要求实现empty, size, push, pop, top五个成员函数，并用异常机制来报告错误（比如在一个大小为0的栈上执行pop操作）。  
标准库  
11.用string类编写一个程序，它从标准输入接收一行输入，然后统计出其中单词的个数，单词的分隔符只有逗号、点号和空格三种。  
12.简述STL的容器container、迭代器iterator、算法algorithm和函数器functor的作用以及它们之间的关系，举例说明。  
13.下面的代码存在什么问题，如何修正？  
list list1;  
for (int i = 0; i < 8; i ++) \{  
list1.push\_back(i);  
\}  
for (list::iterator it = list1.begin(); it != list1.end(); ++it) \{  
if (\*it % 2 == 0) \{  
list1.erase(it);  
\}  
\}  
Win32  
14.比较ANSI和Unicode的区别，并说明C Runtime Library和Win32 API如何支持二者。  
15.简述线程同步的四种机制。  
16.简述虚拟内存机制，并描述在win95和winnt下内存空间的结构。  
17.简述DLL的实现机制以及输出DLL中函数的两种方法。  
网络  
18.简述TCP和UDP之间的区别。  
19.简述Winsock的六种主要IO处理模式。  
20.描述一个你以前实现过的服务器的结构图，并分析其中可能存在的瓶颈。  
  
16. 关联、聚合(Aggregation)以及组合(Composition)的区别？  
涉及到UML中的一些概念：关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：  
  
从实现的角度讲，聚合可以表示为:  
class A \{...\} class B \{ A\* a; .....\}  
而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：  
  
实现的形式是:  
class A\{...\} class B\{ A a; ...\}  
参考文章： [http://www.cnitblog.com/Lily/archive/2006/02/23/6860.html][http_www.cnitblog.com_Lily_archive_2006_02_23_6860.html]  
[http://www.vckbase.com/document/viewdoc/ id=422][http_www.vckbase.com_document_viewdoc_ id_422]  
17.面向对象的三个基本特征，并简单叙述之？  
1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)  
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。  
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。  
18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？  
常考的题目。从定义上来说：  
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。  
重写：是指子类重新定义复类虚函数的方法。  
从实现原理上来说：  
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int\_func、str\_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！  
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。  
19. 多态的作用？  
主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。  
20. Ado与Ado.net的相同与不同？  
除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。  
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 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。  
27.struct 和 class 的区别  
答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。  
从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。  
28.当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）  
答案：肯定不是零。举个反例，如果是零的话，声明一个class A\[10\]对象数组，而每一个对象占用的空间是零，这时就没办法区分A\[0\],A\[1\]…了。  
29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）  
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址\*10H+通用寄存器内地址，就得到了真正要访问的地址。  
30. 比较C++中的4种类型转换方式？  
请参考： [http://blog.bioon.com/user1/8688/archives/2006/45399.shtml][http_blog.bioon.com_user1_8688_archives_2006_45399.shtml]，重点是static\_cast, dynamic\_cast和reinterpret\_cast的区别和应用。  
\[C/C++\] C/C++ 笔试、面试题目大汇总\[31-40\]  
bioeconomy 发表于 2006-3-22 17:49:00  
  
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\[\] = "hello world";  
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("zhanglin");  
\_onexit( fn1 );  
\_onexit( fn2 );  
\_onexit( fn3 );  
\_onexit( fn4 );  
printf( "This is executed first.n" );  
\}  
int fn1()  
\{  
printf( "next.n" );  
return 0;  
\}  
int fn2()  
\{  
printf( "executed " );  
return 0;  
\}  
int fn3()  
\{  
printf( "is " );  
return 0;  
\}  
int fn4()  
\{  
printf( "This " );  
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<<"c++";  
\#else  
cout<<"c";  
\#endif  
39.文件中有一组整数，要求排序后输出到另一个文件中  
答案：  
＃i nclude  
＃i nclude  
using namespace std;  
  
void Order(vector& data) //bubble sort  
\{  
int count = data.size() ;  
int tag = false ; // 设置是否需要继续冒泡的标志位  
for ( int i = 0 ; i < count ; i++)  
\{  
for ( int j = 0 ; j < count - i - 1 ; j++)  
\{  
if ( data\[j\] > data\[j+1\])  
\{  
tag = true ;  
int temp = data\[j\] ;  
data\[j\] = data\[j+1\] ;  
data\[j+1\] = temp ;  
\}  
\}  
if ( !tag )  
break ;  
\}  
\}  
  
void main( void )  
\{  
vectordata;  
ifstream in("c:\\data.txt");  
if ( !in)  
\{  
cout<<"file error!";  
exit(1);  
\}  
int temp;  
while (!in.eof())  
\{  
in>>temp;  
data.push\_back(temp);  
\}  
in.close(); //关闭输入文件流  
Order(data);  
ofstream out("c:\\result.txt");  
if ( !out)  
\{  
cout<<"file error!";  
exit(1);  
\}  
for ( i = 0 ; i < data.size() ; i++)  
out<40. 链表题：一个链表的结点结构  
struct Node  
\{  
int data ;  
Node \*next ;  
\};  
typedef struct Node Node ;  
  
(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)  
Node \* ReverseList(Node \*head) //链表逆序  
\{  
if ( head == NULL || head->next == NULL )  
return head;  
Node \*p1 = head ;  
Node \*p2 = p1->next ;  
Node \*p3 = p2->next ;  
p1->next = NULL ;  
while ( p3 != NULL )  
\{  
p2->next = p1 ;  
p1 = p2 ;  
p2 = p3 ;  
p3 = p3->next ;  
\}  
p2->next = p1 ;  
head = p2 ;  
return head ;  
\}  
(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）  
Node \* Merge(Node \*head1 , Node \*head2)  
\{  
if ( head1 == NULL)  
return head2 ;  
if ( head2 == NULL)  
return head1 ;  
Node \*head = NULL ;  
Node \*p1 = NULL;  
Node \*p2 = NULL;  
if ( head1->data < head2->data )  
\{  
head = head1 ;  
p1 = head1->next;  
p2 = head2 ;  
\}  
else  
\{  
head = head2 ;  
p2 = head2->next ;  
p1 = head1 ;  
\}  
Node \*pcurrent = head ;  
while ( p1 != NULL && p2 != NULL)  
\{  
if ( p1->data <= p2->data )  
\{  
pcurrent->next = p1 ;  
pcurrent = p1 ;  
p1 = p1->next ;  
\}  
else  
\{  
pcurrent->next = p2 ;  
pcurrent = p2 ;  
p2 = p2->next ;  
\}  
\}  
if ( p1 != NULL )  
pcurrent->next = p1 ;  
if ( p2 != NULL )  
pcurrent->next = p2 ;  
return head ;  
\}  
(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 (Autodesk)  
答案：  
Node \* MergeRecursive(Node \*head1 , Node \*head2)  
\{  
if ( head1 == NULL )  
return head2 ;  
if ( head2 == NULL)  
return head1 ;  
Node \*head = NULL ;  
if ( head1->data < head2->data )  
\{  
head = head1 ;  
head->next = MergeRecursive(head1->next,head2);  
\}  
else  
\{  
head = head2 ;  
head->next = MergeRecursive(head1,head2->next);  
\}  
return head ;  
\}  
  
  
\[C/C++\] C/C++ 笔试、面试题目大汇总\[41-45\]  
bioeconomy 发表于 2006-3-22 20:28:00  
  
41. 分析一下这段程序的输出 (Autodesk)  
class B  
\{  
public:  
B()  
\{  
cout<<"default constructor"<\}  
~B()  
\{  
cout<<"destructed"<\}  
B(int i):data(i) //B(int) works as a converter ( int -> instance of B)  
\{  
cout<<"constructed by parameter " << data <\}  
private:  
int data;  
\};  
  
B Play( B b)  
\{  
return b ;  
\}  
(1) results:  
int main(int argc, char\* argv\[\]) constructed by parameter 5  
\{ destructed B(5)形参析构  
B t1 = Play(5); B t2 = Play(t1); 　 destructed t1形参析构  
return 0;　　　　　　　　　　　　　　 destructed t2　注意顺序！  
\} destructed t1  
(2) results:  
int main(int argc, char\* argv\[\]) constructed by parameter 5  
\{ destructed B(5)形参析构  
B t1 = Play(5); B t2 = Play(10); 　 constructed by parameter 10  
return 0;　　　　　　　　　　　　　　 destructed B(10)形参析构  
\} destructed t2　注意顺序！  
destructed t1  
42. 写一个函数找出一个整数数组中，第二大的数 （microsoft）  
答案：  
const int MINNUMBER = -32767 ;  
int find\_sec\_max( int data\[\] , int count)  
\{  
int maxnumber = data\[0\] ;  
int sec\_max = MINNUMBER ;  
for ( int i = 1 ; i < count ; i++)  
\{  
if ( data\[i\] > maxnumber )  
\{  
sec\_max = maxnumber ;  
maxnumber = data\[i\] ;  
\}  
else  
\{  
if ( data\[i\] > sec\_max )  
sec\_max = data\[i\] ;  
\}  
\}  
return sec\_max ;  
\}  
43. 写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。  
KMP算法效率最好，时间复杂度是Ｏ(n+m),详见： [http://www.zhanglihai.com/blog/c\_335\_kmp.html][http_www.zhanglihai.com_blog_c_335_kmp.html]  
44. 多重继承的内存分配问题：  
比如有class A : public class B, public class C \{\}  
那么A的内存结构大致是怎么样的？  
这个是compiler-dependent的, 不同的实现其细节可能不同。  
如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。  
可以参考《深入探索C++对象模型》，或者：  
[http://blog.csdn.net/rainlight/archive/2006/03/03/614792.aspx][http_blog.csdn.net_rainlight_archive_2006_03_03_614792.aspx]  
[http://msdn.microsoft.com/archive/default.asp url=/archive/en-us/dnarvc/html/jangrayhood.asp][http_msdn.microsoft.com_archive_default.asp url_archive_en-us_dnarvc_html_jangrayhood.asp]  
  
45. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）  
struct node \{ char val; node\* next;\}  
bool check(const node\* head) \{\} //return false : 无环；true: 有环  
一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：  
bool check(const node\* head)  
\{  
if(head==NULL) return false;  
node \*low=head, \*fast=head->next;  
while(fast!=NULL && fast->next!=NULL)  
\{  
low=low->next;  
fast=fast->next->next;  
if(low==fast) return true;  
\}  
return false;  
\}  
  
一、请填写BOOL , float, 指针变量 与“零值”比较的 if 语句。（10分）  
  
提示：这里“零值”可以是0, 0.0 , FALSE或者“空指针”。例如 int 变量 n 与“零值”比较的 if 语句为：  
if ( n == 0 )  
if ( n != 0 )  
以此类推。  
  
  
请写出 BOOL flag 与“零值”比较的 if 语句：  
  
  
  
  
请写出 float x 与“零值”比较的 if 语句：  
  
  
  
  
  
请写出 char \*p 与“零值”比较的 if 语句：  
  
  
  
  
  
  
二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）  
  
  
char str\[\] = “Hello” ;  
char \*p = str ;  
int n = 10;  
请计算  
sizeof (str ) =  
  
sizeof ( p ) =  
  
sizeof ( n ) =  
void Func ( char str\[100\])  
\{  
请计算  
sizeof( str ) =  
\}  
  
  
void \*p = malloc( 100 );  
请计算  
sizeof ( p ) =  
  
  
  
  
三、简答题（25分）  
  
  
1、头文件中的 ifndef/define/endif 干什么用？  
  
  
  
  
  
2、\#include 和 \#include “filename.h” 有什么区别？  
  
  
  
  
  
3、const 有什么用途？（请至少说明两种）  
  
  
  
  
  
4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”声明？  
  
  
  
  
  
  
5、请简述以下两个for循环的优缺点  
  
// 第一个  
  
for (i=0; i  
\{  
  
if (condition)  
  
DoSomething();  
  
else  
  
DoOtherthing();  
  
\}  
// 第二个  
  
if (condition)  
  
\{  
  
for (i=0; i  
DoSomething();  
  
\}  
  
else  
  
\{  
  
for (i=0; i  
DoOtherthing();  
  
\}  
  
优点：  
  
  
  
缺点：  
  
  
  
优点：  
  
  
  
缺点：  
  
  
  
  
  
四、有关内存的思考题（20分）  
  
  
void GetMemory(char \*p)  
  
\{  
  
p = (char \*)malloc(100);  
  
\}  
  
void Test(void)  
\{  
char \*str = NULL;  
  
GetMemory(str);  
  
strcpy(str, "hello world");  
  
printf(str);  
  
\}  
  
  
请问运行Test函数会有什么样的结果？  
  
答：  
  
  
  
  
  
  
char \*GetMemory(void)  
  
\{  
  
char p\[\] = "hello world";  
  
return p;  
  
\}  
  
void Test(void)  
  
\{  
  
char \*str = NULL;  
  
str = GetMemory();  
  
printf(str);  
  
\}  
  
  
请问运行Test函数会有什么样的结果？  
  
答：  
  
Void GetMemory2(char \*\*p, int num)  
  
\{  
  
\*p = (char \*)malloc(num);  
  
\}  
void Test(void)  
  
\{  
  
char \*str = NULL;  
  
GetMemory(&str, 100);  
  
strcpy(str, "hello");  
  
printf(str);  
  
\}  
请问运行Test函数会有什么样的结果？  
  
答：  
  
  
  
  
  
  
  
void Test(void)  
  
\{  
  
char \*str = (char \*) malloc(100);  
  
strcpy(str, “hello”);  
  
free(str);  
  
if(str != NULL)  
  
\{  
  
strcpy(str, “world”);  
  
printf(str);  
  
\}  
  
\}  
请问运行Test函数会有什么样的结果？  
  
答：  
  
  
  
  
  
  
  
  
  
  
  
五、编写strcpy函数（10分）  
  
已知strcpy函数的原型是  
char \*strcpy(char \*strDest, const char \*strSrc);  
其中strDest是目的字符串，strSrc是源字符串。  
  
  
（1）不调用C++/C的字符串库函数，请编写函数 strcpy  
  
  
  
  
  
  
  
  
  
  
  
（2）strcpy能把strSrc的内容复制到strDest，为什么还要char \* 类型的返回值？  
  
  
  
  
  
  
六、编写类String的构造函数、析构函数和赋值函数（25分）  
  
已知类String的原型为：  
class String  
  
\{  
  
public:  
  
String(const char \*str = NULL); // 普通构造函数  
  
String(const String &other); // 拷贝构造函数  
  
~ String(void); // 析构函数  
  
String & operate =(const String &other); // 赋值函数  
  
private:  
  
char \*m\_data; // 用于保存字符串  
  
\};  
  
请编写String的上述4个函数。  
  
以上题目摘自林锐博士的《高质量C++编程指南》。大家可以去看这本书作为参考

[http_www.sinoprise.com_simple_index.php t32.html]: http://www.sinoprise.com/simple/index.php?t32.html
[http_www.cnitblog.com_Lily_archive_2006_02_23_6860.html]: http://www.cnitblog.com/Lily/archive/2006/02/23/6860.html
[http_www.vckbase.com_document_viewdoc_ id_422]: http://www.vckbase.com/document/viewdoc/?id=422
[http_blog.bioon.com_user1_8688_archives_2006_45399.shtml]: http://blog.bioon.com/user1/8688/archives/2006/45399.shtml
[http_www.zhanglihai.com_blog_c_335_kmp.html]: http://www.zhanglihai.com/blog/c_335_kmp.html
[http_blog.csdn.net_rainlight_archive_2006_03_03_614792.aspx]: http://blog.csdn.net/rainlight/archive/2006/03/03/614792.aspx
[http_msdn.microsoft.com_archive_default.asp url_archive_en-us_dnarvc_html_jangrayhood.asp]: http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarvc/html/jangrayhood.asp