C/C++经典面试题总结摘选 C/C++程序员面试宝典（二）

 
==============================================================================
1.new 、 delete 、 malloc 、 free 关系

delete 会调用对象的析构函数 , 和 new 对应 free 只会释放内存， new 调用构造函数。 malloc 与 free 是 C++/C 语言的标准库函数， new/delete 是 C++ 的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用 maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于 malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于 malloc/free 。因此 C++ 语言需要一个能完成动态内存分配和初始化工作的运算符 new ，以及一个能完成清理与释放内存工作的运算符 delete 。注意 new/delete 不是库函数。

总结：new和delete会自动调用对象的构造与析构函数而malloc与free不会；

new和delete式C++运算符，而malloc和free是C/C++标准库函数。
=============================================================================
2.delete 与 delete [] 区别

delete 只会调用一次析构函数，而 delete[] 会调用每一个成员的析构函数。  delete 与 new 配套， delete [] 与 new [] 配套
这就说明：对于内建简单数据类型， delete 和 delete[] 功能是相同的。对于自定义的复杂数据类型， delete 和 delete[] 不能互用。
delete[] 删除一个数组， delete 删除一个指针简单来说，用 new 分配的内存用 delete 删除用 new[] 分配的内存用 delete[] 删除 delete[] 会调用数组元素的析构函数。内部数据类型没有析构函数，所以问题不大。如果你在用 delete 时没用括号， delete 就会认为指向的是单个对象，否则，它就会认为指向的是一个数组。

总结： delete 只会调用一次析构函数，而 delete[] 会调用每一个成员的析构函数。
 
===========================================================================
 
3.C++ 有哪些性质（面向对象特点）
封装，继承和多态。

在面向对象程序设计语言中，封装是利用可重用成分构造软件系统的特性，它不仅支持系统的可重用性，而且还有利于提高系统的可扩充性；消息传递可以实现发送一个通用的消息而调用不同的方法；封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。
============================================================================
4. 子类析构时要调用父类的析构函数吗？
析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候 , 派生类的信息已经全部销毁了.定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数
 
=============================================================================
5. 多态，虚函数，纯虚函数

 
一 【多态】
多态的概念 ：
1 指同一个函数的多种形态。
 
2多态是具有表现多种形态的能力的特征，在OO中是指，语言具有根据对象的类型以不同方式处理之，特别是重载方法和继承类这种形式的能力。
 
3多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
多态性在Object Pascal和C++中都是通过虚函数（Virtual Function） 实现的。
 
 
二 【虚函数，纯虚函数，抽象类】
 虚函数就是为多态而生的

多态的作用：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
【例一】
class A
{
    public:
        A() {}
        （virtual） void print()
        {
            cout << “This is A.” << endl;
        }
};
class B : public A
{
    public:
        B() {}
        void print()
        {
            cout << “This is B.” << endl; 　　
        } 　　
}; 　　
int main(int argc, char* argv[])
{ 　　
    B b;
    A a;
    a = b;
    a.print; //make1
    // A &a = b; a->print();———————————-make2
    //A *a = new B();a->print();——————————–make3
    return 0;
}
这将显示：
This is B.
如果把virtual去掉，将显示：
This is A.
(make1,2,3分别是对应三种方式，调用结果是一样的)
加上virtual ,多态了，B中的print被调用了，也就是可以实现父类使用子类的方法。
 
多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作。把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(也就是可以调用子对象中对父对象的相关函数的改进方法)。

那么上面例子中为什么去掉virtual就调用的不是B中的方法了呢，明明把B的对象赋给指针a了啊，是因为C++定义了一组对象赋值的兼容规则，就是指在公有派生的情况下，对于某些场合，一个派生类的对象可以作为基类对象来使用，具体来说，就是下面三种情形：

Class A ;
class B:public A

1. 派生的对象可以赋给基类的对象
A a;
B b;
a = b;
2. 派生的对象可以初始化基类的引用
B b;
A &a = b;
3. 派生的对象的地址可以赋给指向基类的指针
B b;
A *a = &b;
或
A *a = new B();
由上述对象赋值兼容规则可知，一个基类的对象可兼容派生类的对象，一个基类的指针可指向派生类的对象，一个基类的引用可引用派生类的对象，于是对于通过基类的对象指针(或引用)对成员函数的调用，编译时无法确定对象的类，而只是在运行时才能确定并由此确定调用哪个类中的成员函数。

【例二】
#include<iostream>
using namespace std;
class A
{
    public:
        void (virtual) print(){cout << “A print”<<endl;}

    private:
};
class B : public A
{
    public:
    void print(){cout << “B print”< private:
};
void test(A &tmpClass)
{
    tmpClass.print();
}
int main(void)
{
    B b;
    test(b);
    getchar();
    return 0;
}
这将显示：
B print
如果把virtual去掉，将显示：
A print
 
函数的联编：在编译或运行将函数调用与相应的函数体连接在一起的过程。
1 先期联编或静态联编：在编译时就能进行函数联编称为先期联编或静态联编。
2 迟后联编或动态联编：在运行时才能进行的联编称为迟后联编或动态联编。
那么联编与虚函数有什么关系呢，当然，造成上面例子中的矛盾的原因就是代码的联编过程采用了先期联编，使得编译时系统无法确定究竟应该调用基类中的函数还是应该调用派生类中的函数，要是能够采用上面说的迟后联编就好了，可以在运行时再判断到底是哪个对象，所以，virtual关键字的作用就是提示编译器进行迟后联编，告诉连接过程：“我是个虚的，先不要连接我，等运行时再说吧”。
那么为什么连接的时候就知道到底是哪个对象了呢，这就引出虚函数的原理了：当编译器遇到virtual后，会为所在的类构造一个表和一个指针，那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址.指针叫做vptr，指向那个表。而这个指针保存在相应的对象当中，也就是说只有创建了对象以后才能找到相应虚函数的地址。
【注意】
1为确保运行时的多态定义的基类与派生类的虚函数不仅函数名要相同，其返回值及参数都必须相同，否则即使加上了virtual，系统也不进行迟后联编。
2 虚函数关系通过继承关系自动传递给基类中同名的函数，也就是上例中如果A中print有virtual,那么 B中的print即使不加virtual,也被自动认为是虚函数。
3 没有继承关系，多态机制没有意义，继承必须是公有继承。
4 如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的,如果发现基类提供了虚函数，那么最好override它。

纯虚函数：
虚函数的作用是为了实现对基类与派生类中的虚函数成员的迟后联编，而纯虚函数是表明不具体实现的虚函数成员，即纯虚函数无实现代码。其作用仅仅是为其派生类提过一个统一的构架，具体实现在派生类中给出。
一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。
抽象类：
含有一个或多个纯虚函数的类称为抽象类。
【例三】
#include<iostream>

using namespace std;
class A
{
    public:
        virtual float print() = 0;
    protected:
        float h,w;
    private:
};
class B : public A
{
    public:
        B(float h0,float w0){h = h0;w = w0;}
        float print(){return h*w;}
    private:
};
class C : public A
{
    public:
        C(float h0,float w0){h = h0;w = w0;}
        float print(){return h*w/2;}
    private:
};

int main(void)
{
    A *a1,*a2;
    B b(1,2);
    C c(1,2);
    a1 = &b;
    a2 = &c;
    cout << a1->print()<endl;
    cout << a2->print()<endl;
}
 
【注意】
1 抽象类并不能直接定义对象，只可以如上例那样声明指针，用来指向基类派生的子类的对象，上例中的A *a1,*a2;改为 A a1,a2;是错误的。
2 从一个抽象类派生的类必须提供纯虚函数的代码实现或依旧指明其为派生类，否则是错误的。
3 当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。
【例三】
class A
{
    public:
        A() { ptra_ = new char[10];}
        ~A() { delete[] ptra_;} // 非虚析构函数
    private:
        char * ptra_;
};

class B: public A
{
    public:
        B() { ptrb_ = new char[20];}
        ~B() { delete[] ptrb_;}
    private:
        char * ptrb_;
};

void foo()
{
    A * a = new B;
    delete a;
}
在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！ 如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。

最后通过一个例子说明一下抽象类，纯虚函数以及多态的妙用吧：
我们希望通过一个方法得到不同图形面积的和的方式：
#include<iostream>
using namespace std;
class A //定义一个抽象类，用来求图形面积
{
    public:
        virtual float area() = 0;//定义一个计算面积的纯虚函数，图形没确定
                    //不能确定具体实现
    protected:
        float h,w; //这里假设所有图形的面积都可以用h和w两个元素计算得出

};
class B : public A //定义一个求长方形面积的类
{
    public:
        B(float h0,float w0){h = h0;w = w0;}
        float area (){return h*w;}//基类纯虚函数的具体实现
 
};
class C : public A //定义一个求三角形面积的类
{
    public:
        C(float h0,float w0){h = h0;w = w0;}
        float area (){return h*w/2;}//基类纯虚函数的具体实现
    
};

float getTotal(A *s[],int n)//通过一个数组传递所有的图形对象
//多态的好处出来了吧，不是多态，不能用基类A调用
//参数类型怎么写，要是有100个不同的图形，怎么传递
{
    float sum = 0;
    for(int i = 0;i < n; i++)
        sum = sum + s[i]->area();
    return sum;
}
int main(void)
{
    float totalArea;
    A *a[2];
    a[0] = new B(1,2); //一个长方形对象
    a[1] = new C(1,2);//一个三角形对象
    totalArea = getTotal(a , 2);//求出两个对象的面积和
    
    return 0;

}

===============================================================================

最后

以上就是轻松棒棒糖为你收集整理的C/C++经典面试题总结摘选 C/C++程序员面试宝典（二）的全部内容，希望文章能够帮你解决C/C++经典面试题总结摘选 C/C++程序员面试宝典（二）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。