昆明吉鑫合金有限公司:C++ 面试题

1  ＃i nclude “filename.h”和＃i nclude 的区别?
   答：对于＃i nclude 编译器从标准库开始搜索filename.h
    对于＃i nclude “filename.h”编译器从用户工作路径开始搜索filename.h
2  头文件的作用是什么?
答：一、通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需
要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
二、头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规
则能大大减轻程序员调试、改错的负担。
3  C++函数中值的传递方式有哪几种?
答：C++函数的三种传递方式为：值传递、指针传递和引用传递。
4  内存的分配方式的分配方式有几种?
答：一、从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。
二、在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内
存分配运
算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
三、从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free
或delete释放
内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

5  实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数;
答：双向链表删除一个节点P
template void list::delnode(int p)
{
 int k=1;
 listnode *ptr,*t;
 ptr=first;

 while(ptr->next!=NULL&&k!=p)
 {
  ptr=ptr->next;
     k++;
 }
    t=ptr->next;
 cout<<"你已经将数据项 "<data<<"删除"< 
 ptr->next=ptr->next->next;
 length--;
 delete t;
}

在节点P后插入一个节点：
template bool list::insert(type t,int p)
{
 listnode *ptr;
 ptr=first;

 int k=1;
 while(ptr!=NULL&&k {
  ptr=ptr->next;
  k++;
 }
 if(ptr==NULL&&k!=p)
  return false;
 else
 {
   listnode *tp;
   tp=new listnode;
   tp->data=t;
   tp->next=ptr->next;
   ptr->next=tp;
   length++;
  
   return true;
 }
}

6  写一个函数，将其中的\t都转换成4个空格。
   void change(char* pstr)
   {
      while(*pstr++ != '\0')
      {
         if (*pstr == '\t')
           
           
      }
    }

7  Windows程序的入口是哪里？写出Windows消息机制的流程.

8  如何定义和实现一个类的成员函数为回调函数？

9  C++里面是不是所有的动作都是main()引起的？如果不是，请举例.
答：在运行c++程序时，通常从main()函数开始执行。因此如果没有main(),程序将不完整，编译器将指出未定义main()函数。
   例外情况：如， 在windows编程中，可以编写一个动态连接库（dll)模块，这是其他windows程序可以使用的代码。由于
   DLL模块不是独立的程序，因此不需要main().用于专用环境的程序--如机器人中的控制器芯片--可能不需要main().但常规的
   独立程序都需要main().

10 C++里面如何声明const void f(void)函数为C程序中的库函数？
11 下列哪两个是等同的

int b;

A const int* a = &b;

B const* int a = &b;

C const int* const a = &b;

D int const* const a = &b;

12 内联函数在编译时是否做参数类型检查

13 三个float:a,b,c
问值
(a+b)+c==(b+a)+c
(a+b)+c==(a+c)+b
14 把一个链表反向填空
  void reverse(test* head)
  {
     test* pe = head;
     test* ps = head->next;
     while(ps)
     {  
        pe->next = ps->next;
        ps->next = head;
        head = ps;
        ps = pe->next;
     }
   }
       

15 设计一个重采样系统，说明如何anti-alias

16 某个程序在一个嵌入式系统(200M的CPU,50M的SDRAM)中已经最化了，换到另一个系统(300M的CPU,50M的SDRAM)中运行，还需要优化吗？

17. 下面哪种排序法对12354最快
a quick sort
b.buble sort
c.merge sort

18. 哪种结构，平均来讲，获取一个值最快
a. binary tree
b. hash table
c. stack

19 请问C++的类和C里面的struct有什么区别？
答：c++的类的成员默认情况下是私有的,c的struct的成员默认情况下是公共的.

20 请讲一讲析构函数和虚函数的用法和作用？
答：析构函数的作用是当对象生命期结束时释放对象所占用的资源。 析构函数用法：析构函数是特殊的类成员函数
它的名字和类名相同，没有返回值，没有参数不能随意调用也没有重载。只是在类对象生命期结束时有系统自动调用。
   虚函数用在继承中，当在派生类中需要重新定义基类的函数时需要在基类中将该函数声明为虚函数，作用为使程序支持动态联遍。

21 全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？
 答：一些变量整个程序中都是可见的，它们称为全局变量，一些变量在函数内部定义且只在函数中可知，则称为局部变量。
全局变量由编译器建立且存放在内存的全局数据区，局部变量存放在栈区

22 一些寄存器的题目，主要是寻址和内存管理等一些知识。

23 8086是多少尉的系统？在数据总线上是怎么实现的？

24 多态。overload 和 override的区别。
答：重载在相同范围（同一个类中），函数名字相同，参数不同，virtual关键字可有可无。
 覆盖是指派生类函数覆盖基类函数，不同的范围，函数名字相同，参数相同，基类函数必须有virtual关键字。

<>
25．完成下列程序

*

*.*.

*..*..*..

*...*...*...*...

*....*....*....*....*....

*.....*.....*.....*.....*.....*.....

*......*......*......*......*......*......*......

*.......*.......*.......*.......*.......*.......*.......*.......

＃i nclude
using namespace std;

const int n = 8;

main()
{
   int i;
   int j;
   int k;

   for(i = n; i >= 1; i--)
   {
      for(j = 0; j < n-i+1; j++)
      {
         cout<<"*";
         for(k=1; k < n-i+1; k++)
         {
            cout<<".";
         }
      }
      cout<   }
   system("pause");
}

26 完成程序，实现对数组的降序排序

＃i nclude
using namespace std;

void sort(int* arr, int n);

int main()

{
   int array[]={45,56,76,234,1,34,23,2,3};
   sort(array, 9);
   for(int i = 0; i <= 8; i++)//曾经在这儿出界
      cout<   cout<   system("pause");
}

void sort(int* arr, int n)
{
   int temp;
   for(int i = 1; i < 9; i++)
   {
      for(int k = 0; k < 9 - i; k++)//曾经在这儿出界
      {
         if(arr[k] < arr[k + 1])
            {
               temp = arr[k];
               arr[k] = arr[k + 1];
               arr[k + 1] = temp;
            } 
      }
   }
}

27 费波那其数列，1，1，2，3，5……编写程序求第十项。可以用递归，也可以用其他方法，但要说明你选择的理由。
非递归
＃i nclude
using namespace std;

int Pheponatch(int n);

main()
{
   int Ph = Pheponatch(10);
   cout<   system("pause");
  
}

int Pheponatch(int n)
{
   int elem;
   int n1 = 1;
   int n2 = 1;
   if(n == 1 || n ==2)
          return 1;
   else
   {
      for(int i = 3; i <= n; i++)
      {
         elem = n1 + n2;
         n1 = n2;
         n2 = elem;
      }
      return elem;
  }
}  

递归
＃i nclude
using namespace std;

int Pheponatch(int n);

main()
{
   int n;
   cin>>n;
   int ph = Pheponatch(n);
   cout<   system("pause");
  
}

int Pheponatch(int n)
{  
    if(n <= 0)
       exit(-1);
    else
       if(n == 1 || n ==2)
          return 1;
    else
       return Pheponatch(n - 1) + Pheponatch(n - 2);
}  

28 下列程序运行时会崩溃，请找出错误并改正，并且说明原因。

＃i nclude

＃i nclude

typedef struct{

   TNode* left;

   TNode* right;

   int value;

} TNode;

TNode* root=NULL;

void append(int N);

int main()

{

   append(63);

   append(45);

   append(32);

   append(77);

   append(96);

   append(21);

   append(17); // Again, 数字任意给出

}

void append(int N)

{

 TNode* NewNode=(TNode *)malloc(sizeof(TNode));

 NewNode->value=N;

 if(root==NULL)

 {

   root=NewNode;

   return;

 }

 else

 {

   TNode* temp;

   temp=root;

   while((N>=temp.value && temp.left!=NULL) || (N

))

   {

      while(N>=temp.value && temp.left!=NULL)

                 temp=temp.left;

      while(N

                 temp=temp.right;

   }

   if(N>=temp.value)

          temp.left=NewNode;

   else

          temp.right=NewNode;

   return;       

 }

}

29. A class B network on the internet has a subnet mask of 255.255.240.0, what is the maximum number of hosts per subnet       .

a. 240                  b. 255                  c. 4094                d. 65534

30. What is the difference: between o(log n) and o(log n^2), where both logarithems have base 2       .

a. o(log n^2) is bigger                  b. o(log n) is bigger

c. no difference
31. For a class what would happen if we call a class’s constructor from with the same class’s constructor       .

a. compilation error             b. linking error

c. stack overflow                          d. none of the above

32. “new” in c++ is a:       .

a. library function like malloc in c

b. key word                                    c. operator

d. none of the above

33. Which of the following information is not contained in an inode       .

a. file owner                                   b. file size

c. file name                                     d. disk address

34. What’s the number of comparisons in the worst case to merge two sorted lists containing n elements each       .

a. 2n           b.2n-1                 c.2n+1                d.2n-2

35. Time complexity of n algorithm T(n), where n is the input size ,is T(n)=T(n-1)+1/n if n>1 otherwise 1 the order of
 this algorithm is       .

a. log (n)   b. n                     c. n^2                  d. n^n

36. The number of 1’s in the binary representation of 3*4096+ 15*256+5*16+3 are       .

a. 8                      b. 9                      c. 10           d. 12

37．设计函数 int atoi(char *s)。

38．int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 输出是多少？

39．解释局部变量、全局变量和静态变量的含义。

40．解释堆和栈的区别。
 栈区（stack）—   由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆:一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于
链表.

41．论述含参数的宏与函数的优缺点。

42. 以下三条输出语句分别输出什么？[C易]
char str1[]       = "abc";
char str2[]       = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5  = "abc";
const char* str6  = "abc";
cout << boolalpha << ( str1==str2 ) << endl; // 输出什么？
cout << boolalpha << ( str3==str4 ) << endl; // 输出什么？
cout << boolalpha << ( str5==str6 ) << endl; // 输出什么？

43. 非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A？[C++中等]
答：
a. class B : public A { ……} // B公有继承自A，可以是间接继承的
b. class B { operator A( ); } // B实现了隐式转化为A的转化
c. class A { A( const B& ); } // A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数
d. A& operator= ( const A& ); // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

44. 以下代码中的两个sizeof用法有问题吗？[C易]
void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
    for( size_t i=0; i        if( 'a'<=str[i] && str[i]<='z' )
            str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;

45. 以下代码有什么问题？[C难]
void char2Hex( char c ) // 将字符以16进制表示
{
    char ch = c/0x10 + '0'; if( ch > '9' ) ch += ('A'-'9'-1);
    char cl = c%0x10 + '0'; if( cl > '9' ) cl += ('A'-'9'-1);
    cout << ch << cl << ' ';
}
char str[] = "I love 中国";
for( size_t i=0; i    char2Hex( str[i] );
cout << endl;

46. 以下代码有什么问题？[C++易]
struct Test
{
    Test( int ) {}
    Test() {}
    void fun() {}
};
void main( void )
{
    Test a(1);
    a.fun();
    Test b();
    b.fun();
}
***  Test b();//定义了一个函数

47. 以下代码有什么问题？[C++易]
cout << (true?1:"1") << endl;

8. 以下代码能够编译通过吗，为什么？[C++易]
unsigned int const size1 = 2;
char str1[ size1 ];
unsigned int temp = 0;
cin >> temp;
unsigned int const size2 = temp;
char str2[ size2 ];

48. 以下代码中的输出语句输出0吗，为什么？[C++易]
struct CLS
{
    int m_i;
    CLS( int i ) : m_i(i) {}
    CLS()
    {
        CLS(0);
    }
};
CLS obj;
cout << obj.m_i << endl;

49. C++中的空类，默认产生哪些类成员函数？[C++易]
答：
class Empty
{
public:
    Empty();                          // 缺省构造函数
    Empty( const Empty& );            // 拷贝构造函数
    ~Empty();                         // 析构函数
    Empty& operator=( const Empty& ); // 赋值运算符
    Empty* operator&();               // 取址运算符
    const Empty* operator&() const;   // 取址运算符 const
};

50. 以下两条输出语句分别输出什么？[C++难]
float a = 1.0f;
cout << (int)a << endl;
cout << (int&)a << endl;
cout << boolalpha << ( (int)a == (int&)a ) << endl; // 输出什么？
float b = 0.0f;
cout << (int)b << endl;
cout << (int&)b << endl;
cout << boolalpha << ( (int)b == (int&)b ) << endl; // 输出什么？

51. 以下反向遍历array数组的方法有什么错误？[STL易]
vector array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 3 );
for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组
{
    cout << array[i] << endl;
}

52. 以下代码有什么问题？[STL易]
typedef vector IntArray;
IntArray array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 2 );
array.push_back( 3 );
// 删除array数组中所有的2
for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
{
    if( 2 == *itor ) array.erase( itor );
}

53. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]
答：
void* mymemcpy( void *dest, const void *src, size_t count )
{
    char* pdest = static_cast( dest );
    const char* psrc = static_cast( src );
    if( pdest>psrc && pdest    {
        for( size_t i=count-1; i!=-1; --i )
                pdest[i] = psrc[i];
    }
    else
    {
        for( size_t i=0; i            pdest[i] = psrc[i];
    }
    return dest;
}
int main( void )
{
    char str[] = "0123456789";
    mymemcpy( str+1, str+0, 9 );
    cout << str << endl;

    system( "Pause" );
    return 0;
}

54 线程与进程的区别

55：请你分别划划OSI的七层网络结构图，和TCP/IP的五层结构图？

56：请你详细的解释一下IP协议的定义，在哪个层上面，主要有什么作用？ TCP与UDP呢？
  IP协议是网络层的协议，它实现了Internet中自动路由的功能，即寻径的功能，TCP协议是一个传输性的协议它向下屏蔽了IP协议不可靠传输的特性，向上提供一个可靠的点到点的传输，UDP提供的是一种无连接的服务,主要考虑到很多应用不需要可靠的连接，但需要快速的传输

57：请问交换机和路由器分别的实现原理是什么？分别在哪个层次上面实现的？
   交换机用在局域网中，交换机通过纪录局域网内各节点机器的MAC地质(物理地址)就可以实现传递报文,无需看报文中的IP地质。路由器识别不同网络的方法是通过识别不同网络的网络ID号(IP地址的高端部分)进行的，所以为了保证路由成功，每个网络都必须有一个唯一的网络编号。路由器通过察看报文中IP地址，来决定路径，向那个子网(下一跳)路由，也就是说交换机工作在数据链路层看MAC地址，路由器工作在网际层看IP地质
但是由于现在网络设备的发展，很多设备既有交换机的功能有由路由器的功能(交换试路由器)使得两者界限越来越模糊。

58:请问C++的类和C里面的struct有什么区别？

59:请讲一讲析构函数和虚函数的用法和作用？

60:全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是怎么知道的？
   全局变量是整个程序都可访问的变量，谁都可以访问，生存期在整个程序从运行到结束(在程序结束时所占内存释放)，而局部变量存在于模块(子程序，函数)中，只有所在模块可以访问，其他模块不可直接访问，模块结束(函数调用完毕)，局部变量消失，所占据的内存释放。
全局变量分配在全局数据段并且在程序开始运行的时候被加载. 局部变量则分配在堆栈里面。

61:一些寄存器的题目，主要是寻址和内存管理等一些知识。

2、交换机用在局域网中，交换机通过纪录局域网内各节点机器的MAC地质(物理地址)就可以实现传递报文,无需看报文中的IP地质。路由器识别不同网络的方法是通过识别不同网络的网络ID号(IP地址的高端部分)进行的，所以为了保证路由成功，每个网络都必须有一个唯一的网络编号。路由器通过察看报文中IP地址，来决定路径，向那个子网(下一跳)路由，也就是说交换机工作在数据链路层看MAC地址，路由器工作在网际层看IP地质
但是由于现在网络设备的发展，很多设备既有交换机的功能有由路由器的功能(交换试路由器)使得两者界限越来越模糊。
3、IP协议是网络层的协议，它实现了Internet中自动路由的功能，即寻径的功能，TCP协议是一个传输性的协议它向下屏蔽了IP协议不可靠传输的特性，向上提供一个可靠的点到点的传输，UDP提供的是一种无连接的服务,主要考虑到很多应用不需要可靠的连接，但需要快速的传输
4、
 Test b();//定义了一个函数

62:8086是多少位的系统？在数据总线上是怎么实现的？

<>
63.怎样用最快的方法判断链表是否有环?

64.c++中引用和指针有什么不同?指针加上什么限制等于引用?
答：1 引用被创建的时候必须被初始化，而指针不是必需的。2 引用在创建后就不能改变引用的关系，而指针在初始化后可以随时指向
其它的变量或对象。3 没有NULL引用,引用必须与合法的存储单元关联，而指针可以是NULL。

65.做的项目,遇到的困难,怎样解决?

69.操作符重载
class CMyObject:pulic CObject
{
Public:
CMyObject();
CMyObject &operator=(const CMyObject &my);
private:
CString strName;
int nId:
};
请重载赋值操作符

70.链表
Struct structList
{
int value;
structList *pHead;
}
Struct LinkedList *pMyList;
请编写删除链表的头、尾和第n个节点的程序

71.用Socket API制作一个聊天程序，通讯协议使用tcp/ip。要求有简单界面即可，支持多人聊天。

72.如果有过工作经验，请说明在先前公司的工作以及离职原因（如无，请说明毕业后的个人展望）

***************************************************************************
73 对于C++中类(class) 与结构(struct)的描述正确的为:
  A,类中的成员默认是private的,当是可以声明为public,private 和protected,结构中定义的成员默认的都是public;
  B,结构中不允许定义成员函数,当是类中可以定义成员函数;
  C,结构实例使用malloc() 动态创建,类对象使用new 操作符动态分配内存;
  D,结构和类对象都必须使用new 创建;
  E,结构中不可以定义虚函数,当是类中可以定义虚函数.
  F,结构不可以存在继承关系,当是类可以存在继承关系.
答:A,D,F

74,两个互相独立的类:ClassA 和 ClassB,都各自定义了非静态的公有成员函数 PublicFunc() 和非静态的私有成员函数 PrivateFunc();
   现在要在ClassA 中增加定义一个成员函数ClassA::AdditionalPunction(ClassA a,ClassB b);则可以在AdditionalPunction(ClassA x,ClassB y)的实现部分(函数功能体内部)
    出现的合法的表达是最全的是:
    A,x.PrivateFunc();x.PublicFunc();y.PrivateFunc();y.PublicFunc();
    B,x.PrivateFunc();x.PublicFunc();y.PublicFunc();
    C,x.PrivateFunc();y.PrivateFunc();y.PublicFunc();
    D,x.PublicFunc();y.PublicFunc();
答:B
75,C++程序下列说法正确的有:
  A,对调用的虚函数和模板类都进行迟后编译.
  B,基类与子类中函数如果要构成虚函数,除了要求在基类中用virtual 声名,而且必须名字相同且参数类型相同返回类型相同
  C,重载的类成员函数都必须要:或者返回类型不同,或者参数数目不同,或者参数序列的类型不同.
  D,静态成员函数和内联函数不能是虚函数,友员函数和构造函数也不能是虚函数,但是析构函数可以是虚函数.
答:A
***************************************************************************

76,C++中的类与结构的区别?

77,构造函数和析构函数是否可以被重载,为什么?
答：构造函数可以被重载，析构函数不可以被重载。因为构造函数可以有多个且可以带参数，而析构函数只能有一个，且不能带参数。

78,一个类的构造函数和析构函数什么时候被调用,是否需要手工调用?
答：构造函数在创建类对象的时候被自动调用，析构函数在类对象生命期结束时，由系统自动调用。

1  ＃i nclude “filename.h”和＃i nclude 的区别?
答：＃i nclude “filename.h”表明该文件是用户提供的头文件，查找该文件时从当前文件目录开始；＃i nclude 表明这个文件是一个工程或标准头文件，查找过程会检查预定义的目录。

2  头文件的作用是什么?
答：一、通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
二、头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。

3  C++函数中值的传递方式有哪几种?
答：C++函数的三种传递方式为：值传递、指针传递和引用传递。

4  内存的分配方式的分配方式有几种?
答：一、从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。
二、在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
三、从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

5  实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数;
答：双向链表删除一个节点P
template void list::delnode(int p)
{
 int k=1;
 listnode *ptr,*t;
 ptr=first;

 while(ptr->next!=NULL&&k!=p)
 {
  ptr=ptr->next;
     k++;
 }
    t=ptr->next;
 cout<<"你已经将数据项 "<data<<"删除"< 
 ptr->next=ptr->next->next;
 length--;
 delete t;
}

在节点P后插入一个节点：
template bool list::insert(type t,int p)
{
 listnode *ptr;
 ptr=first;

 int k=1;
 while(ptr!=NULL&&k {
  ptr=ptr->next;
  k++;
 }
 if(ptr==NULL&&k!=p)
  return false;
 else
 {
   listnode *tp;
   tp=new listnode;
   tp->data=t;
   tp->next=ptr->next;
   ptr->next=tp;
   length++;
  
   return true;
 }
}

//上海贝尔的面试题43分即可进入复试
一、请填写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、＃i nclude     和  ＃i nclude  “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();
优点：N次中，每次都要对condition进行判断
 缺点： 优点：一次判断condition后，对something或Otherthing执行N次
 缺点：
 
四、有关内存的思考题（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
char *strcpy(char *strDest,const char *strSrc){
          int n=0;
          while(strSrc[n]!=NULL){
               n++:
          }
          *srtDest=new char[n];
          for(int i=0;i    strDest=strSrc[i];
              i++;
}
return *strDest;
}      
（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个函数。

//答案一并给出
一、请填写BOOL , float, 指针变量 与“零值”比较的 if 语句。（10分）
 
请写出 BOOL  flag 与“零值”比较的 if 语句。（3分）
标准答案：
    if ( flag )
    if ( !flag )如下写法均属不良风格，不得分。
if (flag == TRUE)
if (flag == 1 )
if (flag == FALSE) 
    if (flag == 0)
请写出 float  x 与“零值”比较的 if 语句。（4分）
标准答案示例：
const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)
不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。
   
如下是错误的写法，不得分。
if (x == 0.0)
if (x != 0.0)

请写出 char  *p 与“零值”比较的 if 语句。（3分）
标准答案：
    if (p == NULL)
    if (p != NULL)如下写法均属不良风格，不得分。
if (p == 0)
if (p != 0)
if (p) 
    if (!)
 
二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）
 
char  str[] = “Hello” ;
char   *p = str ;
int     n = 10;
请计算
sizeof (str ) =  6   （2分）
        
sizeof ( p ) =   4   （2分）
         
sizeof ( n ) =   4   （2分）void Func ( char str[100])
{
请计算
 sizeof( str ) =   4     （2分）
}
 
void *p = malloc( 100 );
请计算
sizeof ( p ) =  4      （2分）
 
 
三、简答题（25分）
 
1、头文件中的 ifndef/define/endif 干什么用？（5分）
答：防止该头文件被重复引用。
 
2、＃i nclude     和  ＃i nclude  “filename.h” 有什么区别？（5分）
答：对于＃i nclude  ，编译器从标准库路径开始搜索 filename.h
    对于＃i nclude  “filename.h” ，编译器从用户的工作路径开始搜索 filename.h
 
3、const 有什么用途？（请至少说明两种）（5分）
答：（1）可以定义 const 常量
（2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
 
4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ （5分）
答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);
该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。
       
5、请简述以下两个for循环的优缺点（5分）
 
for (i=0; i{
if (condition)
    DoSomething();
else
    DoOtherthing();
}if (condition)
{
for (i=0; i    DoSomething();
}
else
{
    for (i=0; i    DoOtherthing();
}
优点：程序简洁
 
缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。优点：循环的效率高
 
缺点：程序不简洁
 
 
 
四、有关内存的思考题（每小题5分，共20分）
 
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
 
请问运行Test函数会有什么样的结果？
答：程序崩溃。
因为GetMemory并不能传递动态内存，
Test函数中的 str一直都是 NULL。
strcpy(str, "hello world");将使程序崩溃。
 char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
 
请问运行Test函数会有什么样的结果？
答：可能是乱码。
因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。
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函数会有什么样的结果？
答：
（1）能够输出hello
（2）内存泄漏
 
 void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);   
if(str != NULL)
{
  strcpy(str, “world”);
printf(str);
}
}
请问运行Test函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预料，非常危险。
因为free(str);之后，str成为野指针，
if(str != NULL)语句不起作用。
 

27 费波那其数列，1，1，2，3，5……编写程序求第十项。可以用递归，也可以用其他方法，但要说明你选择的理由。
-------------------------------------------------------------------------------------

＃i nclude
＃i nclude

int Pheponatch(int);
int Pheponatch2(int);

int main()

{
   printf("The 10th is %d",Pheponatch2(20));
   system("pause");
   return 0;
}

//递归算法
int Pheponatch(int N)
{
    if( N == 1 || N == 2)
    {
        return 1;
    }   
    else
        return Pheponatch( N -1 ) + Pheponatch( N -2 );
}

//非递归算法
int Pheponatch2(int N)
{
    int x = 1, y = 1, temp;
    int i = 2;
    while(true)
    {
        temp = y;
        y = x + y;
        x = temp;
        i++;
        if( i == N )
        break;
    }   
    return y;
}

25．完成下列程序

*

*.*.

*..*..*..

*...*...*...*...

*....*....*....*....*....

*.....*.....*.....*.....*.....*.....

*......*......*......*......*......*......*......

*.......*.......*.......*.......*.......*.......*.......*.......

＃i nclude

#define N 8

int main()

{

   int i;

   int j;

   int k;

   ---------------------------------------------------------

   |                                     |

   |                                     |

   |                                     |

   ---------------------------------------------------------

   return 0;

}

＃i nclude
＃i nclude

#define N 8

int main()

{
   int i;
   int j;
   int k;

   for(i=N; i>=1; i--)
   {
   for(j=0; j   {
   cout<<"*";
       for(k=1; k   cout<<".";
   }
   cout<<"\n";
   }

   return 0;
}

"28 下列程序运行时会崩溃，请找出错误并改正，并且说明原因。"
// void append(int N) ;
//指针没有初始化：
//NewNode->left=NULL;
//NewNode->right=NULL;

＃i nclude

＃i nclude

typedef struct TNode{

TNode* left;

TNode* right;

int value;

} TNode;

TNode* root=NULL;

void append(int N);

int main()

{

append(63);

append(45);

append(32);

append(77);

append(96);

append(21);

append(17); // Again, 数字任意给出
return 0;

}

void append(int N)

{

TNode* NewNode=(TNode *)malloc(sizeof(TNode));

NewNode->value=N;

NewNode->left=NULL;
NewNode->right=NULL;

if(root==NULL)

{

root=NewNode;

return;

}

else

{

TNode* temp;

temp=root;

while((N>=temp->value && temp->left!=NULL) || (Nvalue && temp->right!=NULL))

{

while(N>=temp->value && temp->left!=NULL)

temp=temp->left;

while(Nvalue && temp->right!=NULL)

temp=temp->right;

}

if(N>=temp->value)

temp->left=NewNode;

else

temp->right=NewNode;

return;       

}

}

算法：
1．什么是NPC，NP-Hard？
2．起泡排序的时间复杂度是多少？
说出至少一个比它更快的算法；
排序的极限时间复杂度是多少？
3．有一个链表，如何判断它是一个循环链表？
如果链表是单向的呢？
如果出现循环的点可能在任意位置呢？
如果缓存空间是有限的，比如是一个常数呢？
如果只能使用2个缓存呢？
4．有一个文件，保存了若干个整数，如何以平均的概率随机得到其中的一个整数？
如果整数的个数是未知的呢？
如果整数是以字符串形式存放，如：（即如何得到随机的一个字符串）
123
-456
…
如果只允许便历文件一次呢？
5．用两组数据，都在内存中，对它们排序分别需要1和2分钟；那么使用两个线程一起排序，大概需要多少时间？

C/C++：
1．C与C++的异同，优劣；
2．C，C++，VC，BC，TC的区别；
3．C++中try…catch关键字的用法与优点；
4．枚举的用法，以及它与宏的区别；
5．const的用法，以及声明const变量与宏的区别；
   const的用法有四种：
   区别：const常量有数据类型， 而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只能进行字符替换，没有类型
   安全检查。而且字符替换可能会带来料想不到的边界效应。
   有些集成化工具可以对const常量进行调试， 但不能对宏量进行调试。
6．C++中引用与指针的区别；
     答：1 引用实际上是所引用的对象或变量的别名，而指针是包含所指向对象或变量的地址的变量。
            2 引用在定义时必须初始化，而指针在定义时不初始化。
            3 不可以有努NULL的引用，而可以有指向NULL的指针。
            4 引用在初始化后不可以改变引用关系，而指针可以随时指向其他对象（非const指针）。
7．C++中virtual与inline的含义分别是什么？
   答：在基类成员函数的声明前加上virtual关键字，意味着将该成员函数声明为虚函数。
       inline与函数的定义体放在一起，使该函数称为内联。inline是一种用于实现的关键字，而不是用于声明的关键字。
虚函数的特点；如果希望派生类能够重新定义基类的方法，则在基类中将该方法定义为虚方法，这样可以启用动态联编。
内联函数的特点；使用内联函数的目的是为了提高函数的运行效率。内联函数体的代码不能过长，因为内联函数省去调用函数
的时间是以代码膨胀为代价的。内联函数不能包含循环语句，因为执行循环语句要比调用函数的开销大。
一个函数能否即是虚函数又是内联函数？
8．以下关键字的含义与用法：
extern，extern “C”，static，explicit，register，#undef，#ifndef
9．什么是函数重载与覆盖？
为什么C不支持函数重载？
为什么C++能支持函数重载？
10．VC中，编译工具条内的Debug与Release选项是什么含义？
11．编写my_memcpy函数，实现与库函数memcpy类似的功能，不能使用任何库函数；
   void* mymemcpy(void* pvTo, const char* pvFrom, size_t size)
   {
      assert((dest != NULL) && (src != NULL));
      byte* psTo = (byte*)pvTo;
      byte* psFrom = (byte*)pvFrom;
      while (size-- > 0)
      {
         *psTo++ = *psFrom++;
      }
      return pvTo;
   }
12．编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数；
   答：char* my_strcpy(char* strdest, const char* strsrc)
          {
              assert(strdest != NULL) && (strsrc != NULL))
              char* address = strdest;
              while((*strdest++ = *strsrc++) != NULL)
               return address;
           }
             
13．编写gbk_strlen函数，计算含有汉字的字符串的长度，汉字作为一个字符处理；
已知：汉字编码为双字节，其中首字节<0，尾字节在0~63以外；（如果一个字节是-128~127）
14．函数assert的用法?
答：断言assert是仅在debug版本起作用的宏，用于检查“不应该“发生的情况。程序员可以把assert看成一个
在任何系统状态下都可以安全使用的无害测试手段。
15．为什么在头文件的最前面都会看到这样的代码：
#ifndef _STDIO_H_
#define _STDIO_H_
16．为什么数组名作为参数，会改变数组的内容，而其它类型如int却不会改变变量的值？
答：当数组名作为参数时，传递的实际上是地址。而其他类型如int作为参数时，由于函数参数值实质上是实参的一份拷贝，被调
函数内部对形参的改变并不影响实参的值。
1．实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。
　　2．写一个函数，将其中的\t都转换成4个空格。
　　3．Windows程序的入口是哪里？写出Windows消息机制的流程。
　　4．如何定义和实现一个类的成员函数为回调函数？
　　5．C++里面是不是所有的动作都是main()引起的？如果不是，请举例。
　　6．C++里面如何声明const void f(void)函数为C程序中的库函数？
　　7．下列哪两个是等同的
　　int b;
　　A const int* a = &b;
　　B const* int a = &b;
　　C const int* const a = &b;
　　D int const* const a = &b;
　　8．内联函数在编译时是否做参数类型检查？
　　void g(base & b){
　　 b.play;
　　}
　　void main(){
　　 son s;
　　 g(s);
　　 return;
　　}
3、WinMain
     while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0)
    {
        if (bRet == -1)
        {
            // handle the error and possibly exit
        }
        else
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

MSRA Interview Written Exam（December 2003，Time：2.5 Hours）

1写出下列算法的时间复杂度。
(1)冒泡排序；
(2)选择排序；
(3)插入排序；
(4)快速排序；
(5)堆排序；
(6)归并排序；

2写出下列程序在X86上的运行结果。

struct mybitfields
{
unsigned short a : 4;
unsigned short b : 5;
unsigned short c : 7;
}test

void main(void) 
{
int i;
test.a=2;
test.b=3;
test.c=0;

i=*((short *)&test);
printf("%d\n",i);
}

3写出下列程序的运行结果。

unsigned int i=3;
cout<

4写出下列程序所有可能的运行结果。

int a;
int b;
int c;

void F1()
{
b=a*2;
a=b;
}

void F2()
{
c=a+1;
a=c;
}

main()
{
a=5;
//Start F1,F2 in parallel
F1(); F2();
printf("a=%d\n",a);
}

5考察了一个CharPrev()函数的作用。

6对 16 Bits colors的处理，要求：
（1）Byte转换为RGB时，保留高5、6bits；
（2）RGB转换为Byte时，第2、3位置零。

7一个链表的操作，注意代码的健壮和安全性。要求：
（1）增加一个元素；
（2）获得头元素；
（3）弹出头元素（获得值并删除）。

8一个给定的数值由左边开始升位到右边第N位，如
0010<<1 == 0100
或者
0001 0011<<4 == 0011 0000
请用C或者C++或者其他X86上能运行的程序实现。

附加题（只有在完成以上题目后，才获准回答）
In C++, what does "explicit" mean? what does "protected" mean?