我准备的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不是库函数。
--------------------------------------------------
2.delete与 delete []区别
delete只会调用一次析构函数，而delete[]会调用每一个成员的析构函数。
在More Effective C++中有更为详细的解释：“当delete操作符用于数组时，
它为每个数组元素调用析构函数，然后调用operator delete来释放内存。”
delete与new配套，delete []与new []配套


MemTest *mTest1=new MemTest[10];
MemTest *mTest2=new MemTest;
Int *pInt1=new int [10];
Int *pInt2=new int;
delete[]pInt1; //-1-
delete[]pInt2; //-2-
delete[]mTest1;//-3-
delete[]mTest2;//-4-


在-4-处报错。


这就说明：对于内建简单数据类型，delete和delete[]功能是相同的。对于自定义的复杂数据类型，
delete和delete[]不能互用。delete[]删除一个数组，delete删除一个指针。
简单来说，用new分配的内存用delete删除；用new[]分配的内存用delete[]删除。
delete[]会调用数组元素的析构函数。内部数据类型没有析构函数，所以问题不大。
如果你在用delete时没用括号，delete就会认为指向的是单个对象，否则，它就会认为指向的是一个数组。
=========================================================
3.C++有哪些性质（面向对象特点）
封装，继承和多态。


-------------------------------------------
1、指针和引用的区别？
答：引用是在C++中引入的。它们之间的区别有：
（1）非空区别：指针可以为空，而引用不能为空
（2）可修改区别：如果指针不是常指针，那么就可以修改指向，而引用不能
（3）初始化区别：指针在定义时可以不用初始化，而引用在定义的同时必须初始化


-------------------------------------------
5，野指针
答：“野指针”是很危险的，if语句对它不起作用。“野指针”的成因主要有两种：
(1)指针变量没有被初始化。指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。
char *p = NULL; char *str = (char *) malloc(100);
(2)指针p被free或者之后，没有置为NULL
(3)指针操作超越了变量的作用范围。所指向的内存值对象生命期已经被销毁


-------------------------------------------
5，类的sizeof大小 
1，空类大小为1
2，虚函数大小为4，构造析构不算大小
3，类大小等于所有数据成员大小之和
4，继承中类大小等于父类和子类的数据成员大小之和




---------------------------------------------
const 符号常量；
(1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别；




如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。


(1)const char *p


一个指向char类型的const对象指针，p不是常量,我们可以修改p的值，使其指向不同的char，但是不能改变它指向非char对象，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error


(2)char const *p
(3)char * const p


这两个好象是一样的，此时*p可以修改，而p不能修改。


(4)const char * const p
这种是地址及指向对象都不能修改。






=========派生继承面试=================================================




5.观察下面一段代码:
class ClassA
{
public:
virtual ~ ClassA(){};
virtual void FunctionA(){};
};
class ClassB
{
public:
   virtual void FunctionB(){};
};
class ClassC : public ClassA,public ClassB
{
public:
};
 
ClassC aObject;
ClassA* pA=&aObject;
ClassB* pB=&aObject;
ClassC* pC=&aObject;
关于pA,pB,pC的取值,下面的描述中正确的是: C
A.pA,pB,pC的取值相同.               B.pC=pA+pB
C.pA和pB不相同                      D.pC不等于pA也不等于pB
------------------------------------------------------








4.多重继承
class A{};
class B{};
class C:public A,public B{};
class D:virtual public A{};
class E:virtual public A,virtual public B{};
sizeof ( A ) = 1      (空类大小为1,编译器安插一个char给空类，用来标记它的每一个对象)
sizeof ( B ) = 1      (空类大小为1,编译器安插一个char给空类，用来标记它的每一个对象)
sizeof ( C ) = 1      (继承或多重继承后空类大小还是1)
sizeof ( D ) = 4      (虚继承时编译器为该类安插一个指向父类的指针，指针大小为4）
sizeof ( E ) = 8      (指向父类A的指针与父类B的指针，加起来大小为8）


5.数据对齐
类(或结构)的大小必需为类中最大数据类型的整数倍.CPU访问对齐的数据的效率是最高的，因此通常编译浪费一些空间来使得我们的数据是对齐的
class A{
public:
    int a;
};
class B{
public:
    int a ;
    char b;
};
class C{
public:
    int a ;
    char b;
    char c;
};
sizeof(A) = 4  （内含一个int ，所以大小为4）
sizeof(B) = 8   (int为4，char为1，和为5，考虑到对齐，总大小为int的整数倍即8)  
sizeof(C) = 8   (同上)


6.函数与虚函数
编译器为每个有虚函数的类都建立一个虚函数表（其大小不计算在类中）,并为这个类安插一个指向虚函数表的指针，即每个有虚函数的类其大小至少为一个指针的大小4
class A{
public:
    int a;
    void Function();
};
class B{
public:
    int a;
    virtual void Function();
};
class C:public B{
public:
    char b;
};
class D:public B{
public:
    virtual void Function2();
};
class E{
public:
    static void Function();
};
sizeof (A) = 4   (内含一个int,普通函数不占大小)
sizeof (B) = 8   (一个int ,一个虚函数表指针)
sizeof (C) =12   (一个int ,一个虚函数表指针，一个char ,再加上数据对齐)
sizeof (D) = 8   (一个int ,一个虚函数表指针,多个虚函数是放在一个表里的，所以虚函数表指针只要一个就行了)
sizeof (E) = 1   (static 函数不占大小,空类大小为1)


7.父类的私有数据
虽然在子类中不可用，但是是可见的，因此私有的数据还是要占子类的大小
class A{
private:
    int a;
};
class B:public A{};
sizof(B) = 4;    (内含一个不可用的父类的int）






















==========================================================
强制类型转换
C++中有专门的用于类型之间转换的关键字：
1. static_cast   //用于数值之间和一方有void*之间的转换
2. const_cast  //用于去掉const和volatile限制
3. reinterpret_cast  //任意两种指针类型之间，指针与数值类型之间
4. dynamic_cast // 用于父子类之间的转换






#include <iostream>
#include <cstdlib>


using namespace std;
int main(int argc, char *argv[])
{
    int a = static_cast<int>(123.78);
    cout<<"a = "<<a<<endl;
    int *p = static_cast<int*>(malloc(sizeof(int)));
    const int k = a;
    cout<<"k = "<<k<<endl;
    const_cast<int &>(k)  = 78;
    cout<<"k = "<<k<<endl;
    float f = 555.66;
    p = reinterpret_cast<int*>(&f);
    cout<<"*p = "<<*p<<endl;

}