一文让你成为c 指针大师，掌握智能指针神器！-ag真人游戏

构造函数，以影响智能指针的内存分配策略。

以下是一个简单的例子，演示了如何将自定义内存分配器传递给std::unique_ptr。在这个例子中，我们使用了一个简单的内存池来提高内存分配效率。请注意，这个例子仅供参考，实际情况可能要更加复杂，具体实现取决于实际需求。

struct memorypool {
    std::vector data;
    void* alloc(size_t size) {
        void* p = malloc(size);
        data.push_back(p);
        return p;
    }
    ~memorypool() {
        for (auto p : data)
            free(p);
    }
};
memorypool pool;
void* operator new(size_t size) {
    return pool.alloc(size);
}
 
void operator delete(void* p) noexcept {
    /* no-op */
}
int main()
{
    std::unique_ptr 
         uptr(new int(42), &operator delete);
    
    return 0;
}

在这个例子中，我们使用了memorypool作为自定义内存分配器。对于所有的operator new(size_t size)调用，memorypool::alloc()方法将被调用来申请内存。在operator delete(void* p) noexcept中，我们仅仅是使用一个空操作。这意味着，当智能指针使用这个分配器时，我们需要手动释放所有的内存，由于我们在程序结束时使用了一个全局内存池来管理内存，所以只需要在程序结束时释放内存即可。

注意：在实际应用中使用自定义内存分配器时，我们需要注意几点：

1. 内存分配器必须是线程安全的。
2. 内存分配器必须符合c 的内存分配规则，不能违反标准库的接口。
3. 内存分配器必须保证内存在反初始化时能够被释放。

3.3 示例代码

完整的示例代码如下。请注意，这个例子仅仅是为了演示如何使用自定义删除器和自定义内存分配器，实际情况可能要根据不同的场景进行调整。

#include 
#include 
#include 
// 自定义删除器
struct mydata {
   int a;
   char* b;
   mydata(int _a, char* _b) : a(_a), b(_b) {}
   ~mydata() { delete[] b; }
};
// 自定义删除器演示代码
void demo_deleter() {
    char* str = new char[100];
    // 使用lambda表达式作为删除器
    std::shared_ptr sptr(new mydata(10, str), [](mydata* ptr){ 
        std::cout << "deleting mydata with a=" << ptr->a << std::endl;
        delete ptr; 
    });
}
// 自定义内存分配器
struct memorypool {
    std::vector data;
    void* alloc(size_t size) {
        void* p = malloc(size);
        data.push_back(p);
        return p;
    }
    ~memorypool() {
        for (auto p : data)
            free(p);
    }
};
memorypool pool;
// 重载operator new和operator delete
void* operator new(size_t size) {
    return pool.alloc(size);
}
 
void operator delete(void* p) noexcept {
    /* no-op */
}
// 自定义内存分配器演示代码
void demo_allocator() {
    // 使用自定义内存分配器
    std::unique_ptr 
         uptr(new int(42), &operator delete);
}
int main() {
    demo_deleter();
    demo_allocator();
    return 0;
}

4. 智能指针的最佳实践

在c 中，智能指针是资源管理的重要工具，它们可以自动管理动态分配的内存，减少内存泄漏和悬挂指针的风险。理解何时使用哪种智能指针以及它们的性能特征是有效利用智能指针的关键。以下内容将详细探讨智能指针的最佳实践。

4.1 何时选择哪种智能指针

在c 中，主要有三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。选择合适的智能指针类型对于实现高效和可维护的代码至关重要。

4.1.1 std::unique_ptr vs. std::shared_ptr

• std::unique_ptr

  std::unique_ptr是最轻量级的智能指针，它独占一个资源。资源的所有权不能被复制或共享，因此std::unique_ptr不能被拷贝，只能被移动。这种设计确保了唯一的所有权和资源的释放是自动的。std::unique_ptr适合以下场景：

  • 资源的唯一所有权：当你确定一个资源只应该有一个所有者时，使用std::unique_ptr是最佳选择。
  • 高性能要求：由于std::unique_ptr没有引用计数开销，它提供了更好的性能。
  • 不需要共享：如果没有其他对象需要访问同一个资源，使用std::unique_ptr能更好地管理资源。

  示例代码：

  #include 
  #include 
  class myclass {
      
  public:
      myclass() {
       std::cout << "myclass created\n"; }
      ~myclass() {
       std::cout << "myclass destroyed\n"; }
  };
  void useuniqueptr() {
      
      std::unique_ptr ptr1 = std::make_unique();
      // std::unique_ptr ptr2 = ptr1; // 编译错误，不能拷贝
      std::unique_ptr ptr2 = std::move(ptr1); // 正确，所有权转移
  }
  

• std::shared_ptr

  std::shared_ptr是一个引用计数智能指针，它允许多个shared_ptr对象共同拥有同一个资源。当最后一个shared_ptr对象被销毁时，资源会被释放。std::shared_ptr适合以下场景：

  • 资源的共享所有权：当资源需要被多个对象共享时，使用std::shared_ptr可以方便管理。
  • 复杂的对象图：例如，树形结构或图形结构中的节点之间可能需要共享资源。
  • 跨函数传递：如果多个函数需要访问同一个资源，std::shared_ptr可以有效管理资源的生命周期。

  示例代码：

  #include 
  #include 
  class myclass {
      
  public:
      myclass() {
       std::cout << "myclass created\n"; }
      ~myclass() {
       std::cout << "myclass destroyed\n"; }
  };
  void usesharedptr() {
      
      std::shared_ptr ptr1 = std::make_shared();
      std::shared_ptr ptr2 = ptr1; // 共享所有权
      std::cout << "use count: " << ptr1.use_count() << "\n"; // 输出: 2
  }
  

4.1.2 避免使用裸指针

在现代c 中，建议尽可能避免使用裸指针，除非它们在特殊情况下是必要的。裸指针易于导致内存泄漏和悬挂指针等问题。智能指针提供了更安全和自动化的内存管理。

• 裸指针的缺点：

  • 内存泄漏：如果忘记释放内存，将会导致内存泄漏。
  • 悬挂指针：指向已释放内存的指针可能导致程序崩溃或未定义行为。
  • 手动管理：需要手动编写内存释放代码，增加了出错的可能性。

• 智能指针的优势：

  • 自动释放：智能指针在作用域结束时自动释放内存。
  • 所有权管理：智能指针明确管理资源的所有权和生命周期。

示例代码：

#include 
#include 
void userawpointer() {
  
    int* rawptr = new int(10);
    std::cout << "value: " << *rawptr << "\n";
    delete rawptr; // 必须手动释放内存
}
void usesmartpointer() {
  
    std::unique_ptr smartptr = std::make_unique(10);
    std::cout << "value: " << *smartptr << "\n";
    // 内存自动释放，无需手动调用 delete
}

4.2 性能考虑

选择智能指针时，需要考虑性能方面的因素。尽管智能指针可以简化内存管理，但它们也有一定的性能开销。理解这些开销可以帮助我们优化代码，确保高效使用智能指针。

4.2.1 智能指针的开销

• std::unique_ptr：

  • 开销：开销最小，仅包含一个指向资源的指针，没有引用计数。由于没有管理开销，它在性能上优于其他类型的智能指针。
  • 适用场景：适用于需要高性能的场景，如高频次的对象创建和销毁。

• std::shared_ptr：

  • 开销：相对于std::unique_ptr，std::shared_ptr开销更大。它需要维护一个引用计数，用于跟踪资源的所有者数量。引用计数的维护会引入额外的开销。
  • 适用场景：适用于资源共享的场景，如多线程环境中，或者多个对象需要访问同一个资源。

• std::weak_ptr：

  • 开销：std::weak_ptr的开销相对较小，它并不直接管理资源，而是对std::shared_ptr的引用计数进行观察。它不会增加引用计数，因此不会影响std::shared_ptr的生命周期。
  • 适用场景：用于避免循环引用或观察资源状态，但不需要管理资源的生命周期。

4.2.2 高效使用智能指针

• 避免不必要的拷贝：在需要传递智能指针时，优先使用std::move而不是拷贝操作。特别是对于std::unique_ptr，拷贝是不可行的，必须使用移动语义。

  示例代码：

  #include 
  #include 
  void processuniqueptr(std::unique_ptr ptr) {
      
      std::cout << "processing value: " << *ptr << "\n";
  }
  void useuniqueptr() {
      
      std::unique_ptr ptr = std::make_unique(42);
      processuniqueptr(std::move(ptr)); // 转移所有权，避免拷贝
  }
  

• 避免循环引用：在使用std::shared_ptr时，要特别注意避免循环引用，这会导致内存泄漏。使用std::weak_ptr打破循环引用是一个有效的ag真人游戏的解决方案。

  示例代码：

  #include 
  #include 
  class b; // 前向声明
  class a {
      
  public:
      std::shared_ptr bptr;
  };
  class b {
      
  public:
      std::weak_ptr