#include<iostream>
using namespace std;
#if 0
void _MergeSort(int* a, int left, int right, int* tmp)
{
if (left >= right)
return;
int mid = left + ((right - left) >> 1);
_MergeSort(a, left, mid, tmp);
_MergeSort(a, mid + 1, right, tmp);
int begin1 = left, end1 = mid;
int begin2 = mid + 1, end2 = right;
int index = left;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
tmp[index++] = a[begin1++];
else
tmp[index++] = a[begin2++];
}
while (begin1 <= end1)
tmp[index++] = a[begin1++];
while (begin2 <= end2)
tmp[index++] = a[begin2++];
memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
}
//
//void MergeSort(int* a, int n)
//{
// int* tmp = (int*)malloc(sizeof(int) * n);
// _MergeSort(a, 0, n - 1, tmp);
//
//}
#include<vector>
template<class T>
class SmarPtr
{
public:
SmarPtr(T* ptr = nullptr)
:_ptr(ptr)
{}
~SmarPtr()
{
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
SmarPtr<int> sp(tmp);
_MergeSort(a, 0, n - 1, tmp);
vector<int> v(1000000000000, 10);
}
int main()
{
try
{
int a[5] = { 4,5,3,2,1 };
MergeSort(a, 5);
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}
#endif
#if 0
//std::auto_ptr
#include<memory>
class Date
{
public:
Date()
{
cout << "Date()" << endl;
}
~Date()
{
cout << "~Date()" << endl;
}
int _year;
int _mouth;
int _day;
};
int main()
{
auto_ptr<Date> ap(new Date);
auto_ptr<Date> copy(ap);
// auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了
// C++98中设计的auto_ptr问题是非常明显的，所以实际中很多公司明确规定了
//不能使用auto_ptr
ap->_year = 1;
return 0;
}
#endif
#if 0
//auto_ptr的实现原理：管理权转移的思想。
//模拟实现：
template<class T>
class AutoPtr
{
public:
AutoPtr(T* ptr = NULL)
:_ptr(ptr)
{}
~AutoPtr()
{
if (_ptr)
delete _ptr;
}
//一旦发生拷贝，就将ap中资源转移到当前对象中，然后令ap与其所管理资源断开联系
//这样就解决了一块空间被多个对象使用而造成程序奔溃问题
AutoPtr(AutoPtr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = NULL;
}
AutoPtr<T>& operator= (AutoPtr<T>& ap)
{
//是要把ap 赋值 给_ptr。
//防止自己给自己赋值
if (this != &ap)
{
//如果_ptr不为空，则说明它正管理着其它空间，
//先把_ptr中的对象释放，不然会造成内存泄漏
if (_ptr)
delete _ptr;
//再赋值
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
T* operator->()
{
return _ptr;
}
T& operator* ()
{
return *_ptr;
}
private:
T* _ptr;
};
class Date
{
public:
Date()
{
cout << "Date()" << endl;
}
~Date()
{
cout << "~Date()" << endl;
}
int _year;
int _mouth;
int _day;
};
int main()
{
AutoPtr<Date>ap(new Date);
//AutoPtr<Date>copy(ap);
AutoPtr<Date>aap(new Date);
aap = ap;
ap->_year = 2019;
//ap.operator->()->_year = 2019;// 本应改是这样的
return 0;
}
#endif
#if 0
//std::unque_ptr == boost::scoped_ptr
class Date
{
public:
Date()
{
cout << "Date()" << endl;
}
~Date()
{
cout << "~Date()" << endl;
}
int _year;
int _mouth;
int _day;
};
//模拟实现
template<class T>
class UniquePtr
{
public:
UniquePtr(T* ptr = nullptr)
:_ptr(ptr)
{}
~UniquePtr()
{
if (_ptr)
delete _ptr;
}
T& operator* ()
{
return *_ptr;
}
T* operator-> ()
{
return _ptr;
}
private:
#if 0
//C++98防拷贝的方式，只声明不实现+声明成私有的
UniquePtr(UniquePtr<T> const&);
UniquePtr& operator=(UniquePtr<T> const&);
//UniquePtr<T> operator=(UniquePtr<T> const&);
#endif
// C++11防拷贝方式:delete （公有私有都可以）
UniquePtr(UniquePtr<T> const&) = delete;
UniquePtr& operator= (UniquePtr<T> const&) = delete;
//UniquePtr<T> operator= (UniquePtr<T> const&) = delete;
private:
T* _ptr;
};
int main()
{
//unique_ptr<Date> up(new Date);
//unique_ptr 的设计思维非常粗暴-防拷贝， 也就是不让拷贝和赋值。
//unique_ptr<Date> copy(up);
//..
UniquePtr<Date> up(new Date);
UniquePtr<Date> copy(up);
UniquePtr<Date> cup(new Date);
cup = up;
return 0;
}
#endif 0
//std::shared_ptr 通过引用计数支持智能指针对象的拷贝
class Date
{
public:
Date()
{
cout << "Date()" << endl;
}
~Date()
{
cout << "~Date()" << endl;
}
int _year;
int _mouth;
int _day;
};
//1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
//2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
//3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
//4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就
// 成野指针了。
//模拟实现
//因为++/--不是一个原子操作，所以引用计数的++/--会引发线程安全问题,因此需要加锁.
#include<mutex>
template<class T>
class SharedPtr
{
public:
SharedPtr(T* ptr = nullptr)
:_ptr(ptr)
,_count(new int(1))
,_mutex(new mutex)
{}
~SharedPtr()
{
Release();
}
SharedPtr(const SharedPtr<T>& sp)
:_ptr(sp._ptr)
,_count(sp._count)
,_mutex(sp._mutex)
{
AddCount();
}
//*this = sp
SharedPtr<T>& operator= (const SharedPtr<T>& sp) //这两个有什么区别？
//SharedPtr& oeprator= (const SharedPtr<T>& sp)
{
//if (this != &sp)
if(_ptr != sp._ptr)
{
//释放管理的旧资源
Release();
//共享管理新对象的资源，并增加引用计数
_ptr = sp._ptr;
_count = sp._count;
_mutex = sp._mutex;
AddCount();
}
return *this;
}
T& operator* ()
{
return *_ptr;
}
T* operator-> ()
{
return _ptr;
}
void AddCount()
{
//加锁或者使用加1的原子操作
_mutex->lock();
++(*_count);
_mutex->unlock();
}
int UseCount()
{
return *_count;
}
private:
void Release()
{
bool deleteflag = false; //设一个标签,为了最后释放_mutex
//引用计数减一，如果减到0，则释放资源
_mutex->lock();
if (--(*_count) == 0) //前置--,先--再判断
{
delete _ptr;
delete _count;
deleteflag = true;
}
_mutex->unlock();
if (deleteflag == true)
delete _mutex;
}
private:
T* _ptr;
int* _count; //引用计数，因为要多个对象同这个计数操作，因此得是int*
mutex* _mutex; //1.互斥锁, 为了线程安全
//2. 智能指针管理的对象是存放在堆上的，两个线程同时去访问，会导致线程安全问题
};
//shared_ptr存在循环引用的问题
struct ListNode
{
int _data;
//shared_ptr<ListNode> _prev;
//shared_ptr<ListNode> _next;
//为了解决shared_ptr的循环引用问题,使用了weak_ptr，他是一个弱指针。
weak_ptr<ListNode> _prev;
weak_ptr<ListNode> _next;
//解决方案：在引用计数的场景下，把节点中的_prev和_next改成
//weak_ptr就可以了
//原理就是，node1->_next = node2;和node2->_prev = node1时
//weak_ptr的_next和_prev不会增加node1和node2的引用计数
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
//如果不是new出来的对象如何通过智能指针管理呢？
//其实shared_ptr设计了一个删除器来解决这个问题
//仿函数删除器
#include <stdlib.h>
template<class T>
struct FreeFunc
{
void operator() (T* ptr)
{
cout << "free:" << ptr << endl;
free(ptr);
}
};
template<class T>
struct DeleteArrayFunc
{
void operator() (T* ptr)
{
cout << "delete[]" << ptr << endl;
delete[] ptr;
}
};
int main()
{
//shared_ptr<Date> sp(new Date);
//shared_ptr<Date> copy(sp);
//cout << sp.use_count() << endl;
//cout << copy.use_count() << endl;
//..
//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;
//..
//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;
FreeFunc<int> freeFunc;
shared_ptr<int> sp1((int*)malloc(4), freeFunc);
DeleteArrayFunc<int> deleteArrayFunc;
shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
return 0;
}
