C++11 智能指针unique_ptr使用 -- 以排序二叉树为例

用智能指针可以简化内存管理。以树为例,如果用普通指针,通常是在插入新节点时用new,在析构函数中调用delete;但有了unique_ptr类型的智能指针,就不需要在析构函数中delete了,因为当unique_ptr类型的指针P生命结束时(比如对于局部变量,程序执行到局部变量的作用域范围之外),P会自动delete它拥有的资源(指针指向的空间)。对于shared_ptr,情况更加复杂一些,shared_ptr会维护一个use count,即有多少个指针共享这一资源,当use count为0时,资源被自动释放。

有一篇wiki专门解释了这种模式(将资源的获取与释放与对象的生命周期绑定),http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization

这篇文章主要关注unique_ptr,如果不熟悉,可以先读一下这个:http://www.cplusplus.com/reference/memory/unique_ptr/

这里用排序二叉树的简单实现来展示如何使用unique_ptr,我们只实现插入一个int,以及中序遍历输出所有数字的功能,这已经足以解释unique_ptr的使用方法(其实是,我不太会写二叉树的平衡- -)

TreeNode代表一个树节点,包括一个int值,和指向左右子树的智能指针。我们在TreeNode和BST里都实现了insert(int)和inOrder(),BST中的方法基本上是调用TreeNode的对应方法(BST的方法只是一个wrapper,真正干活的是TreeNode里的对应方法)

#include <cstdio>
#include <iostream>
#include <sstream>
#include <string>
#include <memory>
using namespace std;
class TreeNode{
    public:
    unique_ptr<TreeNode> left;
    unique_ptr<TreeNode> right;
    int val;
    TreeNode(){}
    TreeNode(int value): val(value){}
    void insert(int value){
        if (value <= val) {
            if (left) {
                left->insert(value);
            } else {
                left.reset(new TreeNode(value));
            }
        } else {
            if (right) {
                right->insert(value);
            } else {
                right.reset(new TreeNode(value));
            }
        }
    }
    void inOrder(stringstream& ss){
        if (left){
            left->inOrder(ss);
        }
        ss << val << " ";
        if (right) {
            right->inOrder(ss);
        }
    }
};
class BST {
public:
    BST ();
    virtual ~BST ();
    void insert(int value);
    string inOrder();
private:
    unique_ptr<TreeNode> root;
};
BST::BST(){}
BST::~BST(){}
void BST::insert(int value){
    if(root){
        root->insert(value);
    } else {
        root.reset(new TreeNode(value));
    }
}
string BST::inOrder(){
    if (root) {
        stringstream ss;
        root->inOrder(ss);
        return ss.str();
    } else {
        return "";
    }

}
int main(int argc, const char *argv[])
{
    BST bst;
    bst.insert(4);
    bst.insert(5);
    bst.insert(2);
    bst.insert(1);
    cout << bst.inOrder() << endl;
    return 0;
}

有人提到可能要把TreeNode指定为NonCopyable,见http://stackoverflow.com/questions/6679482/smart-pointers-for-modelling-a-general-tree-structure-its-iterators,挺有道理的,这个实现不算复杂,可以参考http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Non-copyable_Mixin

时间: 2024-10-07 04:18:15

C++11 智能指针unique_ptr使用 -- 以排序二叉树为例的相关文章

c++11 智能指针 unique_ptr、shared_ptr与weak_ptr

c++11 智能指针 unique_ptr.shared_ptr与weak_ptr C++11中有unique_ptr.shared_ptr与weak_ptr等智能指针(smart pointer),定义在<memory>中. 可以对动态资源进行管理,保证任何情况下,已构造的对象最终会销毁,即它的析构函数最终会被调用. unique_ptr unique_ptr持有对对象的独有权,同一时刻只能有一个unique_ptr指向给定对象(通过禁止拷贝语义.只有移动语义来实现). unique_ptr

C++智能指针 unique_ptr

C++智能指针 unique_ptr unique_ptr 独占所指向的对象, 同一时刻只能有一个 unique_ptr 指向给定对象(通过禁止拷贝语义, 只有移动语义来实现), 定义于 memory (非memory.h)中, 命名空间为 std. 标准库早期版本中定义了 auto_ptr, 它具有 unique_ptr 的部分特征, 但不是全部, 例如, 不能在容器中保存 auto_ptr, 也不能从函数中返回 auto_ptr. 基于这些原因, 应该尽量使用 unique_ptr, 而不是

详解C++11智能指针

前言 C++里面的四个智能指针: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中后三个是C++11支持,并且第一个已经被C++11弃用. C++11智能指针介绍 智能指针主要用于管理在堆上分配的内存,它将普通的指针封装为一个栈对象.当栈对象的生存周期结束后,会在析构函数中释放掉申请的内存,从而防止内存泄漏.C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法,记录当前内存资源被多少个智能指针引用.该引用计数的内存在堆上分配.当新

实战c++中的智能指针unique_ptr系列-- 使用std::unique_ptr代替new operator(错误:‘unique_ptr’ is not a member of ‘std’)

写了很多篇关于vector的博客,其实vector很便捷,也很简单.但是很多易错的问题都是vector中的元素为智能指针所引起的.所以决定开始写一写关于智能指针的故事,尤其是unique_ptr指针的故事. 这是个开始,就让我们使用std::unique_ptr代替new operator吧! 还是用程序说话: #include<iostream> int main() { while (true) int *x = new int; } 看下任务管理器中的内存: 此时使用智能指针unique

C++11智能指针

C成也指针,败也指针.确实,指针给程序员提供了很多便利和灵活性,但是不当的指针使用也会造成很多问题. Java和C#避免了指针(虽然C#中也能使用指针,但是估计很少有人这样做),其垃圾回收机制,给程序员减轻很多管理内存的负担. 为了带来指针更好的使用体验,C++中引入了智能指针的概念,其实质就是将指针的一些操作封装成类,程序员通过使用熟悉的指针运算符(-> 和 *)访问封装指针,该指针类通过运算符重载返回封装的原始指针. C++ 智能指针思路类似于C#等语言中创建对象的过程:创建对象后让系统负责

c++11 智能指针

如果在程序中使用new从堆(自由存储区)分配内存,等到不需要时, 应使用delete将其释放.c++引入了智能指针auto_ptr, 以帮助自动完成这个过程. c++11摒弃了auto_ptr,并新增了三种智能指针:unique_ptr, shared_ptr, weak_ptr. 一. auto_ptr, unique_ptr , shared_ptr 头文件:  #include <memory> 用法:  auto_ptr<double>  A(new double); un

C/C++ C++11智能指针

在使用基本指针类型时,因为要手动释放指针指向的内存,常常容易造成内存泄漏,特别是异常分支很多的情况下.而智能指针类型就是将基本指针类型封装成模板类,以便更好地管理内存. 智能指针都包含一个explicit构造函数,因此基本指针类型不能隐式转换成智能指针,需要显式调用. shared_ptr<double> sp_d; double *p_d = new double; sp_d = p_d; // 错误,隐式转换. sp_d = shared_ptr<double>(p_d); /

实战c++中的智能指针unique_ptr系列-- unique_ptr的operator=、operator bool、reset、swap、get等介绍

既然打算把unique_ptr写一个系列,就要详尽一点,有些内容也许在vector的时候有个涉及,但是现在还是再谈论一番. 我们要把unique_ptr看做一个类,废话了,它当然是一个类.所以这个类肯定也重载了赋值运算符,即operator=.现在就开始看看operator=在unique_ptr中的使用: 官方描述如下: move assignment (1) unique_ptr& operator= (unique_ptr&& x) noexcept; assign null

一次测试测试(C++11)智能指针引用的崩溃结论

项目中用到了智能指针,但是要在智能指针指向的类中获取此类的shared_ptr指针传给其引用的类,结果出现了问题, 测试代码如下: (包括错误解释) 1 //测试 shared_ptr weak_ptr map<string,shared_ptr> 2 #include <stdio.h> //pinrtf ... 3 #include <string> //string ... 4 #include <map> 5 #include <memory&