1 ＃include “filename.h”和＃include <filename.h>的区别?
      答：对于＃i nclude <filename.h>编译器从标准库开始搜索filename.h
       对于＃i nclude “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关键字。

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 .

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

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地质但是由于现在网络设备的发展，很多设备既有交换机的功能有由路由器的功能(交换试路由器)使得两者界限越来越模糊。

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

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

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

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

3、IP协议是网络层的协议，它实现了Internet中自动路由的功能，即寻径的功能，TCP协议是一个传输性的协议它向下屏蔽了IP协议不可靠传输的特性，向上提供一个可靠的点到点的传输，UDP提供的是一种无连接的服务,主要考虑到很多应用不需要可靠的连接，但需要快速的传输

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。要求有简单界面即可，支持多人聊天。

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

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

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

发表于 @ 2007年09月18日　22:32:00 | 评论( loading... ) | 编辑| 举报| 收藏