C++面试题目

Posted 2020-09-21

求职期间收集的C++面试题目

C的结构体和C++结构体的区别

    1、C的结构体内不允许有函数存在，C++允许有内部成员函数，且允许该函数是虚函数。所以C的结构体是没有构造函数、析构函数、和this指针的。

    2、C的结构体对内部成员变量的访问权限只能是public，而C++允许public,protected,private三种。

    3、C语言的结构体是不可以继承的，C++的结构体是可以从其他的结构体或者类继承过来的。

    4、C的结构体只是把数据变量给包裹起来了，并不涉及算法。而C++是把数据变量及对这些数据变量的相关算法给封装起来，并且给对这些数据和类不同的访问权限。

    5、C语言中是没有类的概念的，但是C语言可以通过结构体内创建函数指针实现面向对象思想。

C++中的explicit关键字有何作用？

    禁止将构造函数作为转换函数，即禁止构造函数自动进行隐式类型转换。

重载++和–时是怎么区分前缀++和后缀++的？

    当编译器看到++a（先自增）时，它就调用operator++(a);但当编译器看到a++时，它就调用operator++(a, int)。即编译器通过调用不同的函数区别这两种形式。

多态概念

    多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

    多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOD）的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。

C++的多态性分为静态多态和动态多态

    静态多态性：编译期间确定具体执行哪一项操作，主要是通过函数重载和运算符重载来实现的；

    动态多态性：运行时确定具体执行哪一项操作，主要是通过虚函数来实现的；在程序运行过程中才动态地确定操作所针对的对象

虚继承的作用是什么？

        在多继承中，子类可能同时拥有多个父类，如果这些父类还有相同的父类（祖先类），那么在子类中就会有多份祖先类。为了防止在多继承中子类存在重复的父类情况，可以在父类继承时使用虚函数，即在类B和类C继承类A时使用virtual关键字。因为多继承会带来很多复杂问题，因此要慎用。

关于类占用的内存空间，有以下几点需要注意：

    1、如果类中含有虚函数，则编译器需要为类构建虚函数表，类中需要存储一个指针指向这个虚函数表的首地址，注意不管有几个虚函数，都只建立一张表，所有的虚函数地址都存在这张表里，类中只需要一个指针指向虚函数表首地址即可。

    2、类中的静态成员是被类所有实例所共享的，它不计入sizeof计算的空间

    3、类中的普通函数或静态普通函数都存储在栈中，不计入sizeof计算的空间

    4、类成员采用字节对齐的方式分配空间

static、const关键字的作用

    static关键字至少有下列n个作用：   

    1、函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；   

    2、在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；   

    3、在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；   

    4、在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；   

    5、在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。    

    const关键字至少有下列n个作用：   

    1、欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；   

    2、对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；   

    3、在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；   

    4、对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的 成员变量；   

    5、对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。

do{ }while(0)的好处？

    1. 帮助定义复杂的宏以避免错误

    2. 避免使用goto控制程序流C++资源清理使用RAII手法。

    3. 避免由宏引起的警告

    4. 定义单一的函数块来完成复杂的操作

TCP与UDP的不同

    1.TCP面向连接;UDP是无连接的，即发送数据之前不需要建立连接    

    2.TCP要求系统资源较多，UDP较少； 

    3.UDP程序结构较简单（TCP首部开销20字节;UDP的首部开销小，只有8个字节）

    4.流模式（TCP把数据看成一连串无结构的字节流）与数据报模式(UDP); 

    5.TCP保证数据正确性，UDP可能丢包；TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付

    6.TCP保证数据顺序，UDP不保证 

    7.每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信

    8.TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

TCP三次握手

    第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；

    第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

    第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

    握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”

四次握手

    假设Client端发起中断连接请求，也就是发送FIN报文。Server端接到FIN报文后，意思是说"我Client端没有数据要发给你了"，但是如果你还有数据没有发送完成，则不必急着关闭Socket，可以继续发送数据。你先发送ACK，"告诉Client端，你的请求我收到了，但是我还没准备好，请继续你等我的消息"。这个时候Client端就进入FIN_WAIT状态，继续等待Server端的FIN报文。

    当Server端确定数据已发送完成，则向Client端发送FIN报文，"告诉Client端，好了，我这边数据发完了，准备好关闭连接了"。

    Client端收到FIN报文后，"就知道可以关闭连接了，但是他还是不相信网络，怕Server端不知道要关闭，所以发送ACK后进入TIME_WAIT状态，如果Server端没有收到ACK则可以重传。    

    Server端收到ACK后，"就知道可以断开连接了"。Client端等待了2MSL后依然没有收到回复，则证明Server端已正常关闭，那好，我Client端也可以关闭连接了。Ok，TCP连接就这样关闭了！

TCP UDP端口扫描的实现方式

    TCP SYN 扫描

    TCP FIN 扫描

    TCP ACK 扫描

    recvfrom扫描

    ICMP端口不可达扫描

继承中析构函数最好为虚函数为什么？

    在实现多态时，当用基类操作派生类，在析构时防止只析构基类而不析构派生类的状况发生。

    在类的继承中，如果有基类指针指向派生类，那么用基类指针delete时，如果不定义成虚函数，派生类中派生的那部分无法析构。

    用基类的指针去操作继承类的成员,释放指针P的过程是:只是释放了基类的资源,而没有调用继承类的析构函数;基类的析构函数是虚的，那么它的子类的析构函数也是虚的。

    如果不需要基类对派生类及对象进行操作,则不能定义虚函数,因为这样会增加内存开销.

    当类里面有定义虚函数的时候,编译器会给类添加一个虚函数表,里面来存放虚函数指针,这样就会增加类的存储空间.所以,只有当一个类被用来作为基类的时候,才把析构函数写成虚函数.

构造函数不能声明为虚函数的原因是

     1.构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。而在构造一个对象时，由于对象还未构造成功。编译器无法知道对象 的实际类型，是该类本身，还是该类的一个派生类，或是更深层次的派生类。    

    2.虚函数的执行依赖于虚函数表。而虚函数表在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初 始化，将无法进行。

必须在类初始化列表中初始化的几种情况

    1. 类成员为const类型

    2. 类成员为引用类型

    3. 类成员为没有默认构造函数的类类型

    4. 如果类存在继承关系，派生类必须在其初始化列表中调用基类的构造函数

static_cast< type-id > ( expression )

    用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。

    用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。

    把void指针转换成目标类型的指针;把任何类型的表达式转换成void类型。(static_cast不能转换掉expression的const、volitale、或者__unaligned属性。)

dynamic_cast< type-id > ( expression )

    Type-id必须是类的指针、类的引用或者void *；如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。

    在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

reinpreter_cast<type-id> (expression)

    type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针

const_cast<type_id> (expression)

    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

    常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

---

1. 如果我们定义了一个构造函数，编译器就不会再为我们生成默认构造函数了。

2. 编译器生成的析构函数是非虚的，除非是一个子类，其父类有个虚析构，此时的函数虚特性来自父类。

3. 有虚函数的类，几乎可以确定要有个虚析构函数。

4. 如果一个类不可能是基类就不要申明析构函数为虚函数，虚函数是要耗费空间的。

5. 析构函数的异常退出会导致析构不完全，从而有内存泄露。最好是提供一个管理类，在管理类中提供一个方法来析构，调用者再根据这个方法的结果决定下一步的操作。

6. 在构造函数不要调用虚函数。在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，子类还没有构造，还没有初始化，如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。

7.在析构函数中也不要调用虚函数。在析构的时候会首先调用子类的析构函数，析构掉对象中的子类部分，然后在调用基类的析构函数析构基类部分，如果在基类的析构函数里面调用虚函数，会导致其调用已经析构了的子类对象里面的函数，这是非常危险的。

8. 记得在写派生类的拷贝函数时，调用基类的拷贝函数拷贝基类的部分，不能忘记了。

---

#ifndef __INCvxWorksh

#define __INCvxWorksh 

#ifdef __cplusplus

extern "C" {

#endif 

/*...*/ 

#ifdef __cplusplus

}

#endif 

#endif /* __INCvxWorksh */

作用是防止被重复引用。   

void foo(int x, int y);   

该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。   为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。

---

class String

{ 

 public: 

 String(const char *str = NULL); // 普通构造函数 

 String(const String &other); // 拷贝构造函数 

 ~ String(void); // 析构函数 

 String & operator =(const String &other); // 赋值函数 

 private: 

 char *m_data; // 用于保存字符串 

};

//普通构造函数

String::String(const char *str) 

{

 if(str==NULL) 

 {

 m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志‘\0‘的空

 //加分点：对m_data加NULL 判断

 *m_data = ‘\0‘; 

 } 

 else

 {

 int length = strlen(str); 

 m_data = new char[length+1]; // 若能加 NULL 判断则更好 

 strcpy(m_data, str); 

 }

}

// String的析构函数

String::~String(void) 

{

 delete [] m_data; // 或delete m_data;

}

//拷贝构造函数

String::String(const String &other) 　　　// 得分点：输入参数为const型

{ 

 int length = strlen(other.m_data); 

 m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断

 strcpy(m_data, other.m_data); 

}

//赋值函数

String & String::operator =(const String &other) // 得分点：输入参数为const型

{ 

 if(this == &other) 　　//得分点：检查自赋值

 return *this; 

 delete [] m_data; 　　　　//得分点：释放原有的内存资源

 int length = strlen( other.m_data ); 

 m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断

 strcpy( m_data, other.m_data ); 

 return *this; 　　　　　　　　//得分点：返回本对象的引用

}