阅读大量网络资料总结的常用计算机公司笔试题目（1）

补码：正数的补码与原码相同；负数的补码符号位为1，其余位为该数绝对值的原码按位取反，然后整个数加1。

 

路由器的功能：网络层互联设备。很强的网络互联能力，能够互联多个异构网络；很强的路由选择；分组过滤和流量管理；数据压缩、加密和容错。

 

DNS原理：DNS服务，或者叫域名服务、域名解析服务，就是提供域名与IP地址的相互转换。域名的正向解析是将主机名转换成IP地址的过程 ，域名的反向解析是将IP地址转换成主机名的过程。通常我们很少需要将IP地址转换成主机名，即反向解析。反向解析经常被一些后台程序使用，用户看不到。工作过程：设置电脑去向谁查询，除非电脑本身具有域名服务器的功能，否则它不会进行完整的域名查询，需要借助于internet上的域名服务器进行域名查询；域名的查询过程：查一个域名如zsu.edu.cn时，DNS服务器按以下步骤进行查询。电脑向设定的DNS服务器发出查询zsu.edu.cn。这台服务器先查询自己的缓存，如果存在就回答，如果不存在就向根DNS服务器提出查询zsu.edu.cn的请求。根DNS服务器回答查询到的能解释这个域名的最近DNS服务器也就是掌管.cn的服务器。你的DNS服务器会继续向这个新的DNS服务器提交zsu.edu.cn的查询。这个DNS服务器会告诉你掌管edu.cn的DNS服务器。你的DNS服务器再向这个新DNS服务器提交查询。这样一层层查下来直到查到你要的域名纪录为止。

 

递归的优缺点：优点， 结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性；缺点，运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多。

 

创建数据库：Create DATABASE dbname;删除数据库：drop database dbname;

创建新表：create table tabname(col1 type1 [notnull] [primary key],…);删除新表：drop tabletabname;

添加主键：alter table tabname add primarykey(col);删除主键：alter table tabname drop primarykey(col);

创建索引：create [unique] index idxname ontabname(col);删除索引：drop index idxname on tabname;(索引不可更改，想更改必须删除重新创建)

 

正确：输出hello

char * GetMemory(char *p,int num)

{

    p = (char*)malloc(num*sizeof(char));

    return p;

}

 

void test()

{

    char *str= NULL;

    str = GetMemory(str,100);

    strcpy(str,"hello");

    cout<<str;

    free(str);

}

 

void getmemory(char **p,int num)

{

    *p = (char*)malloc(num);

}

void test()

{

    char *str= NULL;

    getmemory(&str,100);

    strcpy(str,"hello");

    cout<<str;

}

 

正确：输出world

void getmemory(char **p,int num)

{

    *p = (char*)malloc(num);

}

void test()

{

    char *str= NULL;

    getmemory(&str,100);

    strcpy(str,"hello");

    free(str);

    if (str!= NULL)

    {

       strcpy(str,"world");

       cout<<str;

    }  

}

 

错误：无效的指针，输出不确定

char *getmemory(void)

{

    char p[]= "hello";

    return p;

}

void test(void)

{

    char *str= NULL;

    str = getmemory();

    printf(str);

}

 

不使用库函数，编写函数strcpy。

char *strcpy(char *strDest, const char *strSrc)

{

    if ( strDest== NULL || strSrc== NULL)

       return NULL ;

    if ( strDest== strSrc)

       return strDest ;

    char *tempptr= strDest ;

    while( (*strDest++= *strSrc++) != ‘\0’)

       ;

    return tempptr;

}

 

不使用库函数，编写函数strcat。

char *strcat(char *strDest, const char *strSrc)

{

    if ( strDest== NULL || strSrc== NULL)

       return NULL ;

    char *cp= strDest;

    while (*cp)

       cp++;

    while( *cp++= *strSrc++)

       ;

    return strDest;

}

 

switch(表达式)表达式是整数结果，case标号值必须是一个常量表达式。

 

自增和自减操作符：前置操作返回的是左值，后置操作返回的是右值。

 

MFC中CString不是类型安全类，因为其它数据类型转换到CString可以使用类的成员函数Format来转换。

 

C++中使用模板类的好处：可用来创建动态增长和减少的数据结构；它是类型无关的，具有很高的可复用性；它在编译时而不是运行时检查数据类型，保证了类型安全；它是平台无关的，可移植性；可用于基本数据类型。

 

用户级线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户级线程。内核级线程需要内核的参与，由内核完成线程的调度。其依赖与操作系统核心，由内核的内部需求进行创建和撤销。用户级线程不需要额外的内核开支，并且用户级线程的实现方式可以被定制或修改以适应特殊应用的要求，但是当一个线程因I/O而处于等待状态时，整个进程就会被调度程序切换为等待状态，其它线程得不到运行的机会；而内核级线程没有这个限制，有利于发挥多处理器的并发优势，但却占用了更多的系统开支。

 

堆：由malloc系列函数或new操作符分配的内存。其生命周期由free或delete决定。在没有释放之前一直存在，知道程序结束。其特点是使用灵活，空间比较大，但容易出错。

栈：保存局部变量。栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁。其特点是效率高，但空间大小有限。

静态区：保存自动全局变量和static变量（包括static全局和局部变量）。静态区的内容在整个程序的生命周期内都存在，由编译器在编译的时候分配。

 

TCP/IP协议的三次握手

答：在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状态。

 

38头牛中选出3头跑得最快的，使用一个每次只能供6头比赛的场地，要求用最快的方法。

解决方案：6次（6头牛一组）；1次（6个第一名之间）；1次（去掉后三个第一名，取这次第一名组内的前三，取这次第二名组内的前二，取这次第三名）；1次（三个+剩余的两个）

 

求下面函数的返回值（微软）

int func(x)

{

    int countx= 0;

    while(x)

    {

       countx ++;

       x = x&(x-1);

    }

    return countx;

}

假定x = 9999。 答案：

思路：将x转化为进制，看含有的的个数。

 

什么是“引用”？申明和使用“引用”要注意哪些问题？

答：引用就是某个目标变量的“别名”(alias)，对引用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

 

将“引用”作为函数参数有哪些特点？

答:（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

 

在什么时候需要使用“常引用”？　

答:如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；

例1

int a ;

const int &ra=a;

ra=1; //错误

a=1; //正确

例2

string foo( );

void bar(string & s);

那么下面的表达式将是非法的：

bar(foo( ));

bar("hello world");

原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

引用型参数应该在能被定义为const的情况下，尽量定义为const

 

“引用”与多态的关系？

答:引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。

例如

Class A; Class B : Class A{...}; B b; A& ref = b;

 

“引用”与指针的区别是什么？

答:指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数传ref和pointer的区别。

 

什么时候需要“引用”？

答:流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

 

结构与联合有和区别？

答:1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

#include <stdio.h>

union

{

    int i;

    char x[2];

}a;

void main()

{

    a.x[0]= 10;

    a.x[1]= 1;

    printf("%d",a.i);

}

答案：低位低地址，高位高地址，内存占用情况是Ox010A

 

main()

{

    union{ /*定义一个联合*/

       int i;

       struct{ /*在联合中定义一个结构*/

           char first;

           char second;

       }half;

    }number;

    number.i=0x4241; /*联合成员赋值*/

    printf("%c%c\n", number.half.first, mumber.half.second);

    number.half.first='a'; /*联合中结构成员赋值*/

    number.half.second='b';

    printf("%x\n", number.i);

    getch();

}

答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）

       6261 (number.i和number.half共用一块地址空间）

已知String类定义如下，尝试写出类的成员函数实现。

class String

{

public:

    String(const char *str = NULL); // 通用构造函数

    String(const String &another); // 拷贝构造函数

    ~ String(); // 析构函数

    String & operater =(const String &rhs);// 赋值函数

private:

    char *m_data;// 用于保存字符串

};

答：

String::String(const char *str)

{

    if ( str== NULL ) //strlen在参数为NULL时会抛异常才会有这步判断

    {

       m_data = new char[1] ;

       m_data[0] = '\0' ;

    }

    else

    {

       m_data = new char[strlen(str) +1];

       strcpy(m_data,str);

    }

}

String::String(const String &another)

{

    m_data = new char[strlen(another.m_data) + 1];

    strcpy(m_data,other.m_data);

}

String& String::operator =(const String &rhs)

{

    if ( this== &rhs)

       return *this ;

    delete []m_data;//删除原来的数据，新开一块内存

    m_data = new char[strlen(rhs.m_data) + 1];

    strcpy(m_data,rhs.m_data);

    return *this;

}

String::~String()

{

    delete []m_data;

}

 

.h头文件中的ifndef/define/endif 的作用？

答：防止该头文件被重复引用。

 

#include<file.h> 与 #include"file.h"的区别？

答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。

 

关联、聚合(Aggregation)以及组合(Composition)的区别？

答：涉及到UML中的一些概念。关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：

从实现的角度讲，聚合可以表示为:class A {...} class B { A* a; .....}

而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：

实现的形式是:class A{...} class B{ A a; ...}

 

面向对象的三个基本特征，并简单叙述之？

答：封装：将客观事物抽象成类，每个类对自身的数据和方法实行保护（私有、保护、公有）；继承：广义的继承有三种实现形式，实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式；多态：是将父对象设置成为和一个或更多的它的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

 

重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

答：从定义上来说，重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。重写：是指子类重新定义父类虚函数的方法。

从实现原理上来说，

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和functionfunc(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

 

多态的作用？

答：主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。

 

有哪几种情况只能用intializationlist 而不能用assignment?

答：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

 

C++是不是类型安全的？

答：不是。两个不同类型的指针之间可以强制转换（用reinterpret_cast)。C#是类型安全的。

 

main函数执行以前，还会执行什么代码？

答：全局对象的构造函数会在main 函数之前执行。

 

描述内存分配方式以及它们的区别?

答：1）从静态区分配：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

2）在栈上创建：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

 

当一个类A 中没有声明任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。

答：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。

 

New delete 与malloc free 的联系与区别?

答：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor。

 

分别写出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)

        

请说出const与#define 相比，有何优点？

答：1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误；2）有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

        

简述数组与指针的区别？

答：数组要么在静态区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。

(1)修改内容上的差别

char a[] = “hello”;

a[0] = ‘X’;

char *p = “world”; // 注意p 指向常量字符串

p[0] = ‘X’; // 编译器不能发现该错误，运行时错误

(2) 运算符sizeof

用运算符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 字节而不是字节

}

 

类成员函数的重载、覆盖和隐藏区别？

答：

a.成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual 关键字可有可无。

b.覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）