首页 / C++ / C++智能指针 unique_ptr

C++智能指针 unique_ptr

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++智能指针 unique_ptr，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6748字，纯文字阅读大概需要10分钟。

内容图文

C++智能指针 unique_ptr

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

基本用法:

std::unique_ptr<A> up1;
up1.reset(new A(3));
std::unique_ptr<A> up2(new A(4));

A* p = up2.release();
delete p;

std::unique_ptr<A> up3(new A(11));
std::unique_ptr<A> up4 = std::move(up3);
up4 = nullptr;//显式销毁所指对象，同时智能指针变为空指针。与u_s2.reset()等价

成员函数

(1) get 获得内部对象的指针, 由于已经重载了()方法, 因此和直接使用对象是一样的.如 unique_ptr<int> sp(new int(1)); sp 与 sp.get()是等价的
(2) release 放弃内部对象的所有权，将内部指针置为空, 返回所内部对象的指针, 此指针需要手动释放
(3) reset 销毁内部对象并接受新的对象的所有权(如果使用缺省参数的话，也就是没有任何对象的所有权, 此时仅将内部对象释放, 并置为空)
(4) swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
std::move(up) 所有权转移(通过移动语义), up所有权转移后，变成“空指针” (up 的定义为 std::unique_ptr<Ty> up)

unique_ptr 不支持拷贝和赋值.
　　std::unique_ptr<A> up1(new A(5));
　　std::unique_ptr<A> up2(up1); // 错误, unique_ptr 不支持拷贝
　　std::unique_ptr<A> up2 = up1; // 错误, unique_ptr 不支持赋值

虽然 unique_ptr 不支持拷贝和赋值, 但是我们可以调用 release 或 reset 将指针的所有权从一个(非 const) unique_ptr 转移到另一个.
　　std::unique_ptr<int> up1(new int(1));
　　std::unique_ptr<int> up2(up1.release());

虽然 unique_ptr 不支持拷贝, 但是可以从函数中返回, 甚至返回局部对象. 如下面的代码, 编译器知道要返回的对象即将被销毁, 因此执行一种特殊的"拷贝":
　　template <class Ty>
　　std::unique_ptr<Ty> Clone(const Ty& obj)
　　{
　　　　return std::unique_ptr<Ty>(new Ty(obj));
　　}

　　template <class Ty>
　　std::unique_ptr<Ty> Clone(const Ty& obj)
　　{
　　　　std::unique_ptr<Ty> temp = std::unique_ptr<Ty>(new Ty(obj));
　　　　return temp;
　　}

unique_ptr 支持管理数组

std::unique_ptr<A[]> ups(new A[10]);
printf("sizeof(ups) = %d\n", sizeof(ups));
for (int i = 0; i < 10; i++)
{
　　ups[i] = i;
　　printf("ups[i] = %d\n", ups[i]);
}

自定义删除器

　　重载一个 unique_ptr 的删除器会影响到 unique_ptr 类型以及如何构造该类的对象, 必须在尖括号中指定删除器类型. 然后在创建或 reset 时提供删除器对象.
　　　　unique_ptr<T, D> up;
　　可以使用 decltype 来指明函数指针的类型.

            class
             CConnnect
            {
                
            void
             Disconnect() { PRINT_FUN(); }
            };

            
            void Deleter(CConnnect* obj)
            {
                obj->Disconnect(); // 做其它释放或断开连接等工作delete obj; // 删除对象指针            }
            
            std::unique_ptr<CConnnect, decltype(Deleter)*> up(new CConnnect, Deleter);

　　另一种用法:

            class
             Deleter
            {
            
            public
            :
                
            void
            operator() (CConnnect* obj)
                {
                    PRINT_FUN();
                    delete obj;
                }
            };

            std::unique_ptr<CConnnect, Deleter> up1(new CConnnect);
            
            std::unique_ptr<CConnnect, Deleter> up2(new CConnnect, up1.get_deleter());

VC中的源码实现

template<class _Ty,
class _Dx>    // = default_delete<_Ty>class unique_ptr
    : public _Unique_ptr_base<_Ty, _Dx,
    tr1::is_empty<_Dx>::value
    || tr1::is_same<default_delete<_Ty>, _Dx>::value>
{    // non-copyable pointer to an objectpublic:
    typedef unique_ptr<_Ty, _Dx> _Myt;
    typedef _Unique_ptr_base<_Ty, _Dx,
        tr1::is_empty<_Dx>::value
        || tr1::is_same<default_delete<_Ty>, _Dx>::value> _Mybase;
    typedef typename _Mybase::pointer pointer;
    typedef _Ty element_type;
    typedef _Dx deleter_type;

    unique_ptr()
        : _Mybase(pointer(), _Dx())
    {    // default construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
    }

#if defined(_NATIVE_NULLPTR_SUPPORTED)     && !defined(_DO_NOT_USE_NULLPTR_IN_STL)
    unique_ptr(_STD nullptr_t)
        : _Mybase(pointer(), _Dx())
    {    // null pointer construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
    }

    _Myt& operator=(_STD nullptr_t)
    {    // assign a null pointer        reset();
        return (*this);
    }
#endif /* defined(_NATIVE_NULLPTR_SUPPORTED) etc. */

    explicit unique_ptr(pointer _Ptr)
        : _Mybase(_Ptr, _Dx())
    {    // construct with pointer
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
    }

    unique_ptr(pointer _Ptr,
        typename _If<tr1::is_reference<_Dx>::value, _Dx,
        const typename tr1::remove_reference<_Dx>::type&>::_Type _Dt)
        : _Mybase(_Ptr, _Dt)
    {    // construct with pointer and (maybe const) deleter&    }

    unique_ptr(pointer _Ptr, typename tr1::remove_reference<_Dx>::type&& _Dt)
        : _Mybase(_Ptr, _STD move(_Dt))
    {    // construct by moving deleter
        //        static_assert(!tr1::is_reference<_Dx>::value,
        //            "unique_ptr constructed with reference to rvalue deleter");    }

    unique_ptr(unique_ptr&& _Right)
        : _Mybase(_Right.release(),
        _STD forward<_Dx>(_Right.get_deleter()))
    {    // construct by moving _Right    }

    template<class _Ty2,
    class _Dx2>
        unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right)
        : _Mybase(_Right.release(),
        _STD forward<_Dx2>(_Right.get_deleter()))
    {    // construct by moving _Right    }

    template<class _Ty2,
    class _Dx2>
        _Myt& operator=(unique_ptr<_Ty2, _Dx2>&& _Right)
    {    // assign by moving _Right        reset(_Right.release());
        this->get_deleter() = _STD move(_Right.get_deleter());
        return (*this);
    }

    _Myt& operator=(_Myt&& _Right)
    {    // assign by moving _Rightif (this != &_Right)
        {    // different, do the move            reset(_Right.release());
            this->get_deleter() = _STD move(_Right.get_deleter());
        }
        return (*this);
    }

    void swap(_Myt&& _Right)
    {    // swap elementsif (this != &_Right)
        {    // different, do the swap
            _Swap_adl(this->_Myptr, _Right._Myptr);
            _Swap_adl(this->get_deleter(),
                _Right.get_deleter());
        }
    }

    void swap(_Myt& _Right)
    {    // swap elements
        _Swap_adl(this->_Myptr, _Right._Myptr);
        _Swap_adl(this->get_deleter(),
            _Right.get_deleter());
    }

    ~unique_ptr()
    {    // destroy the object        _Delete();
    }

    typename tr1::add_reference<_Ty>::type operator*() const
    {    // return reference to objectreturn (*this->_Myptr);
    }

    pointer operator->() const
    {    // return pointer to class objectreturn (&**this);
    }

    pointer get() const
    {    // return pointer to objectreturn (this->_Myptr);
    }

    _OPERATOR_BOOL() const
    {    // test for non-null pointerreturn (this->_Myptr != pointer() ? _CONVERTIBLE_TO_TRUE : 0);
    }

    pointer release()
    {    // yield ownership of pointer
        pointer _Ans = this->_Myptr;
        this->_Myptr = pointer();
        return (_Ans);
    }

    void reset(pointer _Ptr = pointer())
    {    // establish new pointerif (_Ptr != this->_Myptr)
        {    // different pointer, delete old and reassign            _Delete();
            this->_Myptr = _Ptr;
        }
    }

private:
    void _Delete()
    {    // delete the pointerif (this->_Myptr != pointer())
            this->get_deleter()(this->_Myptr);
    }

    unique_ptr(const _Myt&);    // not defined
    template<class _Ty2,
    class _Dx2>
        unique_ptr(const unique_ptr<_Ty2, _Dx2>&);    // not defined
    _Myt& operator=(const _Myt&);    // not defined
    template<class _Ty2,
    class _Dx2>
        _Myt& operator=(const unique_ptr<_Ty2, _Dx2>&);    // not defined
};

原文：http://www.cnblogs.com/diysoul/p/5930388.html

内容总结

以上是互联网集市为您收集整理的C++智能指针 unique_ptr全部内容，希望文章能够帮你解决C++智能指针 unique_ptr所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1100814.html

来源：【匿名】

【上一篇】c++对象模型研究3：数据【下一篇】c++有个库什么的吗?

更多 ►

【C++智能指针 unique_ptr】教程文章相关的互联网学习教程文章

第一周从C走进C++ 001 函数指针【代码】【图】

1. 基本概念：　　程序运行期间，每个函数都会占用一段连续的内存空间。而函数名就是该函数所占内存区域的起始地址(也称“入口地址”)。我们可以将函数的入口地址赋给一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以调用这个函数。这种指向函数的指针变量称为“函数指针”。 2. 定义形式　　类型名 (* 指针变量名)(参数类型1, 参数类型2,…); 　　例如：　　　　int (*pf)(int ,char); 表示pf是一个函数指针，它所...

C++ 函数指针【代码】

我们都知道，数组名就是指向数组第一个元素的常量指针。同理，对于一个函数而言，函数名也是指向函数第一条指令的常量指针。而编译器要做的就是在程序编译之后，为每个函数分配一个首地址，即该函数第一条指令的地址。一般情况下，我们可以用一个指针来保存这个地址，而这个指针就是函数指针，该指针可以看作是它指向函数的别名，所以我们可以用该指针来调用这个函数。=========================函数指针的声明方法===============...

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_ptrunique_ptr持有对对象的独有权，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。unique_ptr指针本身的生命周期：从unique_ptr指针创建时...

C++——指针---指向数组的指针---指向字符串的指针--指向函数的指针--指针的指针--指针的引用【代码】

一、指向数组的指针代码示例1： 1int main() 2{ 3int a[10]={0,2,4,6,8,10,12,14,16,18}; 4int *p; 5for(p=&a[0];p<&a[0]+10;p++) 6 printf("%d ",*p); 7 }代码示例2： int a[10]={0,2,4,6,8,10,12,14,16,18}; int *p; p=a; printf("%d\n",*(a+5));//注意加括号，否则就是输出“a指向的值加5”了int sum(int *a,int n) {int ans=0;for(int i=1;i<=n;i++)ans+=a[i];return ans; } 二、指向字符串的指针示例代码： 1char *ps...

为什么c++中函数指针是16字节【代码】

原文链接当我们讨论指针时，通常假设它是一种可以用 void * 指针来表示的东西，在 x86_64 平台下是 8 个字节大小。例如，下面是来自维基百科中关于 x86_64 的文章的摘录：Pushes and pops on the stack are always in 8-byte strides, and pointers are 8 bytes wide. 从 CPU 的角度来看，指针无非就是内存的地址，所有的内存地址在 x86_64 平台下都是由 64 位来表示，所以假设它是 8 个字节是正确的。通过简单输出不同类型指针的...

C++基础之指针与引用的底层实现

一句话总结指针分配内存，有地址（编译器和程序员看来），属于一个类型变量，支持取地址与解引用操作。引用分配内存，有地址（编译器看来），相当于一个变量别名，不支持取地址与解引用操作（即不可获取其本身地址），声明即必须初始化，不可变更引用对象，本质上是“pointer const”。推荐阅读快速理解：简谈 C++ 中指针与引用的底层实现原文：https://www.cnblogs.com/MinPage/p/14662084.html

浅谈C/C++引用和指针的联系和区别【代码】【图】

为什么C/C++语言使用指针？答案：①一方面，每一种编程语言都使用指针。不止C/C++使用指针。每一种编程语言都使用指针。C++将指针暴露给了用户(程序员)，而Java和C#等语言则将指针隐藏起来了。“Everything uses pointers. C++ just exposes them rather than hiding them,” It‘s easier to give someone an address to your home than to give a copy of your home to everyone.②另一方面使用指针的优点和必要性：指针能够有效...

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：不存在空引用。引用必须连接到一块合法的内存。一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。引用必须在创建时被初始化。指针可以在任何时间被初始化。原文：https://www.cnblogs.com/0patrick/p/13121415.html

c++入门之初话指针【代码】

先上代码：再进行总结知识： 1 # include "iostream" 2struct ant_year_end3{4int year;5};6 7int main()8{9usingnamespace std; 10 ant_year_end s1, s2, s3; 11 s1.year = 1998; 12 ant_year_end *point = &s2; 13 point->year = 1999; 14 ant_year_end trio[3]; 15 trio[0].year = 2003; 16 cout << trio->year << endl; 17const ant_year_end*arp[3] = { &s1, &s2, &s3 }; 18 cout << arp[1]->...

c++中的const与指针

const修饰符使用const修饰变量时，该变量的值不可修改，因此需要初始化。例如 const int s = 0；此时s为值不可变的变量。那么基于此，当const修饰指针时的情况有三种：（1）const int *p；此时const修饰的是 *p 而非 p，因此，*p的值不可变，而p的值是可变的，所以可不对p进行初始化。例如，int s = 0,t = 1;const int *p;p = &s;cout<<*p<<endl;p = &t;cout<<*p<<endl;以上代码输出：01但此时，无论p指向s或者t，均不能通过 *p 修...

温故而知新 C++ 数组与指针【代码】【图】

#include <stdio.h>usingnamespace std;int main(int argc, _TCHAR* argv[]) {int a[5];int b[4] = {1,2,3,4};char c[] = "1234";int *d= newint[4];*d = 1;*(d+1) = 2;*(d+2) = 3;*(d+3) = 4;printf("a length = %d\n",sizeof(a));printf("b length = %d\n",sizeof(b));printf("c length = %d\n",sizeof(c));printf("d length = %d\n",sizeof(d));delete d;d = nullptr;system("pause");return0; }数组的初始化方式，可以用以上几...

C++笔记--指针和引用【代码】【图】

面试一：指针与引用的区别？答案：（1）非空区别。在任何情况下都不能使用指向空值的引用。因此如果你使用一个变量并让它指向一个对象，但是该变量在某些时候也可能不指向任何对象，这时你应该把变量声明为指针，因为这样你可以赋空值给该变量。相反，如果变量肯定指向一个对象，例如你的设计不允许变量为空，这时你就可以把变量声明为引用。不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针要高。（2）合法性区别...

C++11 智能指针【代码】

【1】C++11智能指针应用示例如下： 1 #include <iostream>2 #include <memory>3usingnamespace std;4 5void test_unique_ptr()6{7 unique_ptr<int> up1(newint(2020)); // 无法复制的unique_ptr8// unique_ptr<int> up2 = up1; // 不能通过编译 9 cout << (*up1) << endl; // 202010 unique_ptr<int> up3 = move(up1); // 现在up3是数据唯一的unique_ptr智能指针11 cout << (*up3)...

C++中数组和指针的区别【代码】

刚接触指针的时候，你很可能会觉得：数组和指针基本上是同一个东西。的确，数组和指针都可以用*取值，都可以加减某个数获得别的指针，都可以用[]来取值……例如下面的代码：int arr[5] = {2, 3, 5, 7, 9}; //定义一个数组，长度为5 int* arr_ptr = arr; //定义一个指针指向数组arrcout << "*arr = " << *arr << "\t*(arr + 3) = " << *(arr + 3) << "\t\tarr[3] = " << arr[3] << endl; cout << "*arr_ptr = " << *arr_ptr << "\t*...

C++编程基础一 17-指针和数组【代码】

1// 17-指针和数组.cpp: 定义控制台应用程序的入口点。2//3 4 #include "stdafx.h" 5 #include <iostream>6 #include <climits>7 8usingnamespace std;910int main() 11{ 12int a[]{345,65,23,7,2,856,23,83,176}; 13 cout << a << endl;//输出数组的时候也输出一串地址，输出的地址是数组的第一个元素的地址。在C++中数组也是指针。 14//如果数组a是指针，那么可以同个*a查看指针的值，应该就是345。15 cout << *a << en...

首页 / C++ / C++智能指针 unique_ptr

C++智能指针 unique_ptr

内容导读

内容图文

C++智能指针 unique_ptr

成员函数

unique_ptr 支持管理数组

自定义删除器

内容总结

内容备注

内容手机端

【C++智能指针 unique_ptr】教程文章相关的互联网学习教程文章

指针 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程