面试题(C++09:Autodesk)

网上收集的Autodesk面试题：
1. 在类的普通成员函数中调用虚函数，情况是怎么样的？     
  具体来说，问题如下：       
  在类的普通成员函数fun1中调用了本类中的虚函数vfun2。     如果在外部有该类的对象指针pobj，或者对象obj，或者应用robj；     
  a.     那么pobj-〉fun1（）；调用的是vfun2的虚函数（可能是派生类中的vfun2），还是说调用的是vfun2在本类中的定义？   
  b.     那么obj.fun1（）；调用的是vfun2的虚函数（可能是派生类中的vfun2），还是说调用的是vfun2在本类中的定义？    
  c.      那么robj.fun1（）；调用的是vfun2的虚函数（可能是派生类中的vfun2），还是说调用的是vfun2在本类中的定义？  
答：
如果调用虚函数的实体是这个类的， 那么应该调用本类中的定义。
对于虚函数来说，是根据所调用 的实体来动态确定所调用的函数定义的。
对于非虚函数来说，用指针调用时， 是根据指针类型确定调用函数的。
Test Example :

#include <iostream>
using namespace std;

class Base
{
      public:
             Base() { cout << "Base" << endl; }
             ~Base() { cout << "~Base" << endl; }
            
             virtual void func1() { cout << "func1 in Base" << endl; }
             void func3() {cout << "func3 in Base" << endl;}
};

class Derived : public Base
{
      public:
             Derived() : Base() {cout << "Derived" << endl;}
             ~Derived() { cout << "~Derived" << endl; }
            
             virtual void func1() { cout << "fun1 in Derived" << endl; }
            
             void func2() { func1(); }
            
             void func3() {cout << "func3 in Derived" << endl;}
};

class Derived2 : public Derived
{
public:
             Derived2() : Derived() {cout << "Derived2" << endl;}
             ~Derived2() { cout << "~Derived2" << endl; }
            
             virtual void func1() { cout << "fun1 in Derived2" << endl; }
            
             void func3() {cout << "func3 in Derived2" << endl;}     
};

int main()
{
//    Derived *pobj = new Derived(); // 1 step
    Derived *pobj = new Derived2(); // 2 step
    cout << "Pointer output" << endl;
    pobj->func2();
   
    Derived obj;
    cout << "Object output" << endl;
    obj.func2();
   
    Derived2 obj2;
//    Derived &robj = obj; // 1 step
    Derived &robj = obj2; // 2 step
    cout << "Reference ouput" << endl;
    robj.func2();
   
    cout << "test non-virutal function" << endl;
    Base *pBase = NULL;
    pBase = new Derived();
    pBase->func3(); // Output :func3 in Base
   
    pBase = new Derived2();
    pBase->func3(); // Output :func3 in Base
   
    getchar();
}

//

2. 成员变量初始化顺序，几个有依赖关系的成员变量要初始化
答：
a. 成员变量的初始化顺序只与变量在类中的声明顺序有关，与在构造函数中的初始化列表的顺序无关。
class Test
{
private :
int n1;
int n2;
public:
Test();
};
Test::Test() : n2(2), n1(1)
{};
当查看相关汇编代码时，就能看到正确的初始化顺序了。
因为成员变量的初始化次序是根据变量在内存中次序有关，而内存中的排列顺序早在编译期就根据变量的定义次序决定了.

从全局看，变量的初始化顺序就应该是：
a,基类的静态变量或全局变量
b,派生类的静态变量或全局变量
c,基类的成员变量
d,派生类的成员变量

3， 写一个双链表, 及常用操作(添加/删除）
转自了以下资源： http://hi.baidu.com/caijiamx/blog/item/4110288b46d317dbfc1f10a5.html
http://hi.baidu.com/chen3900/blog/item/8466e45d1060cb44fbf2c0c9.html
双向链表（Double Linked List）
    　双（向）链表中有两条方向不同的链，即每个结点中除next域存放后继结点地址外，还增加一个指向其直接前趋的指针域prior。

注意：
    　①双链表由头指针head惟一确定的。
    　②带头结点的双链表的某些运算变得方便。
    　③将头结点和尾结点链接起来，为双（向）循环链表。

b、双向链表的结点结构和形式描述
①结点结构(见上图a)
     
②形式描述
    typedef struct dlistnode{
         DataType data;
         struct dlistnode *prior,*next;
      }DListNode;
    typedef DListNode *DLinkList;
    DLinkList head;

c、双向链表的前插和删除本结点操作
    　由于双链表的对称性，在双链表能能方便地完成各种插入、删除操作。
①双链表的前插操作
    
    void DInsertBefore(DListNode *p,DataType x)
      {//在带头结点的双链表中，将值为x的新结点插入*p之前，设p≠NULL
        DListNode *s=malloc(sizeof(DListNode));//①
        s->data=x;//②
        s->prior=p->prior;//③
        s->next=p;//④
        p->prior->next=s;//⑤
        p->prior=s;//⑥
       }
②双链表上删除结点*p自身的操作
    
    void DDeleteNode(DListNode *p)
      {//在带头结点的双链表中，删除结点*p，设*p为非终端结点
          p->prior->next=p->next;//①
          p->next->prior=p->prior;//②
          free(p);//③
      }
注意：
    　与单链表上的插入和删除操作不同的是，在双链表中插入和删除必须同时修改两个方向上的指针。
    　上述两个算法的时间复杂度均为O(1)。

4. 写个is-a和has-a
class Car
{
};
class BMW : public Car
{
};
class Person
{
Car *oneCar;
};

5. struct vs. class区别:
a, 成员的默认访问属性: struct 是 public; class 是private;
b, 类的默认继承属性：struct 是 public; class 是 private;
c, class 可以作为泛型的类型的声明的关键字。struct 不能；