面试速通宝典——12

小飞猪Jay

于 2024-10-04 09:50:47 发布

阅读量503

点赞数 10

分类专栏：面试文章标签：面试职场和发展 c++ linux 计算机网络

本文链接：https://blog.csdn.net/qq_43504141/article/details/142700118

版权

面试专栏收录该内容

16 篇文章 0 订阅

订阅专栏

200. 局部变量和全局变量是否可以同名？

‌‌‌‌　　可以。局部变量会屏蔽全局变量。要用全局变量，需要使用“::”（域运算符）。

解释：

‌‌‌‌　　在C++中，局部变量和全局变量可以同名。但是，当它们同名时，局部变量会屏蔽（遮蔽）全局变量。这意味着在局部变量的作用域内，使用该变量名会引用局部变量，而不是全局变量。如果需要在这种情况下访问全局变量，可以使用域运算符 ::。

示例

‌‌‌‌　　以下是一个简单的示例，演示了局部变量和全局变量同名时的情况：

#include <iostream>

int value = 10; // 全局变量

void printValues() {
    int value = 20; // 局部变量
    std::cout << "局部变量 value: " << value << std::endl;
    std::cout << "全局变量 value: " << ::value << std::endl;
}

int main() {
    printValues();
    return 0;
}

解释

全局变量：
- 在函数 printValues 之外定义的 int value = 10 是一个全局变量。它的作用域是整个文件。
局部变量：
- 在函数 printValues 内定义的 int value = 20 是一个局部变量。它的作用域仅限于该函数内部。
变量遮蔽：
- 在函数 printValues 内，value 这个名字指的是局部变量 value，因此 std::cout << "局部变量 value: " << value << std::endl; 会输出局部变量的值 20。
- 如果需要访问全局变量 value，可以使用域运算符 ::，例如 std::cout << "全局变量 value: " << ::value << std::endl; 会输出全局变量的值 10。

关键点

局部变量的优先级高于全局变量：在局部变量的作用域内，局部变量会遮蔽同名的全局变量。
使用域运算符访问全局变量：当局部变量和全局变量同名时，可以使用 ::（域运算符）来访问全局变量。

‌‌‌‌　　通过这种方式，可以在必要时区分局部变量和全局变量，确保代码的正确性和可读性。

201. 在什么时候使用常引用？

‌‌‌‌　　如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中改变，就应该使用常引用。

解释：

‌‌‌‌　　使用常引用（const reference）有几个主要的场景，尤其是在需要提高程序效率并保护传递给函数的数据不被修改时。以下是一些详细的解释和示例：

使用常引用的场景

提高效率：
- 通过引用传递可以避免拷贝大对象，从而提高程序的性能。对于大对象，如类实例、容器等，传递引用而不是传递值可以显著减少拷贝操作的开销。
保护数据：
- 通过 const 修饰符可以防止函数修改传递给它的对象。这确保了数据的完整性，防止意外或未经授权的修改。
函数参数：
- 对于不需要修改的输入参数，使用常引用可以提高效率并保证数据不被修改。

示例

以下是一些使用常引用的具体示例：

示例 1：传递大型对象

假设有一个大型对象 MyClass，在函数中传递这个对象时使用常引用可以提高性能。

class MyClass {
    // 大量数据成员
};

void processObject(const MyClass& obj) {
    // 读取 obj 的数据，但不修改
}

int main() {
    MyClass myObject;
    processObject(myObject);
    return 0;
}

‌‌‌‌　　在这个例子中，processObject 函数通过常引用接收 MyClass 对象，避免了拷贝，同时确保了 obj 不会被修改。

示例 2：传递字符串

‌‌‌‌　　对于字符串等数据量较大的对象，使用常引用可以避免不必要的拷贝。

void printString(const std::string& str) {
    std::cout << str << std::endl;
}

int main() {
    std::string text = "Hello, World!";
    printString(text);
    return 0;
}

‌‌‌‌　　在这个例子中，printString 函数通过常引用接收 std::string，避免了拷贝，同时保证了字符串内容不会被修改。

示例 3：传递容器

‌‌‌‌　　对于容器（如 std::vector、std::map 等），使用常引用可以避免拷贝容器的数据，提高效率。

void printVector(const std::vector<int>& vec) {
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    printVector(numbers);
    return 0;
}

‌‌‌‌　　在这个例子中，printVector 函数通过常引用接收 std::vector，避免了拷贝，同时确保了向量内容不会被修改。

关键点

提高效率：通过引用传递大对象，避免拷贝，提高性能。
数据保护：使用 const 修饰符防止函数修改传递给它的对象。
函数参数：对于不需要修改的输入参数，使用常引用可以提高效率并保证数据不被修改。

总结

‌‌‌‌　　使用常引用是一种常见的编程实践，可以在提高程序效率的同时保护数据不被修改。通过合理使用常引用，可以编写出更高效、更安全的代码。

202. 类的声明和实现分开的好处？

起保护作用。
提高编译的效率。

解释：

‌‌‌‌　　将类的声明和实现分开是C++编程中的一种常见实践，带来以下几个主要好处：

1. 起保护作用

保护类的实现细节：

通过将类的声明放在头文件中，类的接口（公共成员函数和属性）对外可见，而实现细节（具体的函数实现）放在源文件中，从而隐藏了类的内部实现细节。这种做法被称为信息隐藏或封装，有助于保护类的实现不被外部直接访问和修改。

增强代码的模块化：

通过隐藏实现细节，可以实现更好的代码模块化。其他代码只需要了解类的接口，而不需要关心类的具体实现，从而降低了模块之间的耦合度。

2. 提高编译的效率

减少编译时间：

当类的实现发生变化时，只需要重新编译实现文件，而不需要重新编译所有包含该类声明的文件。这样可以显著减少编译时间，特别是在大型项目中。

更高效的增量编译：

分离声明和实现有助于增量编译。当只修改了源文件中的实现部分时，编译器只需要重新编译这个源文件，而不需要重新编译所有包含头文件的文件，这加快了编译过程。

其他好处

更好的代码组织：

分离声明和实现使得代码组织更加清晰。头文件主要包含接口声明，源文件包含实现细节，这样可以使代码更加易于阅读和维护。

便于团队协作：

在团队开发中，不同的开发者可以分别处理类的声明和实现部分，减少冲突，提高开发效率。

示例

以下是一个简单的示例，展示了如何将类的声明和实现分开：

头文件（MyClass.h）

#ifndef MYCLASS_H
#define MYCLASS_H

class MyClass {
public:
    MyClass();
    void display() const;

private:
    int value;
};

#endif // MYCLASS_H

源文件（MyClass.cpp）

#include "MyClass.h"
#include <iostream>

MyClass::MyClass() : value(0) {}

void MyClass::display() const {
    std::cout << "Value: " << value << std::endl;
}

总结

‌‌‌‌　　将类的声明和实现分开有很多好处，包括保护类的实现细节、提高编译效率、改善代码组织和便于团队协作。这种做法是C++编程中的一种最佳实践，有助于编写出更高效、可维护的代码。

203. windows 消息系统由哪几部分组成？

由 3 部分组成。

消息队列：操作系统负责为进程维护一个消息队列，程序运行时不断从该消息队列中获取消息、处理消息。
消息循环：应用程序通过消息循环不断获取消息，处理消息。
消息处理：消息循环负责将消息派发到相关的窗口上，使用关联的窗口过程函数处理。

解释：

‌‌‌‌　　Windows消息系统是Windows操作系统中的一个核心机制，它主要由以下三部分组成：

1. 消息队列（Message Queue）

作用：
- 操作系统负责为每个GUI线程维护一个消息队列，用于存储该线程的消息。消息可以由用户输入（如键盘、鼠标事件）、系统事件、其他线程或应用程序产生。
特点：
- 消息队列是一个先进先出（FIFO）的队列。应用程序不断从该队列中获取消息进行处理。
- 每个线程都有自己的消息队列，这些消息队列是相互独立的。

2. 消息循环（Message Loop）

作用：
- 应用程序通过消息循环不断获取消息队列中的消息，并对其进行处理。
- 消息循环是应用程序的主循环，通常位于主线程中，负责保持应用程序的运行状态。
常见实现：
- 消息循环通常是一个无限循环，调用 GetMessage 函数从消息队列中获取消息，如果消息队列为空，GetMessage 将使线程进入等待状态，直到有新消息到达。
- 例如：

MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
}

3. 消息处理（Message Processing）

作用：
- 消息处理是指将获取到的消息派发到相应的窗口，由窗口过程函数（Window Procedure）进行处理。
- 每个窗口都有一个关联的窗口过程函数，用于处理该窗口接收到的所有消息。
窗口过程函数：
- 窗口过程函数是一个回调函数，负责处理窗口的各种消息，如创建、绘制、键盘和鼠标输入等。
- 例如

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_PAINT:
            // 处理绘制消息
            break;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        // 处理其他消息
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

综述

‌‌‌‌　　Windows消息系统通过这三部分紧密配合，实现了消息的生成、分发和处理。每个GUI应用程序都依赖于这个系统来响应用户输入、系统事件和其他应用程序的交互，从而实现用户界面的动态交互和功能。

消息队列：存储和管理线程的消息。
消息循环：从消息队列中获取消息并派发消息。
消息处理：窗口过程函数处理具体的消息。

‌‌‌‌　　这种结构使得Windows应用程序能够高效地处理多种事件，并提供响应迅速的用户体验。

204. 什么是消息映射？

‌‌‌‌　　消息映射就是让程序员指定MFC类（有消息处理能力的类）处理某个消息。然后由程序员完成对该处理函数的编写，以实现消息处理功能。

解释：

‌‌‌‌　　消息映射（Messag7e Mapping）是Microsoft Foundation Classes (MFC)中的一个机制，用于将Windows消息与相应的消息处理函数关联起来。它使得程序员可以指定MFC类处理某个特定的消息，并编写相应的处理函数来实现消息处理功能。

消息映射的基本概念

‌‌‌‌　　消息映射的主要目的是将Windows消息（如鼠标点击、键盘输入等）与类成员函数关联起来，使得这些函数在相应消息到达时自动被调用。这种机制简化了消息处理的编写和管理，使代码更易于阅读和维护。

消息映射的实现

在MFC中，消息映射通常通过以下几个步骤实现：

声明消息映射：
- 在类声明中使用宏 DECLARE_MESSAGE_MAP 声明消息映射。
定义消息映射：
- 在类实现中使用宏 BEGIN_MESSAGE_MAP、END_MESSAGE_MAP 和其他消息映射宏（如 ON_WM_PAINT、ON_COMMAND 等）定义消息映射。
编写消息处理函数：
- 编写相应的消息处理函数，这些函数将在对应的消息到达时被调用。

示例

以下是一个简单的MFC消息映射示例：

头文件（MyWindow.h）

#pragma once
#include <afxwin.h>

class CMyWindow : public CFrameWnd {
public:
    CMyWindow();
protected:
    afx_msg void OnPaint();
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    DECLARE_MESSAGE_MAP()
};

源文件（MyWindow.cpp）

#include "MyWindow.h"

BEGIN_MESSAGE_MAP(CMyWindow, CFrameWnd)
    ON_WM_PAINT()
    ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()

CMyWindow::CMyWindow() {
    Create(NULL, _T("My MFC Window"));
}

void CMyWindow::OnPaint() {
    CPaintDC dc(this);
    dc.TextOut(50, 50, _T("Hello, MFC"));
}

void CMyWindow::OnLButtonDown(UINT nFlags, CPoint point) {
    MessageBox(_T("Left mouse button clicked!"), _T("Message"), MB_OK);
}

解释

声明消息映射：
- 在类 CMyWindow 的声明中使用 DECLARE_MESSAGE_MAP 声明消息映射。
定义消息映射：
- 在类 CMyWindow 的实现中使用 BEGIN_MESSAGE_MAP 和 END_MESSAGE_MAP 定义消息映射。通过 ON_WM_PAINT 和 ON_WM_LBUTTONDOWN 将 WM_PAINT 和 WM_LBUTTONDOWN 消息与类的 OnPaint 和 OnLButtonDown 函数关联。
编写消息处理函数：
- OnPaint 函数用于处理 WM_PAINT 消息，在窗口绘制时被调用。
- OnLButtonDown 函数用于处理 WM_LBUTTONDOWN 消息，当左键按下时被调用。

好处

简化消息处理：消息映射机制使得消息处理的编写和管理更加简洁、系统化。
增强可读性和可维护性：消息映射将消息与处理函数的关联清晰地表达出来，代码更易于理解和维护。
模块化设计：将消息处理逻辑集中在消息映射中，有助于实现模块化设计，提高代码的组织性。

总结

‌‌‌‌　　消息映射是MFC中的一个重要机制，用于将Windows消息与相应的处理函数关联起来。通过消息映射，程序员可以方便地指定MFC类处理某个消息，并编写相应的处理函数来实现消息处理功能。这种机制简化了消息处理的编写和管理，使代码更易于阅读和维护。

205. 什么是UDP和TCP？两者的区别是什么？

‌‌‌‌　　TCP 的全称是传输控制协议。这种协议可以提供面向连接的、可靠的、点到点的通信。
‌‌‌‌　　UDP 的全称为用户报文协议，它可以提供非连接的不可靠的点到多点的通信。

‌‌‌‌　　用TCP还是UDP，要看你的程序更注重哪个方面，是可靠还是快速。

解释：

‌‌‌‌　　UDP（User Datagram Protocol，用户数据报协议）和TCP（Transmission Control Protocol，传输控制协议）是两种常见的传输层协议，它们在网络通信中起着重要作用。以下是对两者的详细解释及其区别：

UDP（User Datagram Protocol）

特点：

无连接：UDP是无连接的协议，不建立连接，不保证可靠传输。
不可靠：UDP不保证数据包的顺序到达，也不保证数据包到达目标，即不提供确认和重传机制。
速度快：由于没有连接建立和确认机制，UDP传输速度快，适用于对实时性要求高的场景，如视频会议、在线游戏等。
简单：UDP的头部较短，开销小，协议简单。

应用场景：

实时应用（如VoIP、视频会议）
在线游戏
广播和多播传输

TCP（Transmission Control Protocol）

特点：

面向连接：TCP是面向连接的协议，在数据传输前需建立连接（通过三次握手）。
可靠传输：TCP保证数据按序到达，并且数据不丢失、不重复，通过确认和重传机制保证数据的可靠传输。
流控制和拥塞控制：TCP通过流控制和拥塞控制机制，确保网络的稳定性和公平性，防止网络拥塞。
有状态：TCP维持连接的状态信息，以便可靠传输。

应用场景：

需要可靠传输的应用（如HTTP、HTTPS、FTP、SMTP）
文件传输
电子邮件

UDP和TCP的主要区别

连接方式：
- UDP：无连接，不建立连接，直接发送数据包。
- TCP：面向连接，需要建立连接（三次握手）后才能传输数据。
可靠性：
- UDP：不保证数据包的可靠传输、顺序到达和无重复。
- TCP：提供可靠传输，保证数据包按序到达、无丢失、无重复。
速度：
- UDP：传输速度快，适合实时应用。
- TCP：传输速度相对较慢，因需进行连接建立和确认机制。
数据传输方式：
- UDP：面向报文，数据包独立发送，每个包大小有限制（通常为64KB）。
- TCP：面向流，数据作为字节流传输，无固定大小限制。
开销：
- UDP：头部开销小，协议简单。
- TCP：头部开销大，协议复杂，需要维护状态信息。

总结

UDP：适用于需要快速传输、容忍丢包的场景，如视频流、在线游戏、广播等。
TCP：适用于需要可靠传输、保证数据完整性的场景，如网页浏览、文件下载、电子邮件等。

选择使用哪种协议，取决于具体应用对可靠性、速度和传输方式的要求。

206. DPDK了解吗？

‌‌‌‌　　DPDK是一套开源高性能网络数据平面库，用以加速网络包的处理速度，实现高性能的包交换。

‌‌‌‌　　通过绕过传统的操作系统网络堆栈，直接在用户空间处理网络包，DPDK能够大幅减少延迟，提高数据包处理的吞吐率，广泛用于需要高速网络通信的场景，如高频交易、云计算数据中心和网络功能退化（NFV）。

解释：

‌‌‌‌　　DPDK（Data Plane Development Kit）的基本功能和应用场景。我们可以将这段话拆解成几部分来理解：

定义与目的：
- DPDK是一套开源高性能网络数据平面库。
- 它的主要目的是加速网络包的处理速度，实现高性能的包交换。
工作原理：
- 传统的操作系统网络堆栈会导致一定的处理延迟和性能瓶颈。
- DPDK通过绕过这些传统堆栈，直接在用户空间处理网络包。
- 这种方法大幅减少了延迟，提高了数据包处理的吞吐率（即单位时间内处理的数据包数量）。
应用场景：
- 高频交易：在金融领域，高频交易需要极低的延迟和高吞吐率，DPDK能够满足这些需求。
- 云计算数据中心：大规模的数据中心需要高效的数据包处理来管理大量的数据传输。
- 网络功能虚拟化（NFV）：NFV依赖于快速的数据包处理来实现各种网络功能的虚拟化，DPDK在这方面表现优异。

‌‌‌‌　　总结起来，DPDK通过直接在用户空间处理网络包，避开传统操作系统的网络堆栈，从而显著提高网络数据包处理的速度和效率。它在需要高速网络通信的场景中具有广泛的应用，例如高频交易、云计算数据中心和网络功能虚拟化。

207. C++多态的实现，以及应用场景

‌‌‌‌　　C++中的多态主要是通过虚函数实现的。当基类声明一个函数为虚函数时，派生类可以对该函数进行覆盖，以实现不同的功能。这就允许通过基类的指针或引用来调用实际派生类对象的成员函数，具体调用哪个类的函数是在运行时决定的。

实现机制：

基类中声明虚函数，使用virtual关键字
派生类中重写该虚函数
通过基类指针或引用调用虚函数时，动态绑定至派生类的实现

应用场景：

当有多个派生类时，可以调用同一个基类指针或引用来操作不同的派生类对象，实现代码的统一管理。
在设计模式中，例如工厂方法模式、策略模式、状态模式等，多态性允许用户使用接口类型的通用代码，同时传入不同的派生类实例以改变行为。
当开发库或框架时，多态允许用户通过继承和重写方法来扩展和自定义功能，而不需要修改原有的库代码。

解释：

‌‌‌‌　　举个例子来解释一下，为什么说“派生类（子类）可以覆盖（重写）基类中的虚函数，实现不同的功能，具体调用哪个类的函数是在运行时决定的”。

class Base {
public:
    virtual void foo() {
        // 基类实现
    }
};

class Derived : public Base {
public:
    void foo() override {
        // 派生类实现
    }
};

void callFoo(Base& base) {
    base.foo(); // 调用的是实际对象（基类或派生类）中的 foo 函数
}

int main() {
    Base base;
    Derived derived;

    callFoo(base);    // 调用 Base::foo()
    callFoo(derived); // 调用 Derived::foo()
}