C++:线上课程2

文章目录

• 
  

  一、weak_ptr指针

• • 1.观察器
  • 2.weak_ptr指针代码示例
• 
  

  二、继承

• • 1.公有继承

---

一、weak_ptr指针 1.观察器

use_count	返回管理该对象的shared_ptr对象数量
expired	检查被引用的对象是否已删除
lock	创建管理被引用的对象的shared_ptr
owner_before	提供弱指针的基于拥有者顺序

2.weak_ptr指针代码示例

#include
#include
using namespace std;

template<class _Ty>
class MyDeletor//删除单个对象
{
public:
	//MyDeletor() = default;
	MyDeletor() {}
	void operator()(_Ty* ptr) const
	{
		if (ptr != nullptr)
		{
			delete ptr;// one 
		}
	}
};

template<class _Ty>
class MyDeletor<_Ty[]>//删除多个对象
{
public:
	MyDeletor() = default;
	void operator()(_Ty* ptr) const
	{
		if (ptr != nullptr)
		{
			delete[]ptr; // 
		}
	}
};

template<class _Ty>
class RefCnt
{
public:
	_Ty* _Ptr;               //指向对象
	std::atomic_int _Uses;   //共享型智能指针引用计数
	std::atomic_int _Weaks;  //弱指针引用计数

public:
	RefCnt(_Ty* p) :_Ptr(p), _Uses(1), _Weaks(1) {}
	~RefCnt() {}
	void _Incref() { _Uses += 1; }
	void _Incwref() { _Weaks += 1; }
};
template<class _Ty> class my_weak_ptr;


template<class _Ty, class _Dx = MyDeletor<_Ty> >
class my_shared_ptr // thread;
{
private:
	_Ty* _Ptr; //指向对象
	RefCnt<_Ty>* _Rep;//指向引用计数
	_Dx _mDeletor;//删除器
public:
	my_shared_ptr(_Ty* p = nullptr) :_Ptr(nullptr), _Rep(nullptr)
	{
		if (p != nullptr)
		{
			_Ptr = p;
			_Rep = new RefCnt<_Ty>(p);
		}
	}
	//拷贝构造函数：构造一个对象
	my_shared_ptr(const my_shared_ptr& _Y) :_Ptr(_Y._Ptr), _Rep(_Y._Rep)
	{
		if (_Rep != nullptr)
		{
			_Rep->_Incref(); //_Uses引用计数+1
		}
	}
	//右值移动构造函数：资源进行转移
	my_shared_ptr(my_shared_ptr&& other) :_Ptr(other._Ptr), _Rep(other._Rep)
	{
		//写法1：other.swap(*this);
		other._Ptr = nullptr;
		other._Rep = nullptr;

	}
	//赋值函数
	my_shared_ptr& operator=(const my_shared_ptr& r)
	{
		//判断是否指向同一个对象
		if (this == &r || this->_Ptr == r._Ptr) return *this;
		if (_Ptr != nullptr && --_Rep->_Uses == 0)
		{
			_mDeletor(_Ptr);
			if (--_Rep->_Weaks == 0)
			{
				delete _Rep;
			}
		}
		_Ptr = r._Ptr;
		_Rep = r._Rep;
		if (_Ptr != nullptr)
		{
			_Rep->_Incref(); // _Uses;
		}
		return *this;
	}
	//移动赋值语句
	my_shared_ptr& operator=(my_shared_ptr&& other)
	{
		//防止自赋值
		if (this == &other) return *this;
		if (_Ptr != nullptr && other._Ptr != nullptr && _Ptr == other._Ptr)
		{
			//移动后的资源只让一个对象拥有
			this->_Rep->_Uses -= 1;
			other._Ptr = nullptr;
			other._Rep = nullptr;
			return *this;
		}

		if (_Ptr != nullptr && --_Rep->_Uses == 0)
		{
			_mDeletor(_Ptr);
			if (--_Rep->_Weaks == 0)
			{
				delete _Rep;
			}
		}
		_Ptr = other._Ptr;
		_Rep = other._Rep;
		other._Ptr = nullptr;
		other._Rep = nullptr;
		return *this;
	}
	~my_shared_ptr()
	{
		if (_Rep != nullptr && --_Rep->_Uses == 0)
		{
			_mDeletor(_Ptr);
			if (--_Rep->_Weaks == 0)
			{
				delete _Rep;
			}
		}
		_Ptr = nullptr;
		_Rep = nullptr;
	}

	_Ty* get() const { return _Ptr; }
	_Ty& operator*() const { return *get(); }
	_Ty* operator->() const { return get(); }
	size_t use_count() const//判断有多少智能指针持有此对象
	{
		if (_Rep == nullptr) return 0;
		return _Rep->_Uses;
	}
	void swap(my_shared_ptr& r)//对象交换函数
	{
		std::swap(_Ptr, r._Ptr);
		std::swap(_Rep, r._ref);
	}
	operator bool() const//判断是否拥有资源
	{
		return _Ptr != nullptr;
	}

	template<class _Ty>
	friend class my_weak_ptr;
};


template<class _Ty>
class my_weak_ptr
{
private:
	RefCnt<_Ty>* _Rep;
public:
	my_weak_ptr() :_Rep(nullptr) {}
	//
	my_weak_ptr(const my_shared_ptr<_Ty>& other) :_Rep(other._Rep)
	{
		if (_Rep != nullptr)
		{
			_Rep->_Incwref(); //对弱引用个数+1
		}
	}
	my_weak_ptr(const my_weak_ptr& other) :_Rep(other._Rep)
	{
		if (_Rep != nullptr)
		{
			_Rep->_Incwref();
		}
	}
	my_weak_ptr(my_weak_ptr&& other) :_Rep(other._Rep)
	{
		other._Rep = nullptr;
	}
	//赋值语句
	my_weak_ptr& operator=(const my_weak_ptr& other)
	{
		if (this == &other || this->_Rep == other._Rep) return *this;
		if (_Rep != nullptr && --_Rep->_Weaks == 0)
		{
			delete _Rep;
		}
		_Rep = other->_Rep;
		if (_Rep != nullptr)
		{
			_Rep->_Incwref();//弱引用计数+1
		}
		return *this;
	}
	//移动赋值语句
	my_weak_ptr& operator=(my_weak_ptr&& other)
	{
		if (this == &other) return *this;
		if (this->_Rep != nullptr && other._Rep != nullptr && _Rep == other._Rep)
		{
			this->_Rep->_Weaks -= 1;
			other._Rep = nullptr;
			return *this;
		}
		if (_Rep != nullptr && --_Rep->_Weaks == 0)
		{
			delete _Rep;
		}
		_Rep = other._Rep;
		other._Rep = nullptr;
		return *this;
	}
	my_weak_ptr& operator=(const my_shared_ptr<_Ty>& other)
	{
		if (_Rep != nullptr && --_Rep->_Weaks == 0)
		{
			delete _Rep;
		}
		_Rep = other->_Rep;
		if (_Rep != nullptr)
		{
			_Rep->_Incwref();
		}
		return *this;
	}
	my_weak_ptr& operator=(my_shared_ptr<_Ty>&& other) = delete;

	~my_weak_ptr()
	{
		if (_Rep != nullptr && --_Rep->_Weaks == 0)
		{
			delete _Rep;
		}
		_Rep = nullptr;
	}
	bool expired() const//检查被引用的对象是否已删除
	{
		return this->_Rep->_Uses == 0;
	}
	my_shared_ptr<_Ty> lock() const//加锁
	{
		my_shared_ptr<_Ty> _Ret;
		_Ret._Ptr = _Rep->_Ptr;
		_Ret._Rep = _Rep;
		_Ret._Rep->_Incref();
		return _Ret;
	}
};

class Object
{
private:
	int value;
public:
	Object(int x = 0) :value(x) { cout << "Obejct" << endl; }
	~Object() { cout << "~Object:" << endl; }

	void Print() const { cout << "value: " << value << endl; }
};


class Child;
class Parent
{
public:
	my_weak_ptr<Child> c;
	Parent()
	{
		cout << " Parent " << endl;
	}
	~Parent()
	{
		cout << " ~Parent " << endl;
	}
	void hi() const
	{
		cout << " hello Parent " << endl;
	}
};
class Child
{
	my_weak_ptr<Parent> p;
	Child()
	{
		cout << " Child " << endl;
	}
	~Child()
	{
		cout << " ~Child " << endl;
	}
};

二、继承 1.公有继承

成员函数的接口总会被继承。

公有继承的含义是"是一个"，所以对基类成立的所有事实也必须对派生类成立。

因此，如果一个函数适用于某个类，也必将适用于它的子类。

---