C++常用智能指针学习

最新推荐文章于 2024-09-05 19:05:10 发布

春暖夏凉

最新推荐文章于 2024-09-05 19:05:10 发布

阅读量228

点赞数

分类专栏： C++ 练习

本文链接：https://blog.csdn.net/weixin_42808534/article/details/106855452

版权

C++ 练习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

unique_ptr<> 指针

struct Person
{
	~Person()
	{
		cout << "~Person"<<"\n";
	}

	string str;
};

unique_ptr<Person> test()
{
	return unique_ptr<Person>(new Person);
}


// 链表结点 
template <typename T>
struct  Node{
	T data;
	unique_ptr<Node<T>> next;

	~Node()
	{
		cout << "~Node\n";
	}
};

template<typename T>
class  Link
{
public:
	// 头插法
	void front(const T& data)
	{
		auto node = make_unique<Node<T>>();
		node->data = data;
		node->next = move(head_.next);
		head_.next = move(node);
	}
	void print()
	{
		Node <T>* node = head_.next.get();
		while (node) {
			cout << node->data << ' ';
			node = node->next.get();
		}

		cout << "\n";
	}

	
private:
	Node<T> head_;
};


int main()
{

	//string* str(new string("hello word"));

	//delete str;

	//独有指针  和函数的生命周期一样
	//unique_ptr<string> pointer(new string(" hello word"));
	//cout << *pointer << endl;


	//unique_ptr<Person> pointer = test();  // 析构一次
	//unique_ptr<Person> p2 = move(pointer);
	//p2.reset(new Person);

	//快速创建指针  没有构造函数不用传递参数
	//auto ptr = make_unique<Person>();
	//ptr->str = "hello  word";

	// 一共析构6次 
	Link<int> lk;
	for (int val : {1, 2, 3, 4, 5})
	{
		lk.front(val);
	}

	lk.print();
	return 0;
}

2020/6/23 共享指针学习

#include <memory>
using namespace std;




struct Person
	// 继承一个类
	:enable_shared_from_this<Person> {
	void show()
	{
		cout << str << '\n';
	}

	// 返回共享指针
	shared_ptr<Person> getShared() {
		return shared_from_this();
	}
	string str;
};

int main()
{
	shared_ptr<Person> ptr2;
	{
		shared_ptr<Person> ptr(new Person);
		ptr->str = "hello";
		ptr2 = ptr->getShared();
		//引用记数次数
		cout << ptr.use_count() << endl;

	}
	// pt2 的指针已经被释放，会报出内存异常
	// 更改之后 继承类之后不会 爆出异常 
	ptr2->show();
	return 0;
}

**运行结果 😗*引用记数为２　　且可以正常输出
在这里插入图片描述

智能指针常见面试题目

参考链接 (一)

在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。

动态内存管理经常会出现两种问题：一种是忘记释放内存，会造成内存泄漏；一种是尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针

标准库提供的两种智能指针的区别在于管理底层指针的方法不同，shared_ptr允许多个指针指向同一个对象，unique_ptr则“独占”所指向的对象。标准库还定义了一种名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中

类模板和模板类

  类模板重点在模板, 模板类侧重点在类 ,可以理解为具体的对象
  　类模板的重点是模板。表示的是一个模板，专门用于产生类的模子。例子：

1 template
2 class Vector
3 {
4 …
5 };
　使用这个Vector模板就可以产生很多的class（类），Vector、Vector、 Vector< Vector >、Vector<Shape*>……。

模板类的重点是类。表示的是由一个模板生成而来的类。例子：

上面的Vector、Vector、……全是模板类。

shared_ptr 指针
shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的
拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象。
get函数获取原始指针
注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存
注意避免循环引用，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会导致堆内存无法正确释放，导致内存泄漏。循环引用在weak_ptr中介绍

测试结果

int main()
{
	//UniquePointer<Demo> ptr(new Demo);

	//UniquePointer<Demo> ptr(new Demo);

	//std::shared_ptr<int> p4 = new int(1);  错误
	int a = 10;
	//拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，
	//当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象
	shared_ptr<int> ptra = make_shared<int>(a);
	shared_ptr<int> ptra2(ptra);// copy;
	cout << ptra.use_count() << endl;    //  2

	int b = 20;
	int* pb = &a;
	//shared_ptr<int>ptrb = pb; error
	shared_ptr<int>ptrb = make_shared<int>(b);
	ptra2 = ptrb;
	cout << "b"<<*ptra2;  //20
	pb = ptrb.get();// 获取原始指针

	cout <<"ptra.use_count"<< ptra.use_count() << endl;  //1
	cout <<"ptrb.use_count" <<ptrb.use_count() << endl;  //2
	return 0;
}

unique_ptr

同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权

int main() {
    {
        std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
        //std::unique_ptr<int> uptr2 = uptr;  //不能賦值
        //std::unique_ptr<int> uptr2(uptr);  //不能拷貝
        std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
        uptr2.release(); //释放所有权
    }
    //超過uptr的作用域，內存釋放
}

weak_ptr的使用

int main()
{
	shared_ptr<int> sh_ptr = make_shared<int>(10);
	cout << sh_ptr.use_count() << endl;

	weak_ptr<int> wp(sh_ptr);
	//  记数显示
	std::cout << wp.use_count() << std::endl;
	if (!wp.expired()) {
		std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
		*sh_ptr = 100;
		std::cout << wp.use_count() << std::endl;
	}
   
	//int* pa = new int(10);
	//cout << *pa;
	return 0;
}

内存泄漏版本

class Child;
class Parent;
class  Parent {
private :
	shared_ptr<Child>ChildPtr;
public:
	void setChild(shared_ptr<Child>child)
	{
		this->ChildPtr = child;
	}

	void doSomething() {
		
			if (this->ChildPtr) {
				cout << " mychild  存在" << endl;
			}
	}
	~Parent() {
		// 不用析构了  智能指针帮忙做了
	}
};

class Child {
private:
	shared_ptr<Parent> ParentPtr;
public:
	void setPartent(std::shared_ptr<Parent> parent) {
		this->ParentPtr = parent;
	}
	void doSomething() {
		if (this->ParentPtr.use_count()) {

		}
	}
	~Child() {
	}
};
int main()
{   
	std::weak_ptr<Parent> wpp;
	std::weak_ptr<Child> wpc;
	{
		std::shared_ptr<Parent> p(new Parent);
		std::shared_ptr<Child> c(new Child);
		p->setChild(c);
		c->setPartent(p);
		wpp = p;
		wpc = c;
		std::cout << p.use_count() << std::endl; // 2
		std::cout << c.use_count() << std::endl; // 2
	}
	std::cout << wpp.use_count() << std::endl;  // 1
	std::cout << wpc.use_count() << std::endl;  // 1
	return 0;
}

正确版本

通过 std::weak_ptr ChildPtr 指针或取指针的资源数量

#include <iostream>
#include <memory>

class Child;
class Parent;

class Parent {
private:
    //std::shared_ptr<Child> ChildPtr;
    std::weak_ptr<Child> ChildPtr;
public:
    void setChild(std::shared_ptr<Child> child) {
        this->ChildPtr = child;
    }

    void doSomething() {
        //new shared_ptr
        if (this->ChildPtr.lock()) {

        }
    }

    ~Parent() {
    }
};

class Child {
private:
    std::shared_ptr<Parent> ParentPtr;
public:
    void setPartent(std::shared_ptr<Parent> parent) {
        this->ParentPtr = parent;
    }
    void doSomething() {
        if (this->ParentPtr.use_count()) {

        }
    }
    ~Child() {
    }
};

int main() {
    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
        c->setPartent(p);
        wpp = p;
        wpc = c;
        std::cout << p.use_count() << std::endl; // 2
        std::cout << c.use_count() << std::endl; // 1
    }
    std::cout << wpp.use_count() << std::endl;  // 0
    std::cout << wpc.use_count() << std::endl;  // 0
    return 0;
}

动态分配 const 对象

const int *pci = new const int(1024);
//分配并初始化一个const int
const string *pcs = new const string;
//分配并默认初始化一个const的空string

类似其他任何const对象，一个动态分配的const对象必须进行初始化。对于一个定义了默认构造函数的类类型，其const动态对象可以隐式初始化，而其他类型的对象就必须显式初始化。由于分配的对象就必须显式初始化。由于分配的对象是const的，new返回的指针就是一个指向const的指针。

使用new和delete管理动态内存常出现的问题：
（1）忘记delete内存
（2）使用已经释放的对象
（3）同一块内存释放两次