提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
1.线程
C++的线程和linux下的多线程基本一致，具体使用可以查看文档：
链接: Windows线程库使用文档
这里着重说一下几个需要注意的点：
2.异常
传统的错误处理机制：
- 终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
- 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。
2.1 C++异常概念
异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。
1.throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
2.catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异常，可以有多个catch进行捕获。
3.try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。
如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。
2.2 C++异常使用
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。
下面是一个网络服务的异常例子：
int main()
{
while (1)
{
this_thread::sleep_for(chrono::seconds(1));
try {
HttpServer();
}
catch (const Exception& e) // 这里捕获父类对象就可以
{
// 多态
cout << e.what() << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
}
return 0;
}
2.3 异常的重新抛出
有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
return (double)a / (double)b;
}
void Func()
{
// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
// 重新抛出去。
int* array = new int[10];
try {
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
catch (...)
{
cout << "delete []" << array << endl;
delete[] array;
throw;
}
// ...
cout << "delete []" << array << endl;
delete[] array;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
return 0;
}
2.4 异常安全和规范
异常安全：
1.构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
2.析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
3.C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题。
异常规范：
- 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
- 函数的后面接throw()，表示函数不抛异常。
- 若无异常接口声明，则此函数可以抛掷任何类型的异常。
3.智能指针
下面我们先分析一下下面这段程序有没有什么内存方面的问题？
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
// 1、如果p1这里new 抛异常会如何？
// 2、如果p2这里new 抛异常会如何？
// 3、如果div调用这里又会抛异常会如何？
int* p1 = new int;
int* p2 = new int;
cout << div() << endl;
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
我们知道除0会抛异常，但是如果new也抛异常呢？(很有可能new失败)，那么这样的话捕获异常就会非常麻烦，我们对什么都要捕获一下！并且捕获异常会造成直接走异常了，会导致后面的delete无法正常进行，造成内存泄露！！
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
3.1 RALL特性
为了解决上面的问题，那么智能指针就出现了！！
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
3.2 智能指针的问题
那么拷贝问题如何解决？
那么出现了auto_ptr(C++98)、unique_ptr(C++11)、shared_ptr(C++11)三个东西
3.2.1 auto_ptr
namespace bit
{
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
// 管理权转移
sp._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
// 检测是否为自己给自己赋值
if (this != &ap)
{
// 释放当前对象中资源
if (_ptr)
delete _ptr;
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
int main()
{
std::auto_ptr<int> sp1(new int);
std::auto_ptr<int> sp2(sp1); // 管理权转移
// sp1悬空
*sp2 = 10;
cout << *sp2 << endl;
cout << *sp1 << endl;
return 0;
}
auto_ptr 的设计存在一些严重的问题，尤其是在涉及容器（如 std::vector）和多线程环境时。最主要的问题是管理权转移会导致一个对象在多个 auto_ptr 之间的共享和管理变得非常困难，甚至不可能。因此，auto_ptr 无法安全地用于现代 C++ 编程。
因此其是一个失败的设计，已经被弃用！
3.2.2 unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理.
unique_ptr 是 C++11 引入的一种智能指针，用于独占管理动态分配的资源。与 auto_ptr 不同，unique_ptr 不允许共享或复制，从而避免了管理权转移带来的问题。它确保了资源在任何时候都只有一个拥有者，当这个拥有者销毁时，资源也随之销毁。
namespace bit
{
template<class T>
class unique_ptr
{
public:
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
unique_ptr(const unique_ptr<T>&sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
private:
T* _ptr;
};
}
int main()
{
//bit::unique_ptr<int> sp1(new int);
//bit::unique_ptr<int> sp2(sp1);
std::unique_ptr<int> sp1(new int);
std::unique_ptr<int> sp2(sp1);
return 0;
}
unique_ptr 是一种智能指针，确保独占管理资源，避免了 auto_ptr 的管理权转移问题。它通过删除拷贝构造和赋值操作符来实现独占所有权，确保资源在 unique_ptr 销毁时被正确释放。由于其简单而有效的设计，unique_ptr 是现代 C++ 编程中管理动态资源的推荐方式。
3.2.3 shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
引用计数是一种用于跟踪资源（如动态分配的对象）有多少个所有者的方法。每当创建一个 shared_ptr 副本时，引用计数会增加；每当销毁一个 shared_ptr 实例时，引用计数会减少。当引用计数降为零时，资源会被释放。
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace bit
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _pRefCount(new int(1))
, _pmtx(new mutex)
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pRefCount(sp._pRefCount)
, _pmtx(sp._pmtx)
{
AddRef();
}
void Release()
{
_pmtx->lock();
bool flag = false;
if (--(*_pRefCount) == 0 && _ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
delete _pRefCount;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
}
}
void AddRef()
{
_pmtx->lock();
++(*_pRefCount);
_pmtx->unlock();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)
{
Release();
_ptr = sp._ptr;
_pRefCount = sp._pRefCount;
_pmtx = sp._pmtx;
AddRef();
}
return *this;
}
int use_count()
{
return *_pRefCount;
}
~shared_ptr()
{
Release();
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
int* _pRefCount;
mutex* _pmtx;
};
}
// shared_ptr智能指针是线程安全的吗？
// 是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的
// 指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了
// 引用计数的线程安全问题，是智能指针要处理的
int main()
{
bit::shared_ptr<int> sp1(new int);
bit::shared_ptr<int> sp2(sp1);
bit::shared_ptr<int> sp3(sp1);
bit::shared_ptr<int> sp4(new int);
bit::shared_ptr<int> sp5(sp4);
//sp1 = sp1;
//sp1 = sp2;
//sp1 = sp4;
//sp2 = sp4;
//sp3 = sp4;
*sp1 = 2;
*sp2 = 3;
return 0;
}
shared_ptr 是一种智能指针，用于多个所有者共享同一资源。它通过引用计数来管理资源的生命周期，引用计数的增加和减少是线程安全的，但资源本身的访问不是线程安全的。这使得 shared_ptr 在现代 C++ 编程中非常有用，尤其是在需要共享资源的多线程环境中。
3.3 手撕shared_ptr
尤其要注意自己给自己赋值！！！
shared_ptr.h:
#pragma once
#include<iostream>
using namespace std;
#include<atomic>
namespace bit
{
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr)
, _pcount(new atomic<int>(1))
{}
// sp2(sp1)
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
{
(*_pcount)++;
}
// sp1 = sp3;
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)
{
this->release();
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
void release()
{
if (--(*_pcount) == 0)
{
// 最后一个管理的对象，释放资源
delete _ptr;
delete _pcount;
}
}
~shared_ptr()
{
release();
}
int use_count()
{
return *_pcount;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
atomic<int>* _pcount;
};
}
main.cpp:
#include<iostream>
#include<string>
#include<thread>
#include<vector>
#include<mutex>
#include<atomic>
#include<condition_variable>
#include "shared_ptr.h"
using namespace std;
class A
{
public:
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
~A()
{
cout << "~A()" << endl;
}
//private:
int _a1 = 1;
int _a2 = 1;
};
int main()
{
bit::shared_ptr<A> sp1(new A(1, 1));
bit::shared_ptr<A> sp2(sp1);
cout << sp1.use_count() << endl;
bit::shared_ptr<A> sp3(new A(2, 2));
bit::shared_ptr<A> sp4(sp3);
bit::shared_ptr<A> sp5(sp4);
cout << sp3.use_count() << endl;
sp1 = sp3;
sp2 = sp3;
bit::shared_ptr<A> sp6(new A(3, 3));
sp6 = sp6;
sp3 = sp4;
return 0;
}
3.4 shared_ptr的缺陷——循环引用与解决(weak_ptr)
为了解决这个缺陷，提出了weak_ptr！
weak_ptr就是在循环引用的时候不去增加引用计数！
3.5 定制删除器
如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题！
提示：这里对文章进行总结：
扫一扫
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
