c++系列 —— 智能指针auto_ptr和unique_ptr

最新推荐文章于 2024-04-21 17:40:04 发布
最新推荐文章于 2024-04-21 17:40:04 发布
阅读量2.4k 收藏 8
点赞数 2
分类专栏： 从0开撸C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37620587/article/details/125477366
版权

往期地址：

本期主题：
智能指针

智能指针

1.智能指针概述

1.解决了什么问题，智能在哪里

智能指针解决的问题：

解决了内存泄漏的问题，对于申请在堆上的内存（c语言是malloc，c++是new），程序员不需要主动释放，智能指针自动释放

2.对智能指针的原理猜想

  1. 我们都知道栈上的内存能够自动释放，所以猜测智能指针的底层应该是类似于栈的方式
  2. 栈上的变量，创建时自动调用构造函数，退出时自动调用析构函数

按照这样的方式我们来写一份测试代码：

#include <iostream>
using namespace std;
//构造函数申请内存,析构函数释放
class smart_pointer
{
public:
    smart_pointer()
    {
        cout << "smart_pointer()" << endl;
        p = NULL;
    }

    smart_pointer(int size)
    {
        cout << "smart_pointer(int size)" << endl;
        p = new int[size];
    }

    ~smart_pointer()
    {
        cout << "~smart_pointer()" << endl;

        if (NULL != p)
            delete[] p;
    }

    void test_func()
    {
        if (p != NULL) {
            p[0] = 1;
            cout << "p[0] val is " << p[0] << endl;
        }
    }

private:
    int *p;

};

int main(void)
{
    //这里选择栈上的局部变量,这样就能够自动调用构造和析构函数
    smart_pointer sp_instance(3);
    sp_instance.test_func();

    return 0;
}

运行结果：
在这里插入图片描述

2.智能指针使用

详细内容可以参考cppreference的动态内存管理章节中，cpprefernce动态内存管理

2.1 auto_ptr

auto_ptr定义：

template< class T > class auto_ptr;

使用示例：

#include <iostream>
#include <memory>
class people
{
public:
    people() {
        cout << "people()" << endl;
    }

    people(string name) {
        this->name = name;
        cout << "people(string name)" << endl;
    }

    ~people() {
        cout << "~people()" << endl;
    }

    void print_name(void)
    {
        cout << "name: " << this->name << endl;
    }
private:
    string name;

};

int main(void)
{
    //p1是people对象的智能指针
    auto_ptr<people> p1(new people("jason"));
    p1->print_name();
}

运行结果：
//这里需要使用 --std=c++98的原因是 autoptr在C++17中移除了，所以需要告诉编译器用c++98的方式去编译，不然会编译报错
在这里插入图片描述

2.2 unique_ptr

unique_ptr的定义如下：

template<
    class T,
    class Deleter = std::default_delete<T>
> class unique_ptr;

1. 构造函数使用

unique_ptr有多种构造函数，详细的描述参考cpprefernce，这里我们讲几种：

struct Foo {
	Foo() {cout << "Foo default ctor\n";}
	~Foo() {cout << "~Foo dtor\n";}
};

//删除器
struct D {
	D() {cout << "D default ctor\n";}
	D(const D&) {cout << "D copy ctor\n";}
	void operator()(Foo* p) const {
		cout << "D is deleting Foo\n";
		delete p;
	};
};

int main(void)
{
	cout << "Example constructor(1)...\n";
	unique_ptr<Foo> up1;
	unique_ptr<Foo> up1b(nullptr);
	
	cout << "Example constructor(2)...\n";
	//添加代码括号,改变up2变量的生命周期,退出括号时就释放up2
	{
		unique_ptr<Foo> up2(new Foo);
	}

	cout << "Example constructor(3)...\n";
	D d;
	{
		//d是类D的对象,up3的构造函数以d作为了参数,所以会调用D的复制构造函数
		unique_ptr<Foo, D> up3(new Foo, d);
	}
	{
		//传递的参数已经是引用了,不需要像上面一样再调用复制构造
		unique_ptr<Foo, D&> up4(new Foo, d);
	}
	
	//3个数组,构造调用3次,析构也会调用3次
	cout << "Example array constructor...\n";
	{
		unique_ptr<Foo[]> up(new Foo[3]);
	}
	return 0;
}

测试结果：

$ ./a.out 
Example constructor(1)...
Example constructor(2)...
Foo default ctor
~Foo dtor
Example constructor(3)...
D default ctor
Foo default ctor
D copy ctor
D is deleting Foo
~Foo dtor
Foo default ctor
D is deleting Foo
~Foo dtor
Example array constructor...
Foo default ctor
Foo default ctor
Foo default ctor
~Foo dtor
~Foo dtor
~Foo dtor

2. 管理器 release/reset/swap

这几个管理去都比较简单，直接看代码即可：

struct Foo {
	int val;

	Foo() {cout << "Foo default ctor\n";}
	Foo(int _val):val(_val) {cout << "Foo int val\n";}
	~Foo() {cout << "~Foo dtor\n";}
};

//删除器
struct D {
	D() {cout << "D default ctor\n";}
	D(const D&) {cout << "D copy ctor\n";}
	void operator()(Foo* p) const {
		cout << "D is deleting Foo\n";
		delete p;
	};
};

int main(void)
{
	//1.release 释放被管理对象
	cout << "Example 1, release....\n";
	//创建被管理对象的指针
	unique_ptr<Foo> up(new Foo());
	//使用release,释放被管理对象的所有权,给另外一个指针(另外一个指针并非智能指针)
	Foo *fp = up.release();
	
	assert (up.get() == nullptr);
	cout << "Foo is no longer owned by unique_ptr...\n";
	delete fp;
	
	//2.reset 替换被管理对象
	//与release的区别在于,这里会先析构掉旧的智能指针,然后创建新的
	cout << "Example 2, reset....\n";
	unique_ptr<Foo> up2(new Foo());
	
	cout << "new Foo, start reset--------\n";
	up2.reset(new Foo());
	cout << "new Foo, reset done--------\n";
	
	//3.swap,用来交换 *this和另一unique_ptr对象other所管理的内容
	//void swap(unique_ptr& other) noexcept;
	cout << "Example 3, swap....\n";
	unique_ptr<Foo> up3a(new Foo(1));
	unique_ptr<Foo> up3b(new Foo(2));
	
	up3a.swap(up3b);
	
	cout << "up3a->val:" << up3a->val << endl;
	cout << "up3b->val:" << up3b->val << endl;
	
	return 0;
}

测试结果：

Example 1, release....
Foo default ctor
Foo is no longer owned by unique_ptr...
~Foo dtor
Example 2, reset....
Foo default ctor
new Foo, start reset--------
Foo default ctor
~Foo dtor
new Foo, reset done--------
Example 3, swap....
Foo int val
Foo int val
up3a->val:2
up3b->val:1
~Foo dtor
~Foo dtor
~Foo dtor

3. 观察器 get/get_deleter/operator bool

直接看代码：

struct Foo {
	int val;

	Foo() {cout << "Foo default ctor\n";}
	Foo(int _val):val(_val) {cout << "Foo int val\n";}
	~Foo() {cout << "~Foo dtor\n";}
};

//删除器
struct D {
	void test_func(void) {
		cout << "test_func" << endl;
	};
	
	D() {cout << "D default ctor\n";}
	D(const D&) {cout << "D copy ctor\n";}
	void operator()(Foo* p) const {
		cout << "D is deleting Foo\n";
		delete p;
	};
};
int main(void)
{

	unique_ptr<string> up1(new string("hello"));
	
	string *p1 = up1.get();
	cout << *p1 << endl;

	cout << "Example 2, get_deleter ....\n";
	//2.get_deleter返回被管理对象的删除器
	unique_ptr<Foo, D> up2(new Foo, D());
	D& d = up2.get_deleter();
	d.test_func();
	
	//3.operator bool,就是将指针对象进行运算符重载,重载成一个bool量
	cout << "Example 3, operator bool ....\n";
	if ((up1) && (up2))
	{
		cout << true << endl;
	}
	
	return 0;
}

测试结果：

$ ./a.out
Example 1, get....
hello
Example 2, get_deleter ....
D default ctor
Foo default ctor
D copy ctor
test_func
Example 3, operator bool ....
1
D is deleting Foo
~Foo dtor

2.3 auto_ptr和unique_ptr对比

unique_ptr作为auto_ptr的升级版，优势具体在哪里，我们做实验来进行对比。

1.赋值运算

差异：unique_ptr比auto_ptr的赋值运算更为安全；

  • auto_ptr的赋值运算符等效于调用 reset(r.release()) ，实际上是把智能指针的所有权转移，原智能指针被release之后已经变成nullptr；
  • unique_ptr 不允许直接赋值，需要使用移动赋值；

1.autoptr例子：

//1.auto_ptr的例子,直接赋值
class people
{
public:
    people() {
        cout << "people()" << endl;
    }

    people(string name) {
        this->name = name;
        cout << "people(string name)" << endl;
    }

    ~people() {
        cout << "~people()" << endl;
    }

    void print_name(void)
    {
        cout << "name: " << this->name << endl;
    }
private:
    string name;

};

void test_func(auto_ptr<people> ptr)
{
	ptr->print_name();
}

int main(void)
{
	//1.测试1：直接使用=赋值运算符,等效于调用 reset(r.release())
    auto_ptr<people> p1(new people("jason"));
	auto_ptr<people> p2 = p1;
	
	p2->print_name();
    p1->print_name(); //这里发生了core dumped，发生coredump的原因是此时p1已经是Nullptr，被reset(nullptr)了
}

测试结果：

$ ./a.out
people(string name)
name: jason
Segmentation fault (core dumped)

2.unique_ptr例子：

struct Foo {
	int val;

	Foo() {cout << "Foo default ctor\n";}
	Foo(int _val):val(_val) {cout << "Foo int" << this->val <<endl;}
	~Foo() {cout << "~Foo dtor\n";}
	void print_val() {
		cout << "val is" << this->val << endl;
	}
};

//删除器
struct D {
	void test_func(void) {
		cout << "test_func" << endl;
	};
	
	D() {cout << "D default ctor\n";}
	D(const D&) {cout << "D copy ctor\n";}
	void operator()(Foo* p) const {
		cout << "D is deleting Foo\n";
		delete p;
	};
};
int main(void)
{
	unique_ptr<Foo> up(new Foo(4));

	// unique_ptr<Foo> up2 = up; //unique_ptr不允许直接赋值，error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = Foo; _Dp = std::default_delete<Foo>]’


	unique_ptr<Foo> up2 = move(up);
	up2->print_val();

	return 0;
}

测试结果：
在这里插入图片描述

2.作为函数参数的差异

差异：

  • auto_ptr作为函数参数时，只能传引用，而不能传值，传值会导致一次指针的赋值，导致指针变空；
  • unique_ptr作为函数参数时，既能传引用，又能传值；

1.autoptr例子：
测试代码：
使用 test_func 时，后面会发生coredump，使用 test_func_re()就可以，原因是因为传值作为参数时，会产生一个临时对象来接受参数，其实又回到第一个差异，赋值的问题。

class people
{
public:
    people() {
        cout << "people()" << endl;
    }

    people(string name) {
        this->name = name;
        cout << "people(string name)" << endl;
    }

    ~people() {
        cout << "~people()" << endl;
    }

    void print_name(void)
    {
        cout << "name: " << this->name << endl;
    }
private:
    string name;

};

void test_func(auto_ptr<people> ptr)
{
	ptr->print_name();
}

void test_func_re(auto_ptr<people>& ptr)
{
	ptr->print_name();
}

int main(void)
{
	//2.测试2：auto_ptr作为函数的参数
	auto_ptr<people> p1(new people("jason"));
	// test_func(p1); //在这里就发生了析构
	// p1->print_name(); //core dumped
	test_func_re(p1);
}

测试结果：
在这里插入图片描述
2.unique_ptr例子：

struct Foo {
	int val;

	Foo() {cout << "Foo default ctor\n";}
	Foo(int _val):val(_val) {cout << "Foo int" << this->val <<endl;}
	~Foo() {cout << "~Foo dtor\n";}
	void print_val() {
		cout << "val is" << this->val << endl;
	}
};

//删除器
struct D {
	void test_func(void) {
		cout << "test_func" << endl;
	};
	
	D() {cout << "D default ctor\n";}
	D(const D&) {cout << "D copy ctor\n";}
	void operator()(Foo* p) const {
		cout << "D is deleting Foo\n";
		delete p;
	};
};

void test_arg_func(unique_ptr<Foo> ptr)
{
	ptr->print_val();
}
int main(void)
{
	unique_ptr<Foo> up(new Foo(4));
	test_arg_func(move(up));

	return 0;
}

在这里插入图片描述

浪矢杂谈
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr
m0_49328056的博客
12-25 1089
智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr
C++智能指针：unique_ptr、shared_ptr、weak_ptr
倒地不起的土豆
03-26 1190
shared_ptr:允许多个指针指向同一个对象 unique_ptr:独占所指向的对象 weak_ptr：弱引用，指向shared_ptr所管理的对象。可以有效解决循环引用的问题
智能指针类模板：auto_ptr、unique_ptr、shared_ptr的原理与使用
baidu_38797690的博客
06-24 1152
本文介绍了智能指针类模板的原理与使用，其中主要介绍了auto_ptr、unique_ptr、shared_ptr，它们有各自的特性，适用于不同的场景，同时也各有优点和缺陷。实际使用时要结合其特点进行选择。
C++auto_ptr的用法
qq_67972375的博客
02-22 752
auto_ptr的用法
【C++智能指针】unique_ptr的源码详解以及应用实例
最新发布
b_r_ight的博客
04-21 1193
C++11智能指针的原理和使用
auto_ptr与unique_ptr
pingglala的专栏
06-12 1537
auto_ptr是用于C++11之前的智能指针。由于 auto_ptr 基于排他所有权模式：两个指针不能指向同一个资源，复制或赋值都会改变资源的所有权。auto_ptr 主要有两大问题： o 复制和赋值会改变资源的所有权，不符合人的直觉。 o 在 STL 容器中无法使用auto_ptr ，因为容器内的元素必需支持可复制（copy constructable）和可赋值（assignable）。
C++新特性19_auto_ptr的使用及废除原因（已废除；两大缺陷：不能有两个auto_ptr 对象拥有同一个内部指针所有权；两个auto_ptr对象发生赋值操作时，右者对象会丧失该所有权；接口）
分享学习成长历程，Winter is coming！
12-01 2255
class template: std::auto_ptr template <class X> class auto_ptr; 从官网的文档上就可以看出，这个auto_ptr指针不推荐使用(deprecated)，原因这里也有说明： auto_ptr指针在c++11标准中就被废除了，可以使用unique_ptr来替代，功能上是相同的，unique_ptr相比较auto_ptr而言，提升了安全性（没有浅拷贝），增加了特性（delete析构）和对数组的支持。 这个类模板提供了有限度的垃圾回收机
C++智能指针 unique_ptr 和auto_ptr
weixin_42460329的博客
08-27 765
unique_ptr指针： unique指针禁止不同的指针指向同一对象，可用于对象的保护。 不同unique指针的赋值通过转移控制权实现，不进行指针的复制，一个对象永远只有一个unique_ptr指针指向其内容； 传值问题：unique指针不能通过值传递到函数，即在函数输入变量中不能直接传参。直接传参会导致参数的复制，要注意！个人觉得这里容易出现使用问题。 操作方法： 1. 在构建函数时赋值； 2. 通过reset函数重新指定对象； 3. 通过release释放空间；release释放后，un
智能指针
weixin_41127779的博客
09-11 197
为什么要有智能指针 std::string * ps = new std::string(str); ... if (weird_thing()) throw exception(); str = *ps; delete ps; 如果出错指针ps未被释放，内存泄漏 希望指针可以自动释放，已知对象的析构函数会自动调用，删除指针。但是ps为普通指针，没有析构函数。 所以，...
auto_ptr和unique_ptr
CL_XYZ
04-04 811
auto_ptr是老版本的智能指针，当时还没有unique_ptr，shared_ptr，weak_ptr，现在auto_ptr已经被废弃，他有了更好用的替代品unique_ptr，相对于他的后继者，它有以下几个缺点。 1.auto_ptr可以进行赋值和拷贝运算，但是他虽然名义上做的是赋值和拷贝，但是背后做的却是move语义做的事情，拷贝和赋值之后，源对象被置位空，这看起来十分反常。而uniqu...
C++智能指针auto_ptr、unique_ptr、shared_ptr、weak_prt详解
GodFishhh的博客
02-03 1977
C++智能指针auto_ptr、unique_ptr、shared_ptr、weak_prt详解
C++ | auto_ptr与unique_ptr
大柳_的博客。
05-24 669
文章目录前言一、RAII二、裸指针1.裸指针是什么2.裸指针所带来的问题、三、智能指针1.智能指针的种类2.unique_ptr总结 前言 浅谈智能指针 提示：以下是本篇文章正文内容，下面案例可供参考 一、RAII 二、裸指针 1.裸指针是什么 由类型直接定义的指针。比如： 2.裸指针所带来的问题、 1.难以区分指向的是单个对象还是一个数组; 2.使用完指针之后无法判断是否应该销毁指针， 因为无法判断指针是否"拥有” 指向的对象; 3.在已经确定需要销毁指针的情况下，也无法确定是用delete关键字
【C++入门到精通】智能指针 auto_ptr、unique_ptr简介及C++模拟实现 [ C++入门 ]
Yawesh的博客
01-18 1968
这篇文章介绍了 C++ 中的两种智能指针：std::auto_ptr和std::unique_ptr。首先，文章简要介绍了它们的作用和使用示例。然后，对于std::auto_ptr，文章展示了一个简单的模拟实现，解释了每个函数的作用和实现原理。接着，文章介绍了更为严格的 std::unique_ptr，包括其特点、使用示例和模拟实现。对于模拟实现，文章详细解释了如何防止拷贝和赋值，并提供了两种不同的思路。整篇文章内容清晰明了，对于想要学习 C++ 动态内存管理的读者具有很好的参考价值。
C++：智能指针(1)——auto_ptr, unique_ptr的区别
weixin_41442027的博客
04-16 2849
正在上传…重新上传取消 auto_ptr, unique_ptr 首先看一段代码 #include <iostream> #include <type_traits> #include <vector> #include <memory> #include <exception> using namespace std; int...
C++ 智能指针的原理：auto_ptr、unique_ptr、shared_ptr、weak_ptr
weixin_57761086的博客
02-21 2125
介绍C++的智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr。介绍了每种智能指针的作用和特点，以及它们的实现原理，同时介绍了shared_ptr的循环引用的问题，以及如何解决循环引用。
【C++】auto_ptr为何被唾弃？以及其他智能指针的学习
Sxy_wspsby的博客
06-24 1469
1. C++ 98中产生了第一个智能指针auto_ptr.给出了更实用的scoped_ptr和shared_ptr和weak_ptr.3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
智能指针（auto_ptr、unique_ptr、shared_ptr、weak_ptr)
yanzhe1的博客
07-13 738
智能指针（auto_ptr、unique_ptr、shared_ptr)
智能指针原理剖析（一）：auto_ptr、unique_ptr
weixin_49199646的博客
12-13 703
通过常规指针管理动态内存的难点及缺点： （1）忘记释放动态内存： 使用new/malloc分配动态内存时，需要使用delete/free手动释放内存，但程序员容易忘记释放内存，从而产生内存泄露； （2）动态内存释放时机不对： 在尚有指针引用内存的情况下，程序员释放了内存，从而产生空悬指针。典型的案例就是：假设在多线程编程中，线程A、B中分别有指针p1、p2指向对象object，若某个时刻线程A通过p1将object销毁了（释放了object占有的内存），那么线程B中的p2引用object就会产生内存错误。
C++智能指针——auto_ptr详解
热门推荐
yj_android_develop的博客
02-27 1万+
前言 从之前智能指针的介绍中可以了解到智能指针主要作用是管理内存，避免内存泄漏和悬垂指针。 之前介绍的不管是智能指针与引用计数详解还是智能指针与句柄详解，其核心就是通过一个类来管理被new出来的对象，具体的技术就是靠引用计数。 auto_ptr介绍 auto_ptr的实现原理其实就是RAII，在构造的时候获取资源，在析构的时候释放资源，并进行相关指针操作的重载，使用起来就像普通的指针。该智能指针已...
c++智能指针介绍的PPT
01-10
讲解的很清楚，将智能指针的精华所在详细说明，增加理解智能指针。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值