C\C++ 面试的难点与易错点（第一天）

最新推荐文章于 2024-04-26 19:02:59 发布

雪靡

最新推荐文章于 2024-04-26 19:02:59 发布

阅读量602

点赞数 1

分类专栏： C\C++ 面试经验文章标签： c++ 面试

本文链接：https://blog.csdn.net/z736248591/article/details/120202746

版权

C\C++ 同时被 2 个专栏收录

6 篇文章 1 订阅

订阅专栏

面试经验

1 篇文章 0 订阅

订阅专栏

定义一个空类型，里面没有任何成员变量和成员函数，对其求sizeof，得到的结果为？

答案：1。

解释：实际上，这是类结构体实例化的原因，空的类或结构体同样可以被实例化，如果定义对空的类或者结构体取sizeof()的值为0，那么该空的类或结构体实例化出很多实例时，在内存地址上就不能区分该类实例化出的实例，，，所以，为了实现每个实例在内存中都有一个独一无二的地址，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址，所以空类所占的内存大小是1个字节¹。切忌：一旦类中有其他的占用空间成员，则这1个字节就不在计算之内。²
如果在该类型添加一个构造函数和析构函数，再对其sizeof，得到结果为？

答案：1。

解释：因为调用构造函数和析构函数只需知道函数的地址，而函数的地址只与类型相关，而与类型的实例无关。³
那如果把析构函数标记为虚函数呢？

答案：C++编译器一旦发现类型中有虚函数，就会为该类型生成虚函数表，并在该类型的每个实例中添加一个指向虚函数表的指针。在32位的机器上，一个指针占4B；在64位的机器上，一个指针占8B。为何需要虚函数表？因为虚函数表是C++实现多态的一种机制。²

虚函数表实现原理
虚函数的实现是由两个部分组成的，虚函数指针与虚函数表。

虚函数指针

虚函数指针 (virtual function pointer) 从本质上来说就只是一个指向函数的指针，与普通的指针并无区别。它指向用户所定义的虚函数，具体是在子类里的实现，当子类调用虚函数的时候，实际上是通过调用该虚函数指针从而找到接口。

虚函数指针是确实存在的数据类型，在一个被实例化的对象中，它总是被存放在该对象的地址首位，这种做法的目的是为了保证运行的快速性。与对象的成员不同，虚函数指针对外部是完全不可见的，除非通过直接访问地址的做法或者在DEBUG模式中，否则它是不可见的也不能被外界调用。

只有拥有虚函数的类才会拥有虚函数指针，每一个虚函数也都会对应一个虚函数指针。所以拥有虚函数的类的所有对象都会因为虚函数产生额外的开销，并且也会在一定程度上降低程序速度。与JAVA不同，C++将是否使用虚函数这一权利交给了开发者，所以开发者应该谨慎的使用。

虚函数表⁴

上文已经提到，每个类的实例化对象都会拥有虚函数指针并且都排列在对象的地址首部。而它们也都是按照一定的顺序组织起来的，从而构成了一种表状结构，称为虚函数表 (virtual table) 。

我们先来规定一个基类
```
class Base
{
    public:
    virtual void f(){cout<<"Base::f"<<endl;}
    virtual void g(){cout<<"Base::g"<<endl;}
    virtual void h(){cout<<"Base::h"<<endl;}
};
```
首先对于基类Base它的虚函数表记录的只有自己定义的虚函数

接下来我们来看看子类的情况
```
class Derived:public Base
{
	public:
    virtual void f(){cout<<"Derived::f"<<endl;}
    virtual void g1(){cout<<"Derived::g1"<<endl;}
    virtual void h1(){cout<<"Derived::h1"<<endl;}
}
```
· 一般覆盖继承

首先是最常见的继承，子类Derived对基类的虚函数进行覆盖继承，在这个例子中仅设计了一个函数继承的情况以此推广情况。

那么此时情况是这样的：

首先基函数的表项仍然保留，而得到正确继承的虚函数其指针将会被覆盖，而子类自己的虚函数将跟在表后。

而当多重继承的时候，表项将会增多，顺序会体现为继承的顺序，并且子函数自己的虚函数将跟在第一个表项后。

C++中一个类是公用一张虚函数表的，基类有基类的虚函数表，子类是子类的虚函数表，这极大的节省了内存

同名覆盖原则与const修饰符
如果继续深入下去的话我们将会碰见一个有趣的状况
```
class Base
{
public:
	virtual void func()const
	{
		cout << "Base!" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void func()
	{
		cout << "Derived!" << endl;
	}
};

void show(Base& b)
{
	b.func();
}
Base base;
Derived derived;

int main()
{
	show(base);
	show(derived);
	base.func();
	derived.func();
	return 0;
}
```
在上述程序中我们将Base类中的虚函数base定义为const类型，我们知道const后缀的目的是为了限定该函数不对类内成员做出修改。然后我们分别声明base与derived并且通过show函数调用它们的func函数，子类传参给父类也是非常正常的一个操作，但是结果可能却令人不解：
```
Base!
Base!
Base!
Derived!
```
这里有一个很大的问题，因为当我们将derived传过去的时候并没有调用derived的虚函数！也就是说虚函数不再是多态的了。

但是的话我们只需要简单的修改任意一项：将line4结尾的const限定符去掉或者将Derived的func1后加上const便可以使一切正常。这是为什么呢？

很多其他的博客将其解释为是const符号作用的原因，但实际上这样的解释并不正确。正确的原因是:

虚函数的声明与定义要求非常严格，只有在子函数中的虚函数与父函数一模一样的时候（包括限定符）才会被认为是真正的虚函数，不然的话就只能是重载。这被称为虚函数定义的同名覆盖原则，意思是只有名称完全一样时才能完成虚函数的定义。

因此在上述的例子中，将Derived类型的子类传入show函数时，实际上类型转化为了Base，由于此时虚函数并未完成定义，Derived的func()此时仅仅是属于Derived自己的虚函数，所以在show中b并不能调用，而调用的是Base内的func。而当没有发生类型转换的时候，Base类型与Derived类型就会各自调用自己的func函数⁵。
构造函数和析构函数可以是虚函数吗？

构造函数不能是虚函数
1. 存储空间角度
  　虚函数的调用需要 vptr 指针，而该指针存放在对象的内容空间中，需要调用构造函数才可以创建它的值，否则即使开辟了空间，该 vptr 指针为随机值；若构造函数声明为虚函数，那么由于对象还未创建，还没有内存空间，更没有 vptr 地址用来调用虚函数之一的构造函数了。
2. 多态角度
  　虚函数主要是实现多态，在运行时才可以明确调用对象，根据传入的对象类型来调用函数，例如通过父类的指针或者引用来调用它的时候可以变成调用子类的那个成员函数。而构造函数是在创建对象时自己主动调用的，不可能通过父类的指针或者引用去调用。那使用虚函数也没有实际意义。
  　在调用构造函数时还不能确定对象的真实类型（由于子类会调父类的构造函数）；并且构造函数的作用是提供初始化，在对象生命期仅仅运行一次，不是对象的动态行为，没有必要成为虚函数。
析构函数常常是虚函数

创建一个对象时我们总是要明白指定对象的类型。虽然我们可能通过基类的指针或引用去訪问它但析构却不一定，我们往往通过基类的指针来销毁对象。这时候假设析构函数不是虚函数，就不能正确识别对象类型从而不能正确调用析构函数。
写通用函数时，运行根据传入对象的类型确定函数的地址，然后调用该函数。但析构却不一定，上面已经提到过了，我们往往通过基类的指针来销毁对象。这时候如果析构函数不是虚函数，就不能正确识别对象类型从而不能正确调用析构函数。
数组与数组指针进行sizeof区别

指针与数组名与指针有太多的相似，甚至很多时候，数组名可以作为指针使用。但是数组和指针存在差异。指针，是一个变量，存储的数据是地址。数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组，其外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量⁶。数组名只是大多数时候隐式转换成指向首元素的指针类型右值。这些时候不会转换：1）对其用 &；2）对其用 sizeof；3）C++中取引用⁷。

我们先来一段代码作为演示：
```
#include<iostream>
using namespace std;
void func(int C[])
{
    cout<<"In function, C sizeof(C):"<<sizeof(C)<<endl;
    cout<<"C point:"<<C<<endl;
    cout<<"C &point:"<<&C<<endl;
    C++;
}
int main()
{
    int A[10];
    int* B=new int[10];
    cout<<"A sizeof(A):"<<sizeof(A)<<endl;
    cout<<"B sizeof(B):"<<sizeof(B)<<endl;
    // 取引用地址
    cout<<"A point:"<<A<<endl;
    cout<<"A &point:"<<&A<<endl;
    cout<<"B point:"<<B<<endl;
    cout<<"B &point:"<<&B<<endl;

    //调用函数
    func(A);
    //A++;//Error
    return 0;
}
```
在X86的编译环境下，输出的结果为：
```
A sizeof(A):40
B sizeof(B):4
A point:0x6dfec8
A &point:0x6dfec8
B point:0x1fa838
B &point:0x6dfec4
In function, C sizeof(C):4
C point:0x6dfec8
C &point:0x6dfeb0
```
显然第14行输出的是数组长度，第15行输出的是指针长度（在X86下为4字节，在x64环境下为8字节）。

第17-第20行，对数组取引用，其地址和本身的地址是一样，而指针则不一样。

第23行，当调用函数的时候，数组会转换为指针，因此长度为4，并且可以做自加运算。
0,0.0,‘0’,“0”,void*占字节数量
- 0为int类型，占4字节。
- 0.0为double类型，占8字节。
- '0’为char类型，占1字节。
- "0"为字符串，为char类型数组，有两个元素(“0\0”)占用1*2=2字节。
- void*为空指针。在x86上，指针为4字节。在x64上，指针为8字节。
C++ const

const的用法大致可分为以下几个方面：⁸
一、修饰普通类型的变量

const 变量指的是，此变量的值是只读的，不应该被改变。
```
const int  a = 7; // 等价于 int const a=7;
int  b = a; // 正确
a = 8;       // 错误，不能改变
```
二、const修饰指针变量

const 修饰指针变量有以下三种情况。
- A: const 修饰指针指向的内容，则内容为不可变量。
- B: const 修饰指针，则指针为不可变量。
- C: const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。
对于 A:
```
const int *p = 8;
```
则指针指向的内容 8 不可改变。简称左定值，因为 const 位于 * 号的左边。

对于 B:
```
int a = 8;
int* const p = &a;
*p = 9; // 正确
int  b = 7;
p = &b; // 错误
```
对于 const 指针 p 其指向的内存地址不能够被改变，但其内容可以改变。简称，右定向。因为 const 位于 * 号的右边。

对于 C: 则是 A 和 B的合并
```
int a = 8;
const int * const  p = &a;
```
这时，const p 的指向的内容和指向的内存地址都已固定，不可改变。

三、const应用到函数中

有以下两种情况：

A: const 修饰参数

B: const 修饰函数的返回值

对于A：
```
void fun0(const A* a ); 
void fun1(const A& a);
```
调用函数的时候，用相应的变量初始化const常量，函数内部不能够改变这个参数的值。

对于B：
```
const A fun2( ); 
const A* fun3( );
```
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。

const 修饰内置类型的返回值，修饰与不修饰返回值作用一样。
const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。

四、const在类中的用法

有以下两种情况：
- A: const 修饰类数据成员
- B: const 修饰类成员函数
对于A：

C++11仅不允许在类声明中初始化static非const类型的数据成员。
```
// using c++11 standard
class CTest11
{
public:
    static const int a = 3; // Ok in C++11
    static int b = 4;       // Error
    const int c = 5;        // Ok in C++11
    int d = 6;              // Ok in C++11
public:
    CTest11() :c(0) { }     // Ok in C++11
};

int main()
{
    CTest11 testObj;
    cout << testObj.a << testObj.b << testObj.c << testObj.d << endl;
    return 0;
}
```
到这里就把在类中定义常量的方法都陈列出来了。

关于C++11新特性： C++11仅不允许在类声明中初始化static非const类型的数据成员

总结如下：

对于static const 类型的成员变量不管是旧的C++标准还是C++11都是支持在定义时初始化的。
对于static 非const类型的成员变量C++03和C++11的标准都是不支持在定义时初始化的。
对于const 非static类型的成员变量C++03要求必须在构造函数的初始化列表中来初始化，而C++11的标准支持这种写法，同时允许在定义时进行初始化操作。
对于非static 非const成员变量，C++03标准不允许在成员变量定义时初始化，但是C++11标准允许在类的定义时对这些非静态变量进行初始化。
对于static非const成员变量的初始化方式并未改变，就是在相应的cpp文件中写成int CTest11::b = 5即可，注意要在类定义之后。

对于B：

const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。

**注意：**const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。

下面的 get_cm()const; 函数用到了 const 成员函数：

class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
private:
    int _cm;
};
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
 
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

如果 get_cm() 去掉 const 修饰，则 Cmf 传递的 const _tt 即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为 const 成员函数。

如果有个成员函数想修改对象中的某一个成员怎么办？这时我们可以使用 mutable 关键字修饰这个成员，mutable 的意思也是易变的，容易改变的意思，被 mutable 关键字修饰的成员可以处于不断变化中，如下面的例子。

class Test
{
public:
    Test(int _m,int _t):_cm(_m),_ct(_t){}
    void Kf()const
    {
        ++_cm; // 错误
        ++_ct; // 正确
    }
private:
    int _cm;
    mutable int _ct;
};
 
int main(void)
{
    Test t(8,7);
    return 0;
}