C++经典面试题目（十四）

Masami22

于 2024-03-30 19:54:03 发布

阅读量1k

点赞数 16

文章标签： c++ 面试 java

本文链接：https://blog.csdn.net/eason22/article/details/137181280

版权

1. 指针常量与常量指针区别

在C++中，指针常量和常量指针是两个不同的概念，它们涉及到指针和其所指向数据的常量性。理解这两者的区别对于编写安全、高效的代码至关重要。

指针常量 (Pointer to Constant)

指针常量是一个指向常量的指针。这意味着你不能通过这个指针来修改它所指向的数据，但是你可以改变这个指针本身，让它指向其他的数据。

例如：

const int *p;  // 指针常量

这里，p 是一个指针，它指向一个常量 int。你不能通过 *p = some_value; 这样的操作来修改 p 所指向的数据，但是你可以改变 p 的值，让它指向另一个 int 常量。

const int a = 10;
const int b = 20;
const int *p = &a;  // p 指向 a
p = &b;  // 可以改变 p 的值，让它指向 b
// *p = 30;  // 这行是错误的，因为 p 指向的是一个常量

常量指针 (Constant Pointer)

常量指针是一个常量，它指向一个（可能不是常量的）数据。这意味着你不能改变这个指针指向哪里，但是你可以通过这个指针来修改它所指向的数据（如果数据本身不是常量的话）。

例如：

int *const p;  // 常量指针

这里，p 是一个常量指针，它指向一个 int。你不能改变 p 的值来让它指向另一个地址，但是你可以通过 *p = some_value; 这样的操作来修改 p 所指向的数据。

int a = 10;
int b = 20;
int *const p = &a;  // p 指向 a
// p = &b;  // 这行是错误的，因为 p 是一个常量指针
*p = 30;  // 可以修改 p 所指向的数据

指向常量的常量指针

你还可以有一个指向常量的常量指针，这意味着你既不能改变指针本身的值（因为它是一个常量指针），也不能通过指针来修改它所指向的数据（因为它指向一个常量）。

const int *const p;  // 指向常量的常量指针

这种指针在初始化之后就不能再被改变，而且它所指向的数据也不能被修改。

理解这些概念对于编写安全、健壮的代码至关重要，因为它们可以帮助你避免在代码中意外地修改数据或指针的值。

2. 如何避免“野指针”

在C++中，野指针（wild pointer）是指那些指向已经被释放或未分配的内存的指针。使用野指针会导致不可预测的行为，包括程序崩溃、数据损坏等。因此，避免野指针是非常重要的。以下是一些常见的策略来避免野指针：

初始化指针：
在声明指针时，务必将其初始化为nullptr。未初始化的指针可能指向任意内存地址，这是非常危险的。
```
int* ptr = nullptr;
```

及时释放内存：
当你使用new分配内存后，一定要记得在适当的时候使用delete释放它。对于动态数组，使用delete[]。

int* ptr = new int;
// ... 使用ptr指向的内存 ...
delete ptr;
ptr = nullptr; // 将指针设为nullptr是一个好习惯，可以防止悬挂指针

避免悬挂指针：
释放内存后，将指针设置为nullptr。这样即使你误用了这个指针，程序也会因为试图访问nullptr而立即崩溃（在大多数系统中，解引用nullptr会触发段错误），而不是产生更难以追踪的错误。
使用智能指针：
C++11引入了智能指针（如std::unique_ptr、std::shared_ptr和std::weak_ptr），它们可以自动管理内存，从而避免手动管理内存时可能出现的野指针问题。
```
std::unique_ptr<int> smartPtr(new int);
// ... 使用smartPtr指向的内存 ...
// 不需要显式调用delete，当smartPtr离开作用域时，它会自动删除所指向的对象
```
避免指针运算：
指针运算（如递增、递减或加上偏移量）容易导致指针指向非预期的内存地址。除非你确定自己在做什么，否则尽量避免这类运算。
检查指针有效性：
在解引用指针之前，始终检查它是否为nullptr。
```
if (ptr != nullptr) {
    // 安全地解引用ptr
}
```
使用RAII（资源获取即初始化）技术：
RAII是一种编程技巧，它通过将资源的生命周期绑定到对象的生命周期来管理资源。当对象被销毁时，它的析构函数会自动释放资源。这可以确保资源在不再需要时被正确释放。
避免裸指针：
尽可能使用标准库容器（如std::vector、std::string等）和智能指针，它们提供了更安全的内存管理方式。
使用工具进行内存检测：
使用诸如Valgrind、AddressSanitizer（ASan）等内存检测工具来发现内存泄漏和野指针问题。

遵循上述建议可以大大减少野指针问题，提高程序的健壮性和安全性。

3. 句柄和指针的区别和联系是什么？

在C++中，句柄（Handle）和指针（Pointer）都是用于访问和操作内存资源的机制，但它们之间存在一些重要的区别和联系。

区别：

抽象级别：指针提供了对内存的直接访问，它们指向内存中的特定位置。因此，使用指针时，程序员需要更直接地管理内存，这增加了出错的可能性。相比之下，句柄是一种更高级别的抽象，它隐藏了内存管理的细节。句柄通常不直接指向内存地址，而是作为访问特定资源的间接引用。
安全性：由于指针直接操作内存，因此使用指针时更容易出现诸如野指针、悬挂指针等问题，这可能导致程序崩溃或数据损坏。而句柄通常由操作系统或库函数管理，它们提供了更安全的资源访问方式，减少了直接操作内存带来的风险。
跨平台性：指针是C++语言的一部分，因此它们在所有支持C++的平台上都是可用的。然而，句柄的实现可能因操作系统或库的不同而有所不同。因此，在使用句柄时，需要注意其跨平台性。

联系：

资源访问：无论是使用指针还是句柄，它们都是用于访问和操作内存资源的工具。指针通过直接指向内存地址来访问数据，而句柄则通过间接引用访问资源。
内存管理：虽然指针和句柄在内存管理方面的抽象级别不同，但它们都与内存管理密切相关。指针需要程序员手动管理内存分配和释放，而句柄则通常由操作系统或库函数自动管理。
性能考虑：在某些情况下，使用句柄而不是指针可能会带来性能上的优势。例如，当资源需要在多个进程或线程之间共享时，使用句柄可以避免直接操作内存地址所带来的复杂性和潜在风险。

总的来说，句柄和指针在C++中都是用于访问和操作内存资源的机制，但它们在抽象级别、安全性和跨平台性等方面存在差异。选择使用哪种机制取决于具体的应用场景和需求。

4. 说一说extern“C”

extern "C" 是 C++ 语言中的一个特定语法，它用于告诉 C++ 编译器将随后的代码或声明以 C 语言的方式进行处理。这主要是为了与 C 语言库或其他 C++ 代码（可能是用 C 语言的链接约定编写的）进行互操作。

当你在 C++ 中链接 C 代码时，由于 C++ 支持函数重载，因此它使用名称修饰（或称为名字重整、名称修饰）来区分具有相同名称但不同参数类型的函数。然而，C 语言并不支持函数重载，因此它不会进行名称修饰。这可能导致在链接阶段出现问题，因为 C++ 编译器查找的函数名与 C 编译器生成的函数名不匹配。

extern "C" 正是为了解决这个问题而存在的。当你在 C++ 中使用 extern "C" 时，你告诉编译器不要对该段代码进行名称修饰，而是使用 C 语言的链接约定。

以下是一个简单的例子：

假设你有一个 C 函数定义在一个 .c 文件中：

// myfunc.c
#include <stdio.h>

void my_function() {
    printf("Hello from C!\n");
}

然后，在 C++ 代码中，你想要调用这个函数：

// main.cpp
extern "C" {
    void my_function();
}

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

在这个例子中，extern "C" 确保 C++ 编译器在链接时查找未修饰的 my_function 名称，从而能够成功链接到 C 代码中的 my_function 函数。

需要注意的是，通常只在 C++ 代码中使用 extern "C"，而在 C 代码中不需要。此外，整个函数声明或定义应该被 extern "C" 块包围，而不仅仅是函数名。这确保了 C++ 编译器对整个函数使用 C 语言的链接约定。

5. 对c++中的smart pointer四个智能指针：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解

在C++中，智能指针是一种用于自动管理动态分配内存的对象。它们通过封装原始指针并提供特定的所有权语义来减少内存泄漏和简化内存管理。C++11引入了三个主要的智能指针：std::shared_ptr、std::unique_ptr和std::weak_ptr。而std::auto_ptr是C++98中引入的，但在C++11中已被弃用，因为它存在一些问题，如所有权转移时的潜在问题。

下面是对这四个智能指针的详细理解：

1. `std::shared_ptr`

std::shared_ptr 实现了共享所有权的语义。多个 shared_ptr 可以指向同一个对象，并且当最后一个指向该对象的 shared_ptr 被销毁或重置时，该对象才会被自动删除。shared_ptr 内部使用一个引用计数来跟踪有多少 shared_ptr 实例指向同一个对象。当引用计数降为0时，对象会被删除。

2. `std::unique_ptr`

std::unique_ptr 实现了独占所有权的语义。一个 unique_ptr 在任何时候都独占其所指向的对象。你不能复制一个 unique_ptr，但你可以移动它。这意味着一旦一个 unique_ptr 拥有了一个对象，就不能有其他 unique_ptr 同时拥有同一个对象。当 unique_ptr 被销毁时，它所指向的对象也会被自动删除。

3. `std::weak_ptr`

std::weak_ptr 是对 std::shared_ptr 的一个辅助工具，它指向一个由 shared_ptr 管理的对象，但不控制该对象的生命周期。weak_ptr 不会增加对象的引用计数，因此不会阻止 shared_ptr 在最后一个 shared_ptr 被销毁时删除对象。weak_ptr 主要用于解决 shared_ptr 循环引用的问题，当两个 shared_ptr 相互引用时，它们的引用计数永远不会降为0，从而导致内存泄漏。使用 weak_ptr 可以打破这种循环引用。

4. `std::auto_ptr`（已弃用）

std::auto_ptr 是C++98中引入的一个智能指针，但在C++11中已被弃用，因为它存在一些问题。auto_ptr 拥有独占所有权的语义，但它有一个危险的特性：当一个 auto_ptr 被赋值给另一个 auto_ptr 时，所有权会发生转移，原来的 auto_ptr 会变成空指针，而新的 auto_ptr 则获得所有权。这种行为容易导致错误，特别是在复杂的代码结构中。因此，现在推荐使用 std::unique_ptr 来替代 std::auto_ptr。

总结：智能指针是C++中用于自动管理动态内存的重要工具。std::shared_ptr、std::unique_ptr 和 std::weak_ptr 是C++11中推荐的智能指针类型，而 std::auto_ptr 由于其潜在的问题已被弃用。