（记录）笔试题之语言和程序设计

一 C/C++

（1）构造函数可以是内联函数。

一般情况下，构造函数比较小的情况下，不管你是否指定其为内联函数，C++编译器会自动将其置为内联，如果函数太大，你即使将其指定为内联函数系统也会不理的。因为这会使程序过大。

（2）函数重载：

两个或两个以上的函数，具有相同的函数名，但是形参的个数或者类型不同，编译器根据实参和形参的类型及个数进行最佳匹配，自动确定调用哪个函数，这就是函数的重载。

（3）new和delete不一定要成对出现。

非内置类型一般带有析构函数，会自动释放

如果有下列结构

class T {

T(...);

~T();

};

func()

{

T *test = new T(...)

....

} // 在这里不用手工delete,系统会在{...} 结构末尾施放new

（4）i++，++i

int i = 5;

int j = (i++)+(i++)+(i++);

i = 5;

int k = (++i)+(++i)+(++i);

printf( "j: %d, k:%d\r\n", j,k );

不同的编译器答案有三种：21，22,24.原因在：http://topic.csdn.net/u/20100914/20/76e83d32-6c97-4e13-b997-a1d7229b22da.html

这个跟不同的系统不同的编译器有关系

也就是说跟你的程序的运行环境有关系..

(i++)+(i++)+(i++);拿这个表达式来说。假定i=5

可能有的人（环境）理解为我要先将三个i++弄完，然后再将三个数相加

这样就是8+8+8..（这样还是有依据的括号的优先级是最高的）

可是有的他就不着么算了，他是5+6+7。

后者是未定义行为，因为表达式括号并不是序列点。标准规定i++的后增副作用应该在序列点之前完成，而这里的序列点是整个表达式完成并返回结果。而在这之前2次以上读取变量并同时修改变量的内容的话，其行为就是未定义的了。(i++)+(i++)这个到底是什么效果需要由编译器自己决定，它只要符合规定，怎么计算顺序都是对的。

（5）变量的默认初始化

指导原则：指针尽量初始化为null；局部变量都初始化。

如果是全局变量，所有的全局变量都赋零，字符变量都赋NULL即0.指针变量也是NULL。即全部变量都自动初始化了。

如果是局部变量，所有的变量都不初始化，因此为随机数。如果不赋值就使用，很危险。需要先初始化再使用。

char *str; // 指针str 的指向不为NULL ，而是不确定的空间，很危险。

(6）类中的const

就是说这个类是错误的

class Stock

{

const int size = 30;

}

只有定义，并没有实例化它，也就没有空间给它

如果你在它里面赋值了一个值给它的成员

那么就需要分配空间

显然，这两者是矛盾的

因此，不允许在类里面定义常量

解决：

1 class A{static const intsize=9}；

2class A{ A() {const intsize=9};}

注意：非const的static只能在外部定义。

（7）C++函数中那些不可以被声明为虚函数

常见的不不能声明为虚函数的有：普通函数（非成员函数）；静态成员函数；内联成员函数；构造函数；友元函数。

inline是编译时展开，必须有实体；

static属于class自己的，也必须有实体；

virtual函数基于vtable（内存空间），constructor函数如果是virtual的，调用时也需要根据vtable寻找，但是constructor是virtual的情况下是找不到的，因为constructor自己本身都不存在了，创建不到class的实例，没有实例，class的成员（除了public static/protectedstaticfor friend class/functions，其余无论是否virtual）都不能被访问了。

友元函数不能被继承。

(8)一个可用的类一般应该包括一般构造函数，拷贝构造函数，赋值函数，析构函数

当需要深拷贝时，则需要拷贝构造函数和赋值函数。

拷贝构造函数，赋值构造函数的区别在于：复制构造函数是去完成对未初始化的存储区的初始化，而赋值操作符则是处理一个已经存在的对象。对一个对象赋值，当它一次出现时，它将调用复制构造函数，以后每次出现，都调用赋值操作符。

例如，

定义对象a，并用另一个对象b对a进行初始化时，

若没有复制构造函数时，那么编译器会自动生成一个

T b(1);//假设对象b已经初始化

T a(b);//初试化阶段，调用复制构造函数

T c = b;//虽然使用了“=”，但是初试化阶段，仍调用复制构造函数

T d；

d = a; //因为对象c已经定义，所以此处调用赋值操作符重载函数。如果没有编译器会自动生成一个

（9）malloc和new的区别

1,malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

2,对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

new可以认为是malloc加构造函数的执行。new出来的指针是直接带类型信息的。而malloc返回的都是void指针。

（10）RTTI(运行时类型信息)机制--RuntimeType Information”

运行时类型信息(RTTI)是一种机制，它允许在程序运行时确定一个对象的类型。

出于对清晰度透明性的考虑，关于RTTI的讨论几乎全部限于指针。然而，所进行的讨论也应用于引用。 RTTI中包含三种主要的C++语言的元素：

1.dynamic_cast：用于多态类型之间转换的操作符

2.typeid：用于表示一个对象的确切类型的操作符

3.type_info：用于保存typeid操作符返回的关于类型信息的类。

1 base *pg=new base;

derived * pm=dynameic_cast<derived*>(pg);

这提出了这样的问题:指针pg的类型是否可被安全地转换为Superb *? 如果可以，操作符将返回对象的地址，否则返回一个空指针。

2. typeid 操作符和type_info 类

typeid操作符使得能够确定两个对象是否为同种类型。它与sizeof有些相像，可以接受两种参数:

(1) 类名。

(2) 结果为对象的表达式。

ypeid操作符返回一个对type_info对象的引用，

例如，如果pg指向的是一个Magnificent对象，则表达式:

typeid(Magnificent) ==typeid(*pg)

结果将为bool值true，否则为false。

（11）原子操作有哪些？

是的：立即数赋值m=5;m=5+6;

不是的：m=m+5,m++

（12）纯虚函数

不同于虚函数，后面必须添加“=0”：virtual void lock(void)=0;

除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。

（13）异常

throw ,try catch,finally。

finally在程序结束前一定会执行，除了使用system(exit 0)

（14）宏和内联函数

1 宏替换发生在预处理阶段，内联函数在编译阶段展开。

2宏参数替换不做类型检查，容易产生二义性或者错误；函数的参数则会先求值。

3 宏不能访问对象的私有成员，而函数更加强大，实现的功能更多。

（15）sizeof（string） 

 是32.string是一个类。不同的库实现不同。现在一般是32.

（16）hash碰撞的处理方法

       1．close hashing-- 开放寻址法；Hi=(H(key) + di) MOD m,i=1,2,…，k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法：

　　1)． di=1,2,3,…，m-1，称线性探测再散列；

　　2)． di=1^2,(-1)^2,2^2,(-2)^2,(3)^2,…，±(k)^2,(k<=m/2)称二次探测再散列；

　　3)． di= 伪随机数 序列，称伪随机探测再散列。

　　 2． open hashing- 链地址法(拉链法)

       3． 再散列法：Hi=RHi(key),i=1,2,…，k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。

　　4． 建立一个公共溢出区

（17）错误和异常的区别

  Exeception是一种设计和实现问题，也就是说，如果程序运行正常，它是从来都不会发生的。

error是表示恢复不是不可能的，但是很困难下的一种严重问题，比如内存的溢出，不可能指望程序能处理这样的问题。

它们所具有的特点如下：

Exception:

1.可以是被控制或者是不被控制的。

2.经常用来表示程序员导致的错误。

3.应该在应用程序进行处理。

error：

1.总是不可以被控制的。

2.经常用来表示系统错误或底层资源的错误。

3.如果可能的话应该在系统级被捕捉。

很一般的来讲，错误在编译的时候就可以发现，我们还可以用assert来检测。
异常是在执行过程中发生的意外，由潜在的错误机率导致（错误是由100%的错误机率导致。）如果我们能够很好的使用throw,catch，许多风险是能够避免的。

异常有时并不是由于你的程序的问题引起的，如用new 申请一个内存块失败时，数据库操作失败时，就会产生一个异常，异常往往是程序的执行过程中不可预料的。如果不对产生的异常进行处理，程序往往崩溃，会使软件显得很脆弱。

错误而言，不管是语法错误，逻辑错误都是可以通过检查发现的。

二 数据库

1 范式

大部分数据库从业人员都知道关系数据库有三个基本的范式，即：第一范式，第二范式，第三范式。当然也有牛人知道BC范式，第四范式，第五范式，第六范式，甚至还有个DK范式。本人对数据库的范式概念也是一知半解的，想想有些可笑，搞数据库的竟然不了解关系数据库的基础——范式。这不最近查阅了不少资料，今天把这些东东总结一下。

 

范式：英文名称是Normal Form，它是英国人E.F.Codd（关系数据库的老祖宗）在上个世纪70年代提出关系数据库模型后总结出来的，范式是关系数据库理论的基础，也是我们在设计数据库结构过程中所要遵循的规则和指导方法。目前有迹可寻的共有8种范式，依次是：1NF，2NF，3NF，BCNF，4NF，5NF，DKNF，6NF。通常所用到的只是前三个范式，即：第一范式（1NF），第二范式（2NF），第三范式（3NF）。

 

下面就简单介绍下这三个范式。

 

◆ 第一范式（1NF）：

强调的是列的原子性，即列不能够再分成其他几列。

 

考虑这样一个表：【联系人】（姓名，性别，电话）

 

如果在实际场景中，一个联系人有家庭电话和公司电话，那么这种表结构设计就没有达到 1NF。要符合 1NF 我们只需把列（电话）拆分，

即：【联系人】（姓名，性别，家庭电话，公司电话）。1NF 很好辨别，但是 2NF 和 3NF 就容易搞混淆。

 

◆ 第二范式（2NF）：

首先是 1NF，另外包含两部分内容，一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖于主键的一部分。

考虑一个订单明细表：

【OrderDetail】（OrderID，ProductID，UnitPrice，Discount，Quantity，ProductName）。

 因为我们知道在一个订单中可以订购多种产品，所以单单一个 OrderID 是不足以成为主键的，主键应该是（OrderID，ProductID）。

显而易见 Discount（折扣），Quantity（数量）完全依赖（取决）于主键（OderID，ProductID），而 UnitPrice，ProductName 只依赖于 ProductID。所以 OrderDetail 表不符合 2NF。不符合 2NF 的设计容易产生冗余数据。

 

可以把【OrderDetail】表拆分为【OrderDetail】（OrderID，ProductID，Discount，Quantity）和【Product】（ProductID，UnitPrice，ProductName）来消除原订单表中UnitPrice，ProductName多次重复的情况。

 

◆ 第三范式（3NF）：首先是 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。

考虑一个订单表【Order】（OrderID，OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity）主键是（OrderID）。

 

其中 OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity 等非主键列都完全依赖于主键（OrderID），所以符合 2NF。不过问题是 CustomerName，CustomerAddr，CustomerCity 直接依赖的是 CustomerID（非主键列），而不是直接依赖于主键，它是通过传递才依赖于主键，所以不符合3NF。

 

通过拆分【Order】为【Order】（OrderID，OrderDate，CustomerID）和【Customer】（CustomerID，CustomerName，CustomerAddr，CustomerCity）从而达到 3NF。

第二范式（2NF）和第三范式（3NF）的概念很容易混淆，区分它们的关键点在于，2NF：非主键列是否完全依赖于主键，还是依赖于主键的一部分；3NF：非主键列是直接依赖于主键，还是直接依赖于非主键列。

三  其它

（1）UML类图

属性和操作之前可附加一个可见性修饰符。加号（+）表示具有公共可见性。减号（-）表示私有可见性。#号表示受保护的可见性。省略这些修饰符表示具有package（包）级别的可见性。如果属性或操作具有下划线，表明它是静态的。

类图中斜线表示纯虚函数和抽象类。

类名BankAccount和withdrawal操作使用斜体。这表示，BankAccount 类是一个抽象类，而withdrawal方法是抽象的操作。换句话说，BankAccount 类使用withdrawal规定抽象操作，并且CheckingAccount 和 SavingsAccount 两个子类都分别地执行它们各自版本的操作。

（2）big endian 和 little endian

大尾端使我们理解的正常顺序，小尾端相反。包括字节序和比特序。

一字节序

power pc采用bigendian,x86采用little endian

比如数字0x12345678在两种不同字节序CPU中的存储顺序如下所示：

Big Endian

低地址高地址

----------------------------------------->

| 12 | 34 | 56 | 78 |

Little Endian

低地址高地址

| 78 | 56 | 34 | 12 |

C/C++语言编写的程序里数据存储顺序是跟编译平台所在的CPU相关的，而JAVA编写的程序则唯一采用big endian方式来存储数据。

2 比特序

CPU存储一个字节的数据时其字节内的8个比特之间的顺序是否也有bigendian和little endian之分？或者说是否有比特序的不同？实际上，这个比特序是同样存在的。下面以数字0xB4（10110100）用图加以说明。

Big Endian

---------------------------------------------->

| 1 | 0 | 1 | 1 | 0 | 1 | 0 |0

Little Endian

| 0 | 0 | 1 | 0 | 1 | 1 | 0 |1 |