C++智能指针

最新推荐文章于 2024-10-01 05:05:58 发布
最新推荐文章于 2024-10-01 05:05:58 发布
阅读量383 收藏 10
点赞数 5
分类专栏： C++的碎碎念念 文章标签： c++ 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50127633/article/details/139087975
版权

在C++11中通过引入智能指针的概念，使得C++程序员不需要手动释放内存

智能指针的种类
1）unique_ptr
2）shared_ptr
3）weak_ptr
auto_ptr已经被废弃

unique_ptr

  • unique_ptr在任何给定的时刻，只能有一个指针管理内存
  • 当指针超出作用域时，内存将自动释放
  • 该类型指针不可Copy，只可以Move

三种创建方式

  • 通过已有裸指针创建
  • 通过new创建
  • 通过std::make_unique创建(推荐)

unique_ptr可以通过get()获取地址

unique_ptr实现了->与*

  • 可以通过->调用成员函数
  • 可以通过*调用dereferencing
示例函数
class  Cat {
public:
	Cat(string name);
	Cat() = default;
	~Cat();

	void cat_info() const {
		cout << "cat inf name:" << name << endl;
	}
	string get_name() const {
		return name;
	}

	void set_name(const string &name) {
		this->name = name;
	}

private:
	string name{"Mimi"};
};

Cat::Cat(string name) :name(name) {
	cout << "Constructor of Cat:" << name << endl;
}

Cat::~Cat() {
	cout << "Destructor of Cat:"<<name << endl;
}

使用stack
int main() {
	Cat c1("ok");
	c1.cat_info();

	{
		Cat c2("yes");
		c2.cat_info();
	}

	cout << "---------" << endl;
	return 0;
}

结果
Constructor of Cat:ok
cat inf name:ok
Constructor of Cat:yes
cat inf name:yes
Destructor of Cat:yes
---------
Destructor of Cat:ok

使用原始指针
int main() {
	//使用原始指针
	Cat* c_p1 = new Cat("yy");
	c_p1->cat_info();
	{
		Cat* c_p2 = new Cat("zz");
		c_p2->cat_info();
		delete c_p2;
	}
	delete c_p1;

	cout << "---------" << endl;
	return 0;
}

结果
Constructor of Cat:yy
cat inf name:yy
Constructor of Cat:zz
cat inf name:zz
Destructor of Cat:zz
Destructor of Cat:yy
---------

int main(){
	unqie_ptr的三种创建方式
	//第一种
	Cat* c_p2 = new Cat("ok");
	unique_ptr<Cat> u_c_p2{ c_p2 };
	c_p2 = nullptr;
	delete c_p2;
	u_c_p2->cat_info();

	//第二种
	unique_ptr<Cat> u_c_p3{ new Cat("dd") };
	u_c_p3->cat_info();

	//第三种:推荐
	unique_ptr<Cat> u_c_p4 = make_unique<Cat>();
	u_c_p4->cat_info();


	cout << "---------" << endl;
	return 0;
}

结果
Constructor of Cat:ok
cat inf name:ok
Constructor of Cat:dd
cat inf name:dd
cat inf name:Mimi
---------
Destructor of Cat:Mimi
Destructor of Cat:dd
Destructor of Cat:ok

uniqet_ptr 与 函数调用

  • unique_ptr是不可Copy，只可以Move
  • 在做函数参数或者是返回值中一定要注意所有权

函数调用与unique_ptr注意事项

  • Passing by value

    需要用move来转移内存拥有权
    如果参数直接传入make_unique语句，自动转换为move

    void do_with_cat_passByValue(unique_ptr<Cat> c) {
	c->cat_info();
}

int main(){
	//1.pass by value
	unique_ptr<Cat> c1 = make_unique<Cat>("ff");
	do_with_cat_passByValue(move(c1));
	cout<<"--------"<<endl;
}

结果
Constructor of Cat:ff
cat inf name:ff
Destructor of Cat:ff
-------

  • Passing by reference

    如果设置参数为const，则不能改变指向
    reset()方法为智能指针清空方法

    void do_with_cat_passByReference(const unique_ptr<Cat> &c) {
c->set_name("oo");
c->cat_info();
//c.reset();
}

unique_ptr<Cat> c2 = make_unique<Cat>("ff2");
do_with_cat_passByReference(c2);

结果
Constructor of Cat:ff2
cat inf name:oo
---------
Destructor of Cat:oo

  • return by value

    指向一个local object
    可以用作链式函数

shared_ptr

  • shared_ptr计数指针，又称共享指针

    shared_ptr创建了一个计数器与类对象所指的内存相关联
    copy则计数器加一，销毁则计数器减一
    api为use_count()

  • 与unique_ptr不同的是它可以共享数据
//常量类型
int main(){
	shared_ptr<int> i_p_1 = make_shared<int>(10);
	cout << "value:" << *i_p_1 << endl;
	cout << "use count:" << i_p_1.use_count() << endl;
	
	shared_ptr<int> i_p_2 = i_p_1;
	cout << "value:" << *i_p_2 << endl;
	cout << "use count:" << i_p_2.use_count() << endl;
	
	i_p_2 = nullptr;
	cout << "use count:" << i_p_1.use_count() << endl;
	cout << "use count:" << i_p_2.use_count() << endl;
	
	cout << "---------" << endl;
	return 0;
}

结果
value:10
use count:1

value:10
use count:2

use count:1
use count:0
---------

int main() {
	//自定义类型
	shared_ptr<Cat> c_p_1 = make_shared<Cat>();
	cout << "c_p_1 use count:" << c_p_1.use_count() << endl;

	shared_ptr<Cat> c_p_2 = c_p_1;
	shared_ptr<Cat> c_p_3 = c_p_1;
	cout << "c_p_1 use count:" << c_p_1.use_count() << endl;
	cout << "c_p_2 use count:" << c_p_2.use_count() << endl;
	cout << "c_p_3 use count:" << c_p_3.use_count() << endl;

	c_p_1 = nullptr;
	cout << "c_p_1 use count:" << c_p_1.use_count() << endl;
	cout << "c_p_2 use count:" << c_p_2.use_count() << endl;
	cout << "c_p_3 use count:" << c_p_3.use_count() << endl;
	cout << "------------" << endl;
	return 0;
}

结果
c_p_1 use count:1

c_p_1 use count:3
c_p_2 use count:3
c_p_3 use count:3

c_p_1 use count:0
c_p_2 use count:2
c_p_3 use count:2
------------
Destructor of Cat:Mimi

shared_ptr与unique_ptr

  • 不能将shared_ptr转换为unique_ptr
  • unique_ptr可以转换为shared_ptr(通过move)
unique_ptr<Cat> get_unique_ptr() {
	unique_ptr<Cat> p_cat = make_unique<Cat>("Local cat");
	return p_cat;
}

int main() {
	unique_ptr<Cat> c_p_1 = make_unique<Cat>("dd");
	shared_ptr<Cat> c_p_2 = move(c_p_1);
	cout << "c_p_2 use count:" << c_p_2.use_count() << endl;
	
	//func：使用shared_ptr可以接收 unqiue_ptr
	shared_ptr<Cat> c_p_3 = get_unique_ptr();
	if (c_p_3) {
		c_p_3->cat_info();
		cout << "c_p_3 use count:" << c_p_3.use_count() << endl;
	}
	cout << "-----------" << endl;
	return 0;
}

结果
Constructor of Cat:dd
c_p_2 use count:1

Constructor of Cat:Local cat
cat inf name:Local cat
c_p_3 use count:1
-----------
Destructor of Cat:Local cat
Destructor of Cat:dd

weak_ptr

  • weak_ptr并不拥有内存所有权
  • 不能调用->和解引用 *

weak_ptr为什么会存在

  • A类中有一个需求需要存储其他A类对象的信息
    如果使用shared_ptr, 那么在销毁时会遇到环形依赖问题
    所以我们这里需要用一个不需要拥有所有权的指针来标记该同类对象
    weak_ptr可以通过lock()函数来提升为shared_ptr
weak_ptr不会增加计数器的值
int main(){
	shared_ptr<Cat> s_p_c1 = make_shared<Cat>("c1");
	weak_ptr<Cat> w_p_c1(s_p_c1);
	cout << "s_p_c1 use count:" << s_p_c1.use_count() << endl;
	cout << "w_p_c1 use count:" << w_p_c1.use_count() << endl;
		
	//lock()将weak_ptr转为shared_ptr
	shared_ptr<Cat> s_p_c2 = w_p_c1.lock();
	cout << "s_p_c1 use count:" << s_p_c1.use_count() << endl;
	cout << "s_p_c2 use count:" << s_p_c1.use_count() << endl;
	cout << "w_p_c1 use count:" << w_p_c1.use_count() << endl;
	cout << "------------" << endl;


}

结果
Constructor of Cat:c1
s_p_c1 use count:1
w_p_c1 use count:1

s_p_c1 use count:2
s_p_c2 use count:2
w_p_c1 use count:2
------------
Destructor of Cat:c1

循环依赖问题

class  Cat {
public:
	Cat(string name);
	Cat() = default;
	~Cat();

	void cat_info() const {
		cout << "cat inf name:" << name << endl;
	}
	string get_name() const {
		return name;
	}

	void set_name(const string &name) {
		this->name = name;
	}

	void set_friend(shared_ptr<Cat> c) {
		m_friend = c;
	}

private:
	string name{"Mimi"};
	shared_ptr<Cat> m_friend;
};

int main(){
	shared_ptr<Cat> c3 = make_shared<Cat>("c3");
	shared_ptr<Cat> c4 = make_shared<Cat>("c4");
}
//结果
Constructor of Cat:c3
Constructor of Cat:c4
------------
Destructor of Cat:c4
Destructor of Cat:c3

int main(){
	shared_ptr<Cat> c3 = make_shared<Cat>("c3");
	shared_ptr<Cat> c4 = make_shared<Cat>("c4");
	//环形依赖
	c3->set_friend(c4);
	c4->set_friend(c3);
}

//结果：没有调用析构函数
Constructor of Cat:c3
Constructor of Cat:c4
------------

将类中的shared_ptr m_friend 换成 weak_ptr m_friend，就可以解决环形依赖的问题

class  Cat {
public:
	Cat(string name);
	Cat() = default;
	~Cat();

	void cat_info() const {
		cout << "cat inf name:" << name << endl;
	}
	string get_name() const {
		return name;
	}

	void set_name(const string &name) {
		this->name = name;
	}

	void set_friend(shared_ptr<Cat> c) {
		m_friend = c;
	}

private:
	string name{"Mimi"};
	weak_ptr<Cat> m_friend;
};

int main(){
	shared_ptr<Cat> c3 = make_shared<Cat>("c3");
	shared_ptr<Cat> c4 = make_shared<Cat>("c4");
	//环形依赖
	c3->set_friend(c4);
	c4->set_friend(c3);
}

结果
Constructor of Cat:c3
Constructor of Cat:c4
------------
Destructor of Cat:c4
Destructor of Cat:c3
一个小猴子｀
关注
专栏目录
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 2018
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
weixin_54670782的博客
12-01 3818
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
【C++进阶学习】第十三弹——C++智能指针的深入解析
2301_80220607的博客
08-13 2728
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针基础用法详解
mahuifa的博客
04-21 1266
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1103
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 647
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 413
【代码】求n的阶乘的相反数（c语言）
简易STL实现 | Set 的实现
AsherGu的博客
09-26 445
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 645
【C++】stack和queue的使用及注意事项
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
最新发布
m0_59237910的博客
10-01 316
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C/C++语言基础--C++运算符重载以及其重载限制
weixin_74085818的博客
09-27 988
运算符重载，就是赋予运算符新的含义。它是重载系统内部运算符的函数，是实现类静态多态性的方式之一。它本质上是函数重载。// 假设都属于学生类// 想要对比谁的年龄大，试想一下，能不能像正常比较大小那样直接比较呢？答案当然是可以的，这个就是我们这节课要学习的**“运算符重载”**，这样进行重载后，类更像是一种自定义数据类型。实际上，我们已经在不知不觉之中使用了运算符重载。列如：我们习惯使用的对整数，浮点数运用+、-、*、/，其实计算机对整数和浮点数的操作过程是不一样的，这个主要是整数和浮点数的。
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值