C++笔试题

来源：互联网发布：品牌艺术人物网络榜编辑：程序博客网时间：2024/05/11 04:44

C++笔试题

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

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

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

ptr->next=ptr->next->next;
length--;
delete t;
}

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

int k=1;
while(ptr!=NULL&&k<p)
{
  ptr=ptr->next;
  k++;
}
if(ptr==NULL&&k!=p)
  return false;
else
{
   listnode<type> *tp;
   tp=new listnode<type>;
   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关键字。

<<Sony笔试题>>
25．完成下列程序

*.*.

*..*..*..

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

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

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

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

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

＃i nclude<iostream>
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<<endl;
   }
   system("pause");
}

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

＃i nclude <iostream>
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<<array[i]<<" ";
   cout<<endl;
   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 <iostream>
using namespace std;

int Pheponatch(int n);

main()
{
   int Ph = Pheponatch(10);
   cout<<Ph<<endl;
   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 <iostream>
using namespace std;

int Pheponatch(int n);

main()
{
   int n;
   cin>>n;
   int ph = Pheponatch(n);
   cout<<ph<<endl;
   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 <stdio.h>

＃i nclude <malloc.h>

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<temp. value && temp. right!=NULL

))

{

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

temp=temp.left;

while(N<temp.value && temp.right!=NULL)

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<sizeof(str)/sizeof(str[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<strlen(str); ++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<char*>( dest );
    const char* psrc = static_cast<const char*>( src );
    if( pdest>psrc && pdest<psrc+cout ) 能考虑到这种情况就行了
    {
        for( size_t i=count-1; i!=-1; --i )
                pdest[i] = psrc[i];
    }
    else
    {
        for( size_t i=0; i<count; ++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是多少位的系统？在数据总线上是怎么实现的？

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

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

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

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

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

ptr->next=ptr->next->next;
length--;
delete t;
}

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

//上海贝尔的面试题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  <filename.h>   和  ＃i nclude  “filename.h” 有什么区别？
3、const 有什么用途？（请至少说明两种）
4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”声明？
5、请简述以下两个for循环的优缺点
// 第一个
for (i=0; i<N; i++)
{
if (condition)
    DoSomething();
else
    DoOtherthing();
}// 第二个
if (condition)
{
for (i=0; i<N; i++)
    DoSomething();
}
else
{
    for (i=0; i<N; 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<n;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  <filename.h>   和  ＃i nclude  “filename.h” 有什么区别？（5分）
答：对于＃i nclude  <filename.h> ，编译器从标准库路径开始搜索 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<N; i++)
{
if (condition)
    DoSomething();
else
    DoOtherthing();
}if (condition)
{
for (i=0; i<N; i++)
    DoSomething();
}
else
{
    for (i=0; i<N; 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 <stdio.h>
＃i nclude <cstdlib>

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 <stdio.h>

#define N 8

int main()

{

int i;

int j;

int k;

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

| |

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

return 0;

}

＃i nclude <stdio.h>
＃i nclude <iostream.h>

#define N 8

int 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<<"\n";
   }

return 0;
}

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

＃i nclude <stdio.h>

＃i nclude <malloc.h>

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) || (N<temp->value && temp->right!=NULL))

{

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

temp=temp->left;

while(N<temp->value && 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<enter>
-456<enter>
…
如果只允许便历文件一次呢？
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<<i * -1;

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上能运行的程序实现。

华为C/C++笔试题

(附答案)

1.写出判断ABCD四个表达式的是否正确, 若正确, 写出经过表达式中 a的值(3分)
int a = 4;
(A)a += (a++); (B) a += (++a) ;(C) (a++) += a;(D) (++a) += (a++);
a = ?
答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a;
改后答案依次为9,10,10,11

2.某32位系统下, C++程序，请计算sizeof 的值(5分).
char str[] = “http://www.ibegroup.com/”
char *p = str ;
int n = 10;
请计算
sizeof (str ) = ？（1）
sizeof ( p ) = ？（2）
sizeof ( n ) = ？（3）
void Foo ( char str[100]){
请计算
sizeof( str ) = ？（4）
}
void *p = malloc( 100 );
请计算
sizeof ( p ) = ？（5）
答：（1）17 （2）4 （3） 4 （4）4 （5）4

3. 回答下面的问题. (4分)
(1).头文件中的 ifndef/define/endif 干什么用？预处理
答：防止头文件被重复引用
(2). ＃i nclude 和＃i nclude “filename.h” 有什么区别？
答：前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。
(3).在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？
答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern "C"修饰的变
量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调
用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。
(4). switch()中不允许的数据类型是?
答：实型

4. 回答下面的问题(6分)
(1).Void GetMemory(char **p, int num){
*p = (char *)malloc(num);
}
void Test(void){
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
请问运行Test 函数会有什么样的结果？
答：输出“hello”
(2). void Test(void){
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL){
strcpy(str, “world”);
printf(str);
}
}
请问运行Test 函数会有什么样的结果？
答：输出“world”
(3). char *GetMemory(void){
char p[] = "hello world";
return p;
}
void Test(void){
char *str = NULL;
str = GetMemory();
printf(str);
}
请问运行Test 函数会有什么样的结果？
答：无效的指针，输出不确定

5. 编写strcat函数(6分)
已知strcat函数的原型是char *strcat (char *strDest, const char *strSrc);
其中strDest 是目的字符串，strSrc 是源字符串。
（1）不调用C++/C 的字符串库函数，请编写函数 strcat
答：
VC源码：
char * __cdecl strcat (char * dst, const char * src)
{
char * cp = dst;
while( *cp )
cp++; /* find end of dst */
while( *cp++ = *src++ ) ; /* Copy src to end of dst */
return( dst ); /* return dst */
}
（2）strcat能把strSrc 的内容连接到strDest，为什么还要char * 类型的返回值？
答：方便赋值给其他变量

6.MFC中CString是类型安全类么？
答：不是，其它数据类型转换到CString可以使用CString的成员函数Format来转换

7.C++中为什么用模板类。
答：(1)可用来创建动态增长和减小的数据结构
（2）它是类型无关的，因此具有很高的可复用性。
（3）它在编译时而不是运行时检查数据类型，保证了类型安全
（4）它是平台无关的，可移植性
（5）可用于基本数据类型

8.CSingleLock是干什么的。
答：同步多个线程对一个数据类的同时访问

9.NEWTEXTMETRIC 是什么。
答：物理字体结构，用来设置字体的高宽大小

10.程序什么时候应该使用线程，什么时候单线程效率高。
答：1．耗时的操作使用线程，提高应用程序响应
2．并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。
3．多CPU系统中，使用线程提高CPU利用率
4．改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独
立的运行部分，这样的程序会利于理解和修改。
其他情况都使用单线程。

11.Windows是内核级线程么。
答：见下一题

12.Linux有内核级线程么。
答：线程通常被定义为一个进程中代码的不同执行路线。从实现方式上划分，线程有两
种类型：“用户级线程”和“内核级线程”。用户线程指不需要内核支持而在用户程序
中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度
和管理线程的函数来控制用户线程。这种线程甚至在象 DOS 这样的操作系统中也可实现
，但线程的调度需要用户程序完成，这有些类似 Windows 3.x 的协作式多任务。另外一
种则需要内核的参与，由内核完成线程的调度。其依赖于操作系统核心，由内核的内部
需求进行创建和撤销，这两种模型各有其好处和缺点。用户线程不需要额外的内核开支
，并且用户态线程的实现方式可以被定制或修改以适应特殊应用的要求，但是当一个线
程因 I/O 而处于等待状态时，整个进程就会被调度程序切换为等待状态，其他线程得不
到运行的机会；而内核线程则没有各个限制，有利于发挥多处理器的并发优势，但却占
用了更多的系统开支。
Windows NT和OS/2支持内核线程。Linux 支持内核级的多线程

13.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？
答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理
堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上

14.使用线程是如何防止出现大的波峰。
答：意思是如何防止同时产生大量的线程，方法是使用线程池，线程池具有可以同时提
高调度效率和限制资源使用的好处，线程池中的线程达到最大数时，其他线程就会排队
等候。

15函数模板与类模板有什么区别？
答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化
必须由程序员在程序中显式地指定。

16一般数据库若出现日志满了，会出现什么情况，是否还能使用？
答：只能执行查询等读操作，不能执行更改，备份等写操作，原因是任何写操作都要记
录日志。也就是说基本上处于不能使用的状态。

17 SQL Server是否支持行级锁，有什么好处？
答：支持，设立封锁机制主要是为了对并发操作进行控制，对干扰进行封锁，保证数据
的一致性和准确性，行级封锁确保在用户取得被更新的行到该行进行更新这段时间内不
被其它用户所修改。因而行级锁即可保证数据的一致性又能提高数据操作的迸发性。

18如果数据库满了会出现什么情况，是否还能使用？
答：见16

19 关于内存对齐的问题以及sizof()的输出
答：编译器自动对齐的原因：为了提高程序的性能，数据结构（尤其是栈）应该尽可能
地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问
；然而，对齐的内存访问仅需要一次访问。

20 int i=10, j=10, k=3; k*=i+j; k最后的值是？
答：60，此题考察优先级，实际写成： k*=(i+j);，赋值运算符优先级最低

21.对数据库的一张表进行操作,同时要对另一张表进行操作,如何实现?
答：将操作多个表的操作放入到事务中进行处理

22.TCP/IP 建立连接的过程?(3-way shake)
答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。
　　第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状
态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个
SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
　　第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)
，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

23.ICMP是什么协议,处于哪一层?
答：Internet控制报文协议，处于网络层（IP层）

24.触发器怎么工作的?
答：触发器主要是通过事件进行触发而被执行的，当对某一表进行诸如UPDATE、 INSERT
、 DELETE 这些操作时，数据库就会自动执行触发器所定义的SQL 语句，从而确保对数
据的处理必须符合由这些SQL 语句所定义的规则。

25.winsock建立连接的主要实现步骤?
答：服务器端：socker()建立套接字，绑定（bind）并监听（listen），用accept（）
等待客户端连接。
客户端：socker()建立套接字，连接（connect）服务器，连接上后使用send()和recv（
），在套接字上写读数据，直至数据交换完毕，closesocket()关闭套接字。
服务器端：accept（）发现有客户端连接，建立一个新的套接字，自身重新开始等待连
接。该新产生的套接字使用send()和recv（）写读数据，直至数据交换完毕，closesock
et()关闭套接字。

26.动态连接库的两种方式?
答：调用一个DLL中的函数有两种方法：
1．载入时动态链接（load-time dynamic linking），模块非常明确调用某个导出函数
，使得他们就像本地函数一样。这需要链接时链接那些函数所在DLL的导入库，导入库向
系统提供了载入DLL时所需的信息及DLL函数定位。
2．运行时动态链接（run-time dynamic linking），运行时可以通过LoadLibrary或Loa
dLibraryEx函数载入DLL。DLL载入后，模块可以通过调用GetProcAddress获取DLL函数的
出口地址，然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了
。

27.IP组播有那些好处?
答：Internet上产生的许多新的应用，特别是高带宽的多媒体应用，带来了带宽的急剧
消耗和网络拥挤问题。组播是一种允许一个或多个发送者（组播源）发送单一的数据包
到多个接收者（一次的，同时的）的网络技术。组播可以大大的节省网络带宽，因为无
论有多少个目标地址，在整个网络的任何一条链路上只传送单一的数据包。所以说组播
技术的核心就是针对如何节约网络资源的前提下保证服务质量。

1.static有什么用途？（请至少说明两种）
    1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
    2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
    3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用

2.引用与指针有什么区别？
    1) 引用必须被初始化，指针不必。
    2) 引用初始化以后不能被改变，指针可以改变所指的对象。
    3) 不存在指向空值的引用，但是存在指向空值的指针。

3.描述实时系统的基本特性
在特定时间内完成特定的任务，实时性与可靠性。

4.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
全局变量储存在静态数据库，局部变量在堆栈。

5.什么是平衡二叉树？
左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1。

6.堆栈溢出一般是由什么原因导致的？
没有回收垃圾资源。

7.什么函数不能声明为虚函数？
constructor函数不能声明为虚函数。

8.冒泡排序算法的时间复杂度是什么？
时间复杂度是O(n^2)。

9.写出float x 与“零值”比较的if语句。
if(x>0.000001&&x<-0.000001)

10.Internet采用哪种网络协议？该协议的主要层次结构？
Tcp/Ip协议
主要层次结构为：应用层/传输层/网络层/数据链路层/物理层。

11.Internet物理地址和IP地址转换采用什么协议？
ARP (Address Resolution Protocol)（地址解析協議）

12.IP地址的编码分为哪俩部分？
IP地址由两部分组成，网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。

13.用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。
循环链表，用取余操作做

14.不能做switch()的参数类型是：
switch的参数不能为实型。?是实型吗？Java笔试题查查。