今天接到电话面试，被问到几个问题，汗颜之余，小结一下

1、      多态是如何实现绑定的

多态的绑定可以分为运行是多态和编译时多态

● 编译时的多态性

编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

● 运行时的多态性

运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。

编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

今天才正式弄清楚原来虚函数是可以实现运行时多态的，以前只知道虚函数可以使得基类对象的的方法调用派生类的方法。

2、      析构函数是虚函数的优点是什么

用C++开发的时候，用来做基类的类的析构函数一般都是虚函数。可是，为什么要这样做呢？下面用一个小例子来说明：

有下面的两个类：

class ClxBase

{

public:

    ClxBase() {};

    virtual ~ClxBase() {};

    virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };

};

class ClxDerived : public ClxBase

{

public:

    ClxDerived() {};

    ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };

    void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };

};

代码

ClxBase *pTest = new ClxDerived;

pTest->DoSomething();

delete pTest;

输出结果是：

Do something in class ClxDerived!

Output from the destructor of class ClxDerived!

这个很简单，非常好理解。

但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：

Do something in class ClxDerived!

也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。

所以，文章开头的那个问题的答案就是－－这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。

当然，并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数。

说实话，这个也是今天才深刻认识到的。

当然还问到很多数据结构和算法方面（空间复杂度和时间复杂度之类的东东，说真的也是基础性的）的问题，至于那些东西，自己说实话抛开没用他们已经很长时间了，真可以说忘的差不多了，考这种真的很怕，也怪平时没怎么用到。不知道大家用的多不？

好久没有正式参加过面试了，今天突然来一次觉得自己基础还是不够扎实。

C中如何调用C++函数?

前阵子被问及一个在C中如何调用C++函数的问题，当时简单回答是将函数用extern "C"声明，当被问及如何将类内成员函数声明时，一时语塞，后来网上查了下，网上有一翻译C++之父的文章可以作为解答，遂拿来Mark一下。

将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如：

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后，你可以这样使用 f()：

/* C code: */

void f(int);

void cc(int i)

{

    f(i);

   /* ... */

    }

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：

// C++ code:

class C

{

       // ...

       virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

       return p->f(i);

}

然后，你就可以这样调用 C::f()：

/* C code: */

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

       double d = call_C_f(p,i);

       /* ... */

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f()：

/* C code: */

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

       f_i(i);

       f_d(d);

       /* ... */

}

注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。

 该翻译的文档Bjarne Stroustrup的原文链接地址是

http://www.research.att.com/~bs/bs_faq2.html#callCpp

本来贴出来以后受到很多C/C++朋友的关注，非常荣幸，在“梦在天涯”的提醒下，本人后来又完成了一个Demo工程，发现和BJ说的有点出入，希望有高手指点，Demo工程下载链接如下：http://www.cppblog.com/Files/franksunny/cCallCppDemo.rar

//根据结果也就是说，无符号符号数据是可以存储在有符号型变量内存中的,
//而且有例子在内存块长度一样时，不用强转，直接赋给无符号变量时也可行
//上述事实可以解释为内存块不变，采用不同的解码方式解出不同的数据
//但是读出来的时候要注意，如果有符号转无符号一定要强转
//之所以上例unsigned int输出-1，我并不是很清楚

Code

由switch选择结构理解局部变量

函数体内部自定义变量，称为局部变量，存储于栈（stack）中，由编译器自动分配和释放，局部变量的生存期（或者说作用域）是当前函数内部，使用时必须初始化，否则其值将不定。以前对局部变量的定义也就是这么多，而且也就那么在用。近期碰到如下一个问题：

void func( void )

{

   int x = 2;

   switch ( x )

   {

         int m =0;       //initialization skipped by case0,case1,case2,default

   case 0 :

         int i = 0;        //initialization skipped by case1,case2,default

         { int j = 1; }   // OK, initialized in enclosing block

         break;

   case 1 :

         break;

   case 2:

         break;

   default:

         int k = 1;              // OK, initialization not skipped

   }

}

遇到这个问题，网上的解答很多，很多人觉得switch内不能定义局部变量，这个明显是不对的。因为我把代码改成以下形式后就完全可以用了。

void func( void )

{

   int x = 2;

   switch ( x )

   {

         int m;

         m = 0;                   //without execute;

   case 0:

         int i;

         i = 0;

         { int j = 1; }   // OK, initialized in enclosing block

         printf("%d    %d\n", m, i);

         break;

   case 1:

         i = 1;

         printf("%d    %d\n", m, i);

         break;

   case 2:

         i = 2;

         printf("%d    %d\n", m, i);

         break;

   default:

         int k = 1;              // OK, initialization not skipped

   }

}

编译时有一个warning，即“local variable 'm' used without having been initialized”，执行结果为：-858993460       2

因此switch内不但可以定义变量，而且也不用像很多人所说的在case内遇到要用变量时一定要用{}括起来，不过严格的说不用{}扩起来的变量是是属于整个switch块结构的，为此编程一定要将新增变量作用域限定在case内就必须要用{}。

通过switch···case结构，对局部变量的声明、定义以及初始化等概念可以有一个比较清晰的认识。我的理解就是：声明语句不管是放在哪里，其编译时都是将其置顶到块的头部，如int k虽然在default中，但是这个变量的声明就在switch的{}内，其生存期与变量m等同，只是由于前面没有声明，所以default之前不能用。

昨天去网讯（杭州）笔试了，做了下笔试题，感觉题目都不难，但是自己做的的确不怎么样，估计是没机会去了，不过暂时还是先把几道自己还记得的题目，写出来，总结下，以做复习。

1、  要求自己实现 String 类，给出了 String 类的以下头文件类声明

class String

{

public:

       String(const char *m_char = NULL);

       String(const String & Str);

       String& operator = (const String &Str);

       ~String();

private:

       char * m_Data;

};

关于 String 类的笔试题，以前看林锐的随笔时听说他在微软面试时曾碰到那么一道题目，我自己也没有真的下笔去做过，平常都是拿来就用的，这次自己碰到，才知道会死得那么惨，反正编得不堪入目（我就不拿出来献丑了），下面是我回来后，自己重新写的答案。

String::String(const char* m_char)

{

       int m_nLength = strlen(m_char) + 1;

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, m_char, m_nLength);

}

String::String(const String &Str)

{

       int m_nLength = strlen(Str.m_Data) + 1;// 以前真的不知道，原来对象的私有变量

// 在类的实现代码中也是可以访问的

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, Str.m_Data, m_nLength);

}

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

{

       if(this == &Str)

              return *this;

       int m_nLength = strlen(Str.m_Data) + 1;

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, Str.m_Data, m_nLength);

       return *this;

}

String::~String()

{

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }

}

2、  关于内存分配

这个题目很简单，就给了一个函数，然后问函数内的局部变量存放在哪里，我也不知道为什么当时会选择 heap( 堆 ) ，下面再把几个概念罗列出来：

1.            堆区（ heap ）：由程序员申请分配和释放，属动态内存分配方式，若程序员不释放，程序结束时可能会由 OS 回收。不过这个内存分配很容易引起问题，如果申请的内存不释放就会造成内存泄漏；如果释放的不是所要释放的内存，则轻者引起程序运行结果出错，重者系统崩溃。

2.            栈区（ stack ）：编译器自动分配释放，存放函数的形参值、局部变量的值，也是属于动态内存分配方式，它由系统分配，所以执行效率也高，不过自由度小，声明时就得决定其具体大小。

3.            全局区（静态区）（ static ）：全局变量和静态变量的存储是放在一块的，而且初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放，所以也不会造成内存问题。

除了以上的变量外，还有两类存放位置，文字常量区和程序代码区，两者都是由系统分配和释放，且文字常量区和前面三区合成为程序数据区，与程序代码区相对应。

3、  关于类继承的构造和析构函数

class Base

{

public:

       Base(){cout<< "Base" <<endl;};

       ~Base(){cout<<"~Base"<<endl;};

protected:

private:

};

class First:public Base

{

public:

       First(){cout << "First" << endl;};

       ~First(){cout << "~First" <<endl;};

};

int main()

{

       Base *a = new First;

       delete a;

}

问程序的输出会是什么？

结果很简单，也就是 Base

                               First

                   ~Base

其它还有一个关于 & 的题目，把我搞的云里雾里的，还要再看些东西才知道怎么来解释。