C++复习笔记24

最新推荐文章于 2024-07-22 23:59:01 发布
最新推荐文章于 2024-07-22 23:59:01 发布
阅读量166 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hou19975418/article/details/129701822
版权

1.scoped_array以及unique_ptr unique_ptr的实现原理：简单粗暴的防拷贝

#include<iostream>
#include<boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

void test01()
{
	int* ptr = new int[10]{ 1,2,3,4,5,6,7,8,9,10 };
	scoped_array<int> sa(ptr);

	for (int i = 0; i < 10; ++i)
		cout << sa[i] << " ";
	cout << endl;
}

void test02()
{
	int* ptr = new int(10);
	unique_ptr<int> up(ptr);
    cout << *up << endl;
	//unique_ptr<int> up1 = up;//不能赋值也不能拷贝构造
}

void main()
{
	test02();
}

2.shared_ptr：所有权共享，使用引用计数，减到零才释放空间

#include<iostream>
#include<boost/smart_ptr.hpp>
//#include<boost/shared_ptr.hpp>
using namespace std;
//using namespace boost;

void test01()
{
	int* ptr = new int(10);
	shared_ptr<int> sp(ptr);
	cout << *sp << endl;
	cout << "use count" << sp.use_count() << endl;
	{
		shared_ptr<int> sp1;
		sp1 = sp;
		cout << "use count" << sp1.use_count() << endl;
	}
	shared_ptr<int> sp2 = sp;
	cout << "use count" << sp2.use_count() << endl;
}

void main()
{
	test01();
}

3.shared_ptr模拟实现

shared_ptr 的原理：是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源 。
1. shared_ptr 在其内部， 给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享 。
2. 在 对象被销毁时 ( 也就是析构函数调用 ) ，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是 0 ，就说明自己是最后一个使用该资源的对象， 必须释放该资源 ；
4. 如果不是 0 ，就说明除了自己还有其他对象在使用该份资源， 不能释放该资源 ，否则其他对象就成野指
针了。

shared_count.h

#pragma once
#include"sysutil.h"
#include"sp_counted_base.h"
#include"sp_counted_impl.h"
template<class Type>
class shared_count
{
public:
	template<class Y >
	shared_count(Y*  p):pi_(new sp_counted_impl<Y>(p))
	{
#ifdef DISPLAY
		std::cout << "Create SHARED_COUNT" << std::endl;
#endif
	}

	shared_count(const shared_count<Type>& r) :pi_(r.pi_)
	{
		if (pi_)
			pi_->add_ref_copy();
	}

	void swap(shared_count& r)
	{
		sp_counted_base* tmp = r.pi_;
		r.pi_ = pi_;
		pi_ = tmp;
	}

	~shared_count()
	{
#ifdef DISPLAY
		std::cout << "Free SHARED_COUNT" << std::endl;
#endif
		if (pi_ != NULL)
		{
			pi_->release();
		}
	}

	long use_count()const
	{
		return pi_->use_count();
	}

private:
	sp_counted_base* pi_;
};

shared_ptr.h

#pragma once
#include"sysutil.h"
#include"shared_count.h"

template<class Type>
class shared_ptr
{
public:
	typedef shared_ptr<Type>  this_type;
public:
	shared_ptr(Type* p):pn(p),px(p)
	{
#ifdef DISPLAY
		std::cout << "Create SHARED_PTR" << std::endl;
#endif
	}

	shared_ptr(const shared_ptr<Type>& r):px(r.px),pn(r.pn)
	{}

	this_type& operator=(const this_type& r)
	{
		this_type(r).swap(*this);
		return *this;
	}

	Type& operator*()
	{
		return *px;
	}

	Type* operator->()
	{
		return px;
	}

	~shared_ptr()
	{
#ifdef DISPLAY
		std::cout << "Free SHARED_PTR" << std::endl;
#endif
	}

	long use_count()const
	{
		return pn.use_count();
	}

	void swap(shared_ptr<Type>& other)
	{
		std::swap(px, other.px);
		pn.swap(other.pn);
	}

private:
	Type* px;
	shared_count<Type> pn;
};

sp_counted_base.h

#pragma once
#include"sysutil.h"
#include"shared_count.h"

template<class Type>
class shared_ptr
{
public:
	typedef shared_ptr<Type>  this_type;
public:
	shared_ptr(Type* p):pn(p),px(p)
	{
#ifdef DISPLAY
		std::cout << "Create SHARED_PTR" << std::endl;
#endif
	}

	shared_ptr(const shared_ptr<Type>& r):px(r.px),pn(r.pn)
	{}

	this_type& operator=(const this_type& r)
	{
		this_type(r).swap(*this);
		return *this;
	}

	Type& operator*()
	{
		return *px;
	}

	Type* operator->()
	{
		return px;
	}

	~shared_ptr()
	{
#ifdef DISPLAY
		std::cout << "Free SHARED_PTR" << std::endl;
#endif
	}

	long use_count()const
	{
		return pn.use_count();
	}

	void swap(shared_ptr<Type>& other)
	{
		std::swap(px, other.px);
		pn.swap(other.pn);
	}

private:
	Type* px;
	shared_count<Type> pn;
};

sp_counted_impl.h

#pragma once

#include"sysutil.h"
#include"sp_counted_base.h"

template<class X>
class sp_counted_impl:public sp_counted_base
{
public:
	sp_counted_impl(X* px) :px_(px)
	{
#ifdef DISPLAY
		std::cout << "create SP_COUNTED_IMPL" << std::endl;
#endif
	}

	void dispose()
	{
		delete px_;
	}

	~sp_counted_impl()
	{
#ifdef DISPLAY
		std::cout << "Free SP_COUNTED_IMPL" << std::endl;
#endif
	}

private:
	X* px_;
};

sysutil.h

#pragma once
#include<iostream>
#include<vld.h>
//using namespace std;
//#define DISPLAY

test.cpp

#include"shared_ptr.h"

void test01()
{
	int* ptr = new int(5);
	shared_ptr<int> ps(ptr);
	std::cout << "ptr.use_count="<<ps.use_count() << std::endl;

	shared_ptr<int>ps2(ps);
	std::cout << "ptr.use_count=" << ps2.use_count() << std::endl;

	/*{
		shared_ptr<int>ps3(ps2);
		std::cout << "ptr.use_count=" << ps3.use_count() << std::endl;
	}
	std::cout << "ptr.use_count=" << ps2.use_count() << std::endl;

	std::cout << *ps << std::endl;*/

	//int* q = new int(50);
	//shared_ptr<int> ps4(q);
	//std::cout << "q.use_count=" << ps4.use_count() << std::endl;
	{
		int* ptr2 = new int(50);
		shared_ptr<int> ps5(ptr2);
		ps5 = ps;
		std::cout << "ptr2.use_count=" << ps5.use_count() << std::endl;
	}
	std::cout << "ptr2.use_count=" << ps2.use_count() << std::endl;
}

void main()
{
	test01();
	system("pause");
}

weak_ptr:不影响引用计数，也不能解引用

#include<iostream>
#include<vld.h>
using namespace std;

void test01()
{
	int* ptr = new int(10);
	shared_ptr<int> ps(ptr);
	cout << "ptr.use_count=" << ps.use_count() << endl;
    
	weak_ptr<int> pw = ps;
	cout << "ptr.use_count=" << pw.use_count() << endl;//不影响引用计数
	//cout << *pw << endl;//不能解引用
}

void main()
{
	test01();
	system("pause");
}

智能指针：异常安全但不是线程安全的，需要加锁实现互斥

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++ 或 -- ，这个操作不是原子的，引用计数原来是 1 ， ++ 了两次，可能还是 2. 这样引用计数就错乱了。会导致资源未 释放或者程序崩溃的问题。所以只能指针中引用计数 ++ 、 -- 是需要加锁的，也就是说引用计数的操作是 线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。 
#include<iostream>
#include<mutex>
#include<thread>
//智能指针 异常安全但不线程安全
using namespace std;
template <class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{}
	~SharedPtr()
	{
		Release();
	}
	SharedPtr(const SharedPtr<T>& sp)
		: _ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			Release();
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;
			AddRefCount();
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
	int UseCount() { return *_pRefCount; }
	T* Get() { return _ptr; }
	void AddRefCount()
	{
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
	}
private:
	void Release()
	{
		bool deleteflag = false;
		_pMutex->lock();
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
			deleteflag = true;
		}
		_pMutex->unlock();
		if (deleteflag)
			delete _pMutex;
	}
private:
	int* _pRefCount; // 引用计数
	T* _ptr;       // 指向管理资源的指针
	mutex* _pMutex;
};
class Date
{
public:
	Date() { cout << "Date()" << endl; }
	~Date() { cout << "~Date()" << endl; }
	size_t _year = 0;
	size_t _month = 0;
	size_t _day = 0;
};
mutex mt;
void SharePtrFunc(SharedPtr<Date>& sp, size_t n)
{
	cout << sp.Get() << endl;
	for (size_t i = 0; i < n; ++i)
	{
		SharedPtr<Date> copy(sp);
		mt.lock();
		copy->_year++;
		copy->_month++;
		copy->_day++;
		mt.unlock();
	}
}
int main()
{
	SharedPtr<Date> p(new Date);
	cout << p.Get() << endl;
	const size_t n = 10000000;
	thread t1(SharePtrFunc, ref(p), n);
	thread t2(SharePtrFunc, ref(p), n);
	t1.join();
	t2.join();
	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
	return 0;
}

循环引用：

#include<iostream>
using namespace std;
struct ListNode
{
	int _data;
	/*shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;*/
	weak_ptr<ListNode> _prev;//解决循环引用
	weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}
1. node1 和 node2 两个智能指针对象指向两个节点，引用计数变成 1 ，我们不需要手动 delete 。
2. node1 的 _next 指向 node2 ， node2 的 _prev 指向 node1 ，引用计数变成 2 。
3. node1 和 node2 析构，引用计数减到 1 ，但是 _next 还指向下一个节点。但是 _prev 还指向上一个节点。
4. 也就是说 _next 析构了， node2 就释放了。
5. 也就是说 _prev 析构了， node1 就释放了。
6. 但是 _next 属于 node 的成员， node1 释放了， _next 才会析构，而 node1 由 _prev 管理， _prev 属于 node2 成员，所以这就叫循环引用，谁也不会释放。
删除器的使用--属于回调函数 
#include<iostream>
#include<vld.h>
using namespace std;

void ptr_delete(void* ptr)
{
	cout << "Free" << endl;
	free(ptr);//delete [] close
}

void test01()
{
	//socket
	int* ptr = (int*)malloc(sizeof(int));//malloc new[]
	shared_ptr<int> ps(ptr, ptr_delete);
}

void main()
{
	test01();
	system("pause");
}

shared_ptr实现的简单版

// 模拟实现一份简单的SharedPtr,了解原理
#include<iostream>
#include <thread>
#include <mutex>
using namespace std;
template <class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{}
	~SharedPtr() { Release(); }
	SharedPtr(const SharedPtr<T>& sp)
		: _ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}
	// sp1 = sp2
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		//if (this != &sp)
		if (_ptr != sp._ptr)
		{
			// 释放管理的旧资源
			Release();
			// 共享管理新对象的资源，并增加引用计数
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;

			AddRefCount();
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
	int UseCount() { return *_pRefCount; }
	T* Get() { return _ptr; }
	void AddRefCount()
	{
		// 加锁或者使用加1的原子操作
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
	}
private:
	void Release()
	{
		bool deleteflag = false;

		// 引用计数减1，如果减到0，则释放资源
		_pMutex.lock();
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
			deleteflag = true;
		}
		_pMutex.unlock();

		if (deleteflag == true)
			delete _pMutex;
	}
private:
	int* _pRefCount; // 引用计数
	T* _ptr; // 指向管理资源的指针 
	mutex* _pMutex; // 互斥锁
};
int main()
{
	SharedPtr<int> sp1(new int(10));
	SharedPtr<int> sp2(sp1);
	*sp2 = 20;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	SharedPtr<int> sp3(new int(10));
	sp2 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	sp1 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	return 0;
}

写一本我们家的书
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++：智能指针的剖析
AngelDg的博客
04-18 1376
智能指针智能指针的使用及原理 智能指针的使用及原理 RAII RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了...
【C++】—— 智能指针
chenxiyuehh的博客
04-03 289
一、为什么需要智能指针 我们先来看一段代码 #include <iostream> #include <vector> #include <exception> using namespace std; void Test() { int* tmp = (int*)malloc(sizeof(int)* 100); int* p = new int; ...
C语言进阶之自定义类型：结构体，枚举，联合
Britney_dark的博客
03-05 1506
前言 结构体 （1）结构体类型的声明 （2）结构的自引用 （3）结构体变量的定义和初始化 （4）结构体内存对齐 （5）结构体传参 （6）结构体实现位段（位段的填充&可移植性） 枚举 （1）枚举类型的定义 （2）枚举的优点 （3）枚举的使用 联合 （1）联合类型的定义 （2）联合的特点 （3）联合大小的计算。 一、结构体 1.结构体的声明 （1）结构的基础知识 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。 （2）结构的声明 ...
struct Lnode *next
热门推荐
weixin_52634719的博客
09-18 1万+
定义结点，用结构体 next存的是下一个结点的地址，所以它是一个指针型 首先结点是一个结构类型，先说明他有两个成员，一个是元素类型，叫data；另一个next，struct Lnode和上面的一模一样，是一个指向这种类型的一个指针，这种类型是又包括两个成员的指针，自己来定义自己，嵌套定义。 再来一遍：它是一个指针，那为什么这个指针时这个类型呢？因为这个指针指向的变量仍然是有data,有next两个成员，那么这个有data,有next的两个成员的类型是什么类型呢？就是这个struct L...
C++快速复习笔记.rar
05-07
这份"C++快速复习笔记"旨在帮助程序员迅速回顾和掌握C++的关键概念和技术。以下是对笔记内容的详细解读： 一、基础语法 C++的基础语法包括变量声明、数据类型（如int、char、float、double）、运算符（如算术运算符...
C++复习笔记简单整理
06-28
C++复习笔记简单整理
高质量C++复习笔记1
08-08
【高质量C++复习笔记1】 在C++编程中，理解和运用一些关键概念是至关重要的，这里我们将重点关注断言（Assert）和常量（Const）这两个主题。 ### 断言（Assert） 断言是一种调试工具，它允许程序员在代码中设置...
C++面试复习资料笔记
10-12
C++复习资料 复习.html
C++及数据结构复习笔记
07-31
是本人博客部分内容的整合，《C++及数据结构复习笔记》的第一章到第15章的部分。由于只校对了一次，在所难免存在表达不合适的地方，还有可能存在错别字。 该复习文档是本人根据谭浩强老师的《C++程序设计》、邓俊辉...
关于结构体二级指针引用时必须加括号的问题 (*L)->next,而不是*L->next
RiRiRicardo的博客
09-01 5790
今天一天的时候都耗在了单链表的操作函数的编写上了，其实本来应该是一件很简单的事情，但是由于一个优先级的错误，导致了我调试了很久 先说下结论，结构体的二级指针在调用时，必须加上括号，因为*（取值）运算优先级是比->来的低的。 再来说下发现过程，写了很久的程序，产生了各种编译错误，排除好多粗心和手误的错误外，还有一个错误让我百思不得解，代码及错误提示为: 错误代码： *
nextjs报错:'NODE_ENV' 不是内部或外部命令
吞石鱼的博客
08-12 3732
最近在使用next.js的时候，在生产模式下使用nodejs跑server.js文件时，运行 "start": "、 NODE_ENV=production node server.js", 出现 ‘NODE_ENV’ 不是内部或外部命令，也不是可运行的程序或批处理文件 之前的配置: 解决方法： 安装cross-env：yarn add cross-env –d，再在NODE_ENV=xxxxx...
C++ 继承篇
2301_79201049的博客
07-18 677
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 369
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 178
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++ 红黑树
最新发布
wxk2227814847的博客
07-22 647
在之前的文章中，我们介绍了 C++ 标准库中的 map 和 set 容器的使用，以及 AVL 树的实现。尽管 AVL 树在平衡性方面表现优异，但在插入和删除操作频繁的应用中，红黑树（Red-Black Tree）由于其较少的旋转操作次数，往往能提供更优的性能。本篇博客将详细介绍红黑树的概念、性质、节点定义、结构、插入与删除操作、性能、迭代器设计，并展示基于红黑树的模拟实现代码及其在 map 容器中的应用。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 9601
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
Badme
07-18 1万+
【C++】获取环境变量
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 794
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值