智能指针处理char*的数据_new char[] 智能指针-优快云博客

1.概要

1.要点

1.数组类型（如果你告诉智能指针，这个时候数组，他会delete[]）

// 将 raw_ptr 转换为 std::unique_ptr
    std::unique_ptr<char[]> smart_ptr(raw_ptr);

2.自定义删除器 (如果你不告诉他数组，也可以自定义删除器，这样智能指针会用你的删除器来处理指针)

// 自定义删除器，用于删除数组
    auto deleter = [](char* p) { delete[] p; };
 
    // 将 raw_ptr 转换为 std::shared_ptr 并提供自定义删除器
    std::shared_ptr<char[]> smart_ptr(raw_ptr, deleter);

2.相关链接

智能指针处理char*的数据-优快云博客

关于字节数组的内存清理（delete和delete[ ]）-优快云博客

智能指针管理char*数据的内存释放-优快云博客

智能指针是如何知道内存释放的时机的-优快云博客

2.内容

在C++中，智能指针（如 std::unique_ptr 和 std::shared_ptr）是用来管理动态分配的内存的，以避免手动管理内存时可能出现的内存泄漏或悬挂指针等问题。如果你有一个 char* 指针，并且你希望将其与智能指针关联起来，以便自动管理内存，你可以将 char* 转换为智能指针，并通过智能指针来访问和操作这块内存。

以下是一个使用 std::unique_ptr 来管理 char* 内存的示例：

示例：使用 `std::unique_ptr` 管理 `char*`

#include <iostream>
#include <memory>
#include <cstring>

int main() {
    // 动态分配一块内存并初始化
    char* raw_ptr = new char[20];
    std::strcpy(raw_ptr, "Hello, World!");

    // 将 raw_ptr 转换为 std::unique_ptr
    std::unique_ptr<char[]> smart_ptr(raw_ptr);

    // 使用智能指针访问和修改数据
    std::cout << "Message: " << smart_ptr.get() << std::endl;
    
    // 修改内存中的数据
    std::strcpy(smart_ptr.get(), "Hello, C++!");
    std::cout << "Updated Message: " << smart_ptr.get() << std::endl;

    // 智能指针在超出作用域时会自动释放内存
    return 0;
}

示例：使用 `std::shared_ptr` 管理 `char*`

如果你需要使用共享所有权，可以使用 std::shared_ptr，但需要注意的是，std::shared_ptr 并没有直接的数组类型的支持，因此需要提供一个自定义的删除器：

#include <iostream>
#include <memory>
#include <cstring>

int main() {
    // 动态分配一块内存并初始化
    char* raw_ptr = new char[20];
    std::strcpy(raw_ptr, "Hello, World!");

    // 自定义删除器，用于删除数组
    auto deleter = [](char* p) { delete[] p; };

    // 将 raw_ptr 转换为 std::shared_ptr 并提供自定义删除器
    std::shared_ptr<char[]> smart_ptr(raw_ptr, deleter);

    // 使用智能指针访问和修改数据
    std::cout << "Message: " << smart_ptr.get() << std::endl;

    // 修改内存中的数据
    std::strcpy(smart_ptr.get(), "Hello, C++!");
    std::cout << "Updated Message: " << smart_ptr.get() << std::endl;

    // 智能指针在超出作用域时会自动释放内存
    return 0;
}

注意事项

不要混用：不要混用原始指针和智能指针来管理同一块内存，否则可能会导致双重释放或悬挂指针。
避免裸指针：尽量在代码中使用智能指针而不是裸指针，以确保内存管理的安全性。
选择合适的智能指针：std::unique_ptr 适用于独占所有权的情况，而 std::shared_ptr 适用于共享所有权的情况。

通过使用智能指针，你可以更安全、更方便地管理动态分配的内存，避免许多常见的内存管理错误。

3.关联知识

1.smart_ptr.get()返回的是一个指针吗

是的，smart_ptr.get() 返回的是一个指针。在 C++ 的智能指针库中，get() 成员函数被设计用来返回智能指针内部存储的原始指针。

对于 std::unique_ptr<T>，get() 返回的是一个 T* 类型的指针，指向智能指针所管理的对象。
对于 std::shared_ptr<T>，get() 同样返回一个 T* 类型的指针。

这个返回的指针可以直接用于那些需要原始指针的场合，比如传递给 C 风格的 API 函数，或者用于某些需要指针算术运算的场景。然而，你应该小心使用这个指针，因为智能指针仍然拥有这块内存的所有权，并且会在适当的时候释放它。因此，你不应该使用这个指针来手动释放内存，也不应该让其他智能指针来管理这个指针所指向的内存块，否则可能会导致未定义的行为，比如双重释放。

下面是一个简单的例子：

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> sp = std::make_unique<int>(42);
    int* raw_ptr = sp.get();
    
    std::cout << "Value: " << *raw_ptr << std::endl;
    
    // 注意：不要使用 raw_ptr 来释放内存，也不要让其他智能指针管理它。
    // sp 会在其作用域结束时自动释放内存。
    
    return 0;
}

在这个例子中，sp.get() 返回了一个指向由 std::unique_ptr<int> 管理的 int 对象的指针。我们可以使用这个指针来访问对象的值，但是不应该用它来进行内存管理操作。

2.如果我用<char>来处理数组会怎样

// 自定义删除器，用于删除数组
auto deleter = [](char* p) { delete[] p; };

// 将 raw_ptr 转换为 std::shared_ptr 并提供自定义删除器
//std::shared_ptr<char[]> smart_ptr(raw_ptr, deleter);
std::shared_ptr<char> smart_ptr(raw_ptr, deleter);

在您提供的代码片段中，您尝试使用 std::shared_ptr<char> 来管理一个 char 数组，并且提供了一个自定义删除器来确保数组被正确地删除（使用 delete[]）。然而，这里有一个细微的问题：std::shared_ptr<char> 实际上是被设计为管理单个 char 对象的，而不是 char 数组。

当您使用 std::shared_ptr<char> 时，它默认会使用 delete 来释放内存，而不是 delete[]。即使您提供了一个自定义删除器，这个删除器也只会在 shared_ptr 的最后一个实例被销毁时调用。但是，使用 std::shared_ptr<char> 来管理数组可能会导致一些混淆和潜在的错误，因为 std::shared_ptr 的类型表示它管理的是单个对象。

为了更清晰地表达您的意图并避免潜在的错误，您应该使用 std::shared_ptr<char[]> 而不是 std::shared_ptr<char>。这样，类型就正确地表示了您正在管理一个数组，并且您不需要提供自定义删除器，因为 std::shared_ptr<char[]> 默认会使用 delete[] 来释放内存。

下面是修改后的代码：

#include <iostream>
#include <memory>
#include <cstring>

int main() {
    // 动态分配一块内存并初始化
    char* raw_ptr = new char[20];
    std::strcpy(raw_ptr, "Hello, World!");

    // 将 raw_ptr 转换为 std::shared_ptr<char[]>，不需要自定义删除器
    std::shared_ptr<char[]> smart_ptr(raw_ptr);

    // 使用智能指针访问数据
    std::cout << "Message: " << smart_ptr.get() << std::endl;

    // 修改内存中的数据（注意：不要超出原始分配的大小）
    std::strcpy(smart_ptr.get(), "Hello, C++!");
    std::cout << "Updated Message: " << smart_ptr.get() << std::endl;

    // 智能指针在超出作用域时会自动释放内存
    return 0;
}

在这个修改后的代码中，std::shared_ptr<char[]> 正确地表示了您正在管理一个 char 数组，并且会在适当的时候使用 delete[] 来释放内存。这样，您的代码就更加清晰和正确了。

3.关于智能指针，如果我处理char[]的内容，如果不自定义删除器，会怎么样呢

如果您使用 std::shared_ptr<char> 来管理一个 char[]（即字符数组），并且没有提供一个自定义的删除器，那么当 std::shared_ptr 的最后一个实例被销毁时，它将尝试使用 delete 而不是 delete[] 来释放内存。这是因为 std::shared_ptr<char> 被设计为管理单个 char 对象，而不是字符数组。

使用 delete 释放由 new[] 分配的内存（即字符数组）是未定义行为，这可能导致内存泄漏、程序崩溃或其他不可预测的问题。这是因为 new[] 和 delete[] 是成对使用的，它们负责分配和释放数组类型的内存，而 new 和 delete 则是用于单个对象的。

因此，如果您要管理一个 char[]，您应该使用 std::shared_ptr<char[]> 而不是 std::shared_ptr<char>。std::shared_ptr<char[]> 会在其最后一个实例被销毁时自动使用 delete[] 来释放内存，这样就不需要您提供自定义删除器了。

总结一下，如果您不自定义删除器，并且使用 std::shared_ptr<char> 来管理 char[]，那么当智能指针销毁时，它将使用错误的删除方式（delete 而不是 delete[]），这可能导致未定义行为。为了避免这个问题，您应该使用 std::shared_ptr<char[]>。