C++11增加了大量新的特性,比如正则表达式,范围for,auto,unordered map\set,和非常重要的线程库,右值引用和移动语义,lamber表达式和智能指针.
列表初始化
在C++98中,我们初始化一个数组是使用{}进行的
int array[] = {1,2,3,4};
但是对于一些自定义类型却不能使用.因此C++11统一了这些写法
vector<int> v{1,2,3};
int y{ 3 };
int* arr = new int[3]{ 1,2,3 };
map<int, int> m{{1,1},{2,2},{3,3}};
我们自定义的类型也可以用这种方式初始化,本质上都是在调用构造函数.了解即可,和正常初始化没有什么区别.
为了支持这个东西,C++11里添加了一个容器
template<class T> class initializer_list;

给{}时会先创建一个initializer_list,然后去遍历这个容器去进行插入,以vector为例,我们编写
vector<int> v{1,2,3};
做的实际上首先是
initializer_list<int> ilt = {1,2,3}
然后调用vector对该容器的构造函数
vector(initializer_list<T> l);
在该构造函数里,做的事情就是把l的元素一个一个插入vector.
类型推导
在C++98中就已经存在了auto关键字,但是它是一个存储类型的说明符,表明变量是局部自动存储类型.而在C++11中,auto舍弃了原有的用法,而是变成了自动类型推断,这就要求必须对变量进行显式的初始化,变量类型则由编译器进行推断
C++11还多了一个关键字:declytype,它允许我们把变量初始化为某个类型
int a=0,b=0;
decltype(a+b) c;
cout << typeid(c).name() << endl;
这样就把c定义为了和a+b同样的类型.这样的变量类型推导叫做运行时推导(RTT).
新容器
在C++11中,提供了几个新容器array,forward_list
array是一个定长数组
template < class T, size_t N > class array;
实际使用不好用,原因在于它是定长的,灵活性很差.
forward_list就是一个单链表,定义为
template < class T, class Alloc = allocator<T> > class forward_list;
和链表的区别在于没有反向迭代器,不支持尾插尾删和insert,实际使用依然较少.比较有用的就是unordered_map/set.哈希
类的默认行为
如果我们不去编写构造函数,系统会调用默认的构造函数类和对象.
但是如果我们实现一个拷贝构造
class A
{
public:
A(const int& a)
:_a(a)
{}
private:
int _a = 10;
}
这个时候我们直接没有办法创建对象,因为我们实现了一个拷贝构造,此时系统因为有实现的构造函数就不再调用默认的拷贝构造了.所以因为缺乏构造函数,就没有办法创建对象
为了解决这个问题,我们可以指定使用默认的构造函数,语法如下:
class A
{
public:
A() = default;
A(const int& a)
:_a(a)
{}
private:
int _a = 10;
}
如果我们想要让A类对象不允许拷贝,C++98的做法是只声明不实现,这样一旦调用拷贝构造就会报链接错误.
A(const A& aa);
A& operator=(const A& aa);
但是缺陷是别人可以自己定义一个拷贝构造函数.为了解决这个缺陷,我们可以使用private进行限定.这样在类外也不能对其进行定义
class A
{
public:
A() = default;
private:
A(const A& aa);
A& operator=(const A& aa);
int _a = 10;
}
在C++11中复用了delete关键字,于是可以写为
class A
{
public:
A() = default;
A(const A& aa)=delete;
A& operator=(const A& aa)=delete;
private:
int _a = 10;
}
右值引用与移动语义
C++98提出的引用叫做左值引用C++入门,C++11提出了右值引用.作为引用,本质是来说都是在给被引用对象起别名
右值与左值
首先需要解释一下左值和右值的含义.
int x = 10;//x是左值,10是右值
int y = x; //这里x还是左值,y也是左值
可以修改的就被认为是左值,通常是变量.右值通常是常量或表达式或函数返回值等临时对象
//左值引用
int a = 0;
int& b = a;
//右值引用
int x = 1, y = 2;
int&& c = x+y;
也就是说左值引用是在对变量进行引用,右值引用则是在对常量或临时对象进行引用.一般来说左值引用不能引用右值,但是右值引用本质是在对常量进行引用,所以可以使用
const int& a =10;
进行.而右值引用不能引用左值,但是可以引用move后的左值
int a=0;
int&& c = a; //err
int&& c = move(a);
需要注意的是:右值引用是在给常量起别名,需要经过编译才能知道.而宏定义则是在预处理阶段就展开替换.
在C++11中右值又被分为纯右值(常量或临时对象)和将亡值(自定义类型的临时对象).
右值引用的作用
右值引用的最大优点就是能够区分出将亡值,并以此来提高效率
template<class T>
void f(const T& a)
{
cout << "void f(const T& a)" << endl;
}
template<class T>
void f(const T&& a)
{
cout << "void f(const T&& a)" << endl;
}
int main()
{
int a = 10;
f(a);
f(10);
return 0;
}
现在我们编写了两个f,这两个函数构成重载.我们去进行调用
int a = 10;
f(a);
f(10);

如果不去编写右值引用,则两个都会通过左值引用进行调用

右值引用的意义就在于区分出将亡值来提高效率.我们在自己实现stl容器的时候,拷贝构造是这样实现的
String(const String& s)
{
_str = new char[strlen(s._str)+1];
strcpy(_str,s._str);
}
实现的是string的深拷贝.
String f(const char* str)
{
String tmp(str) ;
return tmp;
}
String s1("左值");
String s2(s1);
String s3(f("右值"));
调用拷贝时有的时候是传左值,有的时候传右值.用常规写法调用的都是深拷贝.而我们这里传入的是一个将亡值.
我们来分析一下逻辑,我通过函数f构造了一个将亡值tmp并返回,传给s3后调用拷贝构造,用完s3就析构了.那为不直接把tmp给s3呢?这就是右值引用存在的意义
String(String&& s)
:_str(nullptr)
{
swap(_str,s._str);
}
这样的拷贝叫做移动拷贝.它的意义在于把临时对象的无用深拷贝节省,变成资源的转移.move做的本质是一个强制类型转换,强行把左值转换为右值.
template <typename T>
constexpr typename std::remove_reference<T>::type&& move(T&& arg) noexcept {
return static_cast<typename std::remove_reference<T>::type&&>(arg);
}
所以
string s1;
string s2(move(s1));
s1被move强转为右值,构造完s2后被swap替换成了nullptr.同样的,我们再来实现一下赋值
string& operator=(string && s)
{
swap(_str,s._str);
return *this;
}
因此所有需要深拷贝的容器都应该提供右值引用的接口.
string operator+(string s1,string s2)
{
string s(s1.append(s2));
return ret; //返回右值
}
我们实现一个相加接口,如果我们没有实现右值的拷贝构造,那么这里返回的时候就会先形成一个临时变量ret,然后把s的值通过深拷贝拷贝给ret进行返回后析构(这一步会在现代C++编译器中被优化),造成了大量性能的浪费.换言之,只要通过传值返回,返回的就是拷贝(右值),就会出现深拷贝.
我们之前讲容器的时候始终有两个接口是没有讲的,那就是emplace/emplace_back
template <class... Args> iterator emplace (const_iterator position, Args&&... args);
以及常规的insert
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template <class InputIterator>iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, initializer_list<value_type> il);
可以看到在C++11以后,所有插入都提供了右值引用的接口.它比常规方法更优.因为常规插入的思路是把val深拷贝到position位置,但是如果传过来的是一个将亡值(右值),那么更好的做法是通过移动拷贝.
emplace实际上就是针对右值的插入,有人说emplace比insert高效,但是从实现来看,C++11已经为插入提供了右值的接口,如果是左值,调用emplace也没有发生移动拷贝,因此并不一定.
总结一下:右值引用的核心作用是通过右值判断将亡值,利用移动构造和移动拷贝去减少拷贝的次数.常用于右值引用做参数和返回值.
完美转发
右值在传递的时候属性会发生丢失,
void fun(int&& x) { cout << "r_val" << endl; }
void fun(int& x) { cout << "l_val" << endl; }
template<class T>
void p_forward(T&& x)
{
fun(x);
}
int main()
{
p_forward(10);
int a;
p_forward(a);
p_forward(move(a));
return 0;
}
PS:下面这种写法
template<class T>
void forward(T&& x)
叫做转发引用,这种引用允许同时接收左值和右值.我们的理想情况是输出l_val,l_val,r_val.

从实际情况来看,传到forward()函数内的时候数据的左右值属性还存在,但是在传入fun()后属性就丢失了,导致全部进了左值.为了保留我们的左右值属性,我们需要添加完美转发forward<T>
void p_forward(T&& x)
{
fun(forward<T>(x));
}
lambda表达式
lambda表达式本质上对标的是函数.
当我们自定义了一个数据类,要实现比较的时候,每一种属性都会有多个用于比较的仿函数/函数指针.这就导致属性一多仿函数就会变得很复杂.于是我们就引入lambda表达式,它实际上就是个匿名函数,它的语法如下:
[capture-list] (parameters) mutable -> returntype { statement }
capture-list:捕捉列表.用于读取参数parameters:参数列表,和函数的参数一样mutable:默认情况下lambda函数是一个const函数,使用该修饰符可以取消其常属性.->returntype:返回值类型,没有可省略statement:函数体
我们可以理解为是定义在函数中的匿名函数.比如我要实现a+b,就会有两种写法
int a=3,b=4;
add1 = [a,b]()->int{return a+b;};
add2 = auto [](int xl, int x2)->int{return x1 + x2;};
add1();
add2(a,b);
它的写法上实际上和正常函数基本一致.有了这个东西,我们不再需要定义很多仿函数,而是可以在需要使用的时候局部定义.lambda表达式对标的实际上就是仿函数和函数指针.
捕捉对象可以传值捕捉,也可以传引用捕捉.
传值捕捉:[a,b]表示捕捉a和b,[=]表示值捕捉该作用域的所有文件.需要注意的是传值捕捉的对象是不能被改变的.如果要改变需要加上mutable
auto swap[a,b]()
{
int c = a;
a = b;
b = c;
}//error
auto swap[a,b]()mutable
{
int c = a;
a = b;
b = c;
}
但是这样依然无法完成交换,因为改变的实际上是a,b对象的拷贝
传引用捕捉:[&a,&b]表示捕捉a和b.[&]表示引用捕捉统一作用域所有对象.
auto swap[&a,&b]()
{
int c = a;
a = b;
b = c;
}
为了探究lambda表达式的实现,我们转到汇编

在调用一个lambda表达式函数的时候,实际上它去call 了operator(),这种实现方式和我们写仿函数的时候是一样的.也就是说lambda表达式底层还是一个仿函数.
在定义了一个lambda表达式后,编译器会生成一个lambda_uuid的类,这个类里面对operator()进行了重载,它的参数和实现就是我们编写的lambda表达式的参数和实现.
所以我们在调用add(a,b)的时候就变成了
add.operator()(a,b)
线程库
在linux种,创建进程通过fork()Linux下的进程.创建线程则是使用posix的pthread.这实际上也是一个第三方库.而windows下又是另一套API.如果写了一个多线程的程序,想要兼容windows和linux,就要使用条件编译
#ifdef _WIN32
CreateThread (... )
#else
pthread_create(...)
#endif
现在C++11已经帮我们做好了这件事

线程已经被封装为了一个库

#补充 等linux那边学完
异常
异常是面向对象语言中处理错误的一种方式,传统处理错误的方式为
- 返回错误码Linux的进程控制.有些API接口都会把错误码放到
errno中. - 终止程序,比如数组越界访问程序就会被终止.我们也可以主动调用
exit(-1)对程序进行终止
传统错误处理方法已经不能处理有一些函数的错误了,比如某个函数是通过返回值拿数据,那么发生错误的时候是不能返回错误码的.面对这种问题,很多时候直接通过assert进行终止程序.
另一种情况是函数栈很深,一层一层返回错误码处理是很麻烦的.此外,拿到错误码还需要进行查找才知道是什么错,这样是比较麻烦的.
为了解决这些问题,C++采用抛异常的方式进行解决.出现错误后,我们通过捕获的方式去捕获错误.
try
{
vector<int> v = { 1,2,3,4 };
for (int i = 0; i <= v.size(); i++)
{
cout << v.at(i) << endl;
}
}
catch (exception& e)
{
cout << e.what() << endl;
}
这里会出现越界访问问题,可以使用try...catch语句去进行捕获

其中at实际上和operator[]是一样的,不过operator[]的报错是直接使用assert,而at则是抛出异常.
我们实现除法函数的时候
int div(int n,int m)
{
if(m == 0)
{
//return ?
}
return n/m;
}
为了使用传统返回错误码的方式
int div(int n,int m,int &ret)
{
if(m == 0)
{
return -1;
}
ret = n/m;
return 0;
}
但是会让人很不舒服,因此我们可以使用抛出异常
int div(int n, int m)
{
if (m == 0)
{
throw string("除零错误");
}
return n / m;
}
然后在调用的时候进行捕获
try
{
int m, n;
cin >> n >> m;
cout << div(n, m) << endl;
}
catch (string err)
{
cout << err << endl;
}

throw可以抛出任意类型的对象.如果发生异常,就会直接进入类型匹配的catch语句.如果没有找到就会报错
异常的类型匹配
异常的类型是通过抛出对象而引发的,它的类型决定了激活哪个catch.
被选中的处理代码在抛出异常以后总是去找类型匹配的最近的那一个catch语句.这个近取决于调用的顺序,会按照堆栈的顺序往回查找.如果找到了main的栈都还没有找到就会终止进程.这个过程叫做栈展开.

抛出异常后,会生成一个异常对象的拷贝,这个拷贝对象会在被catch后销毁
使用catch(...)能够捕获所有类型的异常,但是并不能知道捕获的异常的类型,一般会放到最后捕获遗漏的异常,避免程序终止.
实际中抛出和捕获的匹配原则有个例外,并不都是类型完全匹配,可以抛出的派生类对象,使用基类捕获
异常的重抛
有的时候我们new了一块内存,然后在抛出异常后就直接跳到了catch,导致new的内存没有被释放,就会发生内存泄漏.为了解决这个问题,我们可以先把异常捕获,然后进行delete,然后再将异常重新抛出,统一到外面处理
void Fun()
{
try {
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
catch (...)
{
cout << "delete []" << array << endl;
delete[] array;
throw;
}
}
自定义异常体系
在工程中,如果随意抛出异常会导致项目难以管理和开发,所以更合理的方式是:通过一个类去管理所有异常.类是可以继承的继承,而在异常体系中,抛出的异常如果是一个派生类对象,就可以通过捕获基类来捕获所有异常

在实际使用中,公司会提供一个基类,然后你可以随意抛出自己定义的异常,但是必须继承这个基类.这样外层捕获的时候只需要捕获这个基类就可以.
class Exception
{
public:
Exception(const char* errmsg, int errid)
:_errmsg(errmsg),_errid(errid)
{
}
virtual string what()=0;
protected:
int _errid;
string _errmsg;
};
class SqlException :public Exception
{
public:
SqlException(const char* errmsg,int errid)
:Exception(errmsg,errid)
{ }
string what()
{
return string("Sql error:")+=_errmsg;
}
};
假设我们在某个函数中抛出异常,并在主函数中进行捕获
void SqlStart()
{
throw SqlException("数据库启动失败", 1);
}
int main()
{
try
{
SqlStart();
}
catch (Exception& e)
{
cout << e.what() << endl;
}
return 0;
}
并且这里调用what的时候需要构成一个多态,因为这里是一个引用,并且在类内部还完成了虚函数的重写
标准异常体系
C++中已经定义了这样的一个异常体系

不过这套异常体系定义的并不好,大部分时候还是使用公司内部自己定义的一套体系.
异常规范
为了提高效率,我们需要规范我们的异常体系.它的目的是告诉使用者某个函数能够抛出哪些异常,因此就有了异常规格说明,其目的是为了让函数使用者知道该函数可能抛出的异常有哪些.可以在函数的后面接throw(类型),列出这个函数可能抛掷的所有异常类型。
//这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void funO() throw(A,B,C,D);
//这里表示这个函数只会抛出bad_al1oc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
//这里表示这个函数不会抛出异常
void* operator delete(std::size_t size, void* ptr) throw();
//C++l1中新增的noexcept,表示不会抛异常
thread (thread&& x) noexcept;
智能指针
由于C++没有gc(垃圾回收器),这就导致我们new出来的资源是需要进行手动释放的,这样就会导致资源非常容易泄漏.在异常中
void f1()
{
throw invalid_argument("异常");
}
void f2()
{
int* p1 = new int;
try
{
f1();
}
catch(exception& e)
{
delete(p1);
throw e;
}
delete p1;
}
int main()
{
try
{
f2();
}
catch(...)
{
}
}
如果不这么写,一但发生异常就会导致p1忘记释放,非常反人类.为了解决这些问题,我们引入智能指针.它本质上是对指针进行封装成为一个类
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{ }
~SmartPtr()
{
if (_ptr) delete _ptr;
}
private:
T* _ptr;
};
它的原理非常简单,构造函数中创建,析构函数中释放.这样new出来的指针在出生命周期后就自动在析构函数中释放,这样就不再需要手动处理了
void f1()
{
throw invalid_argument("异常");
}
void f2()
{
int* p1 = new int;
SmartPtr<int> sp(p1);
f1();
}
int main()
{
try
{
f2();
}
catch (...)
{
}
}

这种根据对象生命周期来控制程序资源的方式就叫做RAII.本质就是在对象被构造时获得资源,析构时就释放资源.
对于一个指针,要访问它就要重载*和->,所以
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
但是还有问题
int main()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(sp1);
return 0;
}
一旦调用拷贝构造两个智能指针就指向了同一块空间,然后就二次析构直接崩溃了

为了解决这个问题,C++给出了三个方案
- 管理权转移,对应C++98中的
auto_ptr - 防拷贝,对应
unique_ptr - 引用计数,对应
shared_ptr,但是会出现循环引用问题,所以又提出weak_ptr
auto_ptr
auto_ptr是C++98中提出的解决方案,不过这个方案是不合理的.它的解决方案是实现一个拷贝构造
auto_ptr(auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
这样当我们进行拷贝构造的时候,比如
auto_ptr<int> ap1;
auto_ptr<int> ap2(ap1);
时,管理权就直接从ap1变为ap2.拷贝构造的时候直接把ap1指向的空间置为空.这是极其不合理的.
unique_ptr
unique_ptr的解决方法非常简单粗暴,直接不允许进行拷贝,这在C++11里是很好实现的
unique_ptr(unique_ptr<T>& up) = delete;
unique_ptr<T> operator=(unique_ptr<T>& up) = delete;
这种方案虽然简单,但是是比较推荐的.但是一旦需要拷贝就无法使用了

shared_ptr
它的解决方案是通过一个引用计数,看看有多少个指针指向了这块空间.那么在发生拷贝后就让count++,析构的时候检查count是否为0.
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr),_count(1)
{
}
~shared_ptr()
{
if (--_count == 0 && _ptr)
{
cout << "delete " << _ptr << endl;
delete _ptr;
}
_ptr = nullptr;
}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr),_count(sp._count)
{
_count++;
sp._count++;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int _count;
};
int main()
{
myptr::shared_ptr<int> sp1(new int);
myptr::shared_ptr<int> sp2(sp1);
return 0;
}
结果压根没有发生释放

原因是两个shared_ptr并没有共享同一个_count,导致其中一个进入析构函数后_count--,但是完全没有影响另一个的_count.
并且需要注意,不能改为static,尽管这样能解决目前的问题,但是由于static归整个类共享,一旦创建了多个shared_ptr依然会出现问题.
为了解决这个问题,我们把count改为指针,让所有拷贝的指针的_pcount指向同一块空间.
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr)
:_ptr(ptr),_pcount(new int(1))
{
}
~shared_ptr()
{
if (--(*_pcount) == 0 && _ptr)
{
cout << "delete " << _ptr << endl;
delete _ptr;
delete _pcount;
}
_ptr = nullptr;
}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr),_pcount(sp._pcount)
{
(*_pcount)++;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
};
最后来写一下赋值,当sp1=sp2的时候,潜台词是sp1不再管理原来的资源,因此要对sp1的资源进行处理
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
if (this != &sp)
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
(*_pcount)++;
}
return *this;
}
而shared_ptr也是有问题的,在多线程情况下,sp1和sp2同时拷贝sp的时候,就有可能导致相加错误.换言之,目前的shared_ptr不是线程安全的.为了解决这个问题,我们可以进行加锁.为了让同一个shared_ptr极其引用共享同一个锁,因此还是使用指针类型.然后当_pcount++的时候就上锁,加完后再解锁
void add_ref_count()
{
_pmtx->lock();
(*_pcount)++;
_pmtx->unlock();
}
然后引用计数++就使用该函数,--的时候同样上锁保护
void release()
{
_pmtx->lock();
if (--(*_pcount) == 0 && _ptr)
{
cout << "delete " << _ptr << endl;
delete _ptr;
delete _pcount;
}
_pmtx->unlock();
}
~shared_ptr()
{
release();
}
然后问题又来了_pmtx什么时候释放?当彻底完成释放后再删除_pmtx,所以再添加一个标志位
void release()
{
_pmtx->lock();
bool flag = false;
if (--(*_pcount) == 0 && _ptr)
{
cout << "delete " << _ptr << endl;
delete _ptr;
delete _pcount;
flag = true;
}
_pmtx->unlock();
if (flag)
{
delete _pmtx;
}
}
然而它也有它的缺陷–循环引用.它只在特殊场景下会出现,我们创建一个循环链表,析构的时候直接删除每个结点
struct ListNode
{
int val;
ListNode* _next;
ListNode* _prev;
~ListNode()
{
cout << "~ListNode" << endl;
}
};
int main()
{
ListNode* n1 = new ListNode;
ListNode* n2 = new ListNode;
n1->_prev = n2;
n2->_prev = n1;
delete n2;
delete n1;
return 0;
}
当我们引入智能指针:
myptr::shared_ptr<ListNode> n1(new ListNode);
myptr::shared_ptr<ListNode> n2(new ListNode);
n1->_prev = n2;
n2->_next = n1;
编译不通过,ListNode* _prev是一个原生指针,不能被赋值为智能指针.所以我们要把_prev也改为智能指针.然后调用以后发现没有发生析构了

发生甚么事了?原因是现在发生了循环引用,我们来画个图分析分析

在进行链表链接的时候也调用了operator=,n1->_next和n2共享一个_pcount,n2->_prev和n1共享一个_pcount.建立连接后引用计数++了,在该析构的时候各自进行_count--,然后发现均是1,于是就不析构了.而n1和n2不析构,就没有东西调用内部成员变量的析构函数,于是整个结构体陷入一个死锁状态,谁都不会被析构,这就是循环引用问题.
weak_ptr
为了解决这个问题,C++又引入了weak_ptr.出现这个问题的原因是二者发生了互相引用,但是如果只有一个发生了引用,那就能正常析构了.所以如果我们只让一个方向增加引用计数,另一个方向不增加即可.这就是weak_ptr的作用,它的意思就是:我不参与智能指针的管理以此来规避这个问题,但同时我要支持智能指针的赋值(opearator=),所以我们需要专门封装一个类.
严格来说weak_ptr不是智能指针,因为它没有RAII,它不负责释放资源,它的存在就是专门来解决shared_ptr的问题的.
template<class T>
class weak_ptr
{
public:
weak_ptr(const shared_ptr<T>& sp)
_ptr(sp._ptr)
{
}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp._ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
对于weak_ptr的operator=,做的只是单纯的指针拷贝,不会增加引用计数.
同时为了能访问shared_ptr->_ptr,我们要将weak_ptr声明为友元,为了让编译器认识,我们还需要做前置声明.
template<class T>
class weak_ptr;
template<class T>
class shared_ptr
{
friend class weak_ptr<T>;
}
然后把一个方向定义为weak_ptr即可
struct ListNode
{
int val;
myptr::shared_ptr<ListNode> _next;
myptr::weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode" << endl;
}
};

这样其中有一个shared_ptr的引用计数会是1,能被正常释放,释放的时候会去释放所有成员变量,而next是一个shared_ptr,调用其析构函数后,由于代码中是n1->_next = n2;,所以n1->_next于n2共享一个_pcount,因此n1->_next被释放以后,*(n2._pcount)--,这样n2也能被正常释放
智能指针的发展历史
由于C++没有gc,申请的资源需要手动释放,尤其是引入异常以后程序的执行流发生改变,极其容易发生内存泄漏.于是就引入了RAII思想,进一步引入智能指针.
而智能指针经历了10几年发展的”血泪史”,最开始是auto_ptr,但是赋值的管理权转移是设计的重大缺陷,稍有不慎就是空指针问题,因此算得上是一版”废案”
官方在剩下10几年始终没有作为,于是有一帮人觉得C++库过于简陋,就开始了手搓过程,最终形成一个库–boost,其中就包含了智能指针,主要是scoped_ptr/scoped_array,用于分别管理地址和数组,实际上就对应了现在的unique_ptr.然后还搞了一个shared_ptr/shared_array,相当于现在的shared_ptr,同时就引入weak_ptr,这个库现在的使用依然广泛.boost
最后官方看不下去了,终于在C++11中引入了智能指针,变为现在我们看到了unique_ptr,shared_ptr和weak_ptr,并且大量参考了boost的实现,包括右值引用,移动语句,线程池,正则表达式等.
在boost中,区分了ptr/array,原因是析构的时候一个调用delete,一个调用delete[].而在C++11中没有,原因是他们使用了定制删除器.定制删除器本质上来说是一个仿函数,然后智能指针的模板参数就传入相应的析构函数
template<class T>
struct Free
{
void operator()(T* p)
{
free(p);
}
};
template<class T>
struct Fclose
{
void operator()(FILE* p)
{
fclose(p);
}
};
RAII
智能指针是RAII一种思想的实现,本质就是在利用构造和析构实现一些事情,因为构造和析构都能自动调用.由此我们可以拓展一下:
在进行线程操作的时候,上锁的线程必须进行解锁,假设
void func()
{
throw string("err")
}
void f()
{
mutex mtx;
mtx.lock()
func();
mtx.unlock();
}
int main()
{
try
f();
catch(...)
{
}
}
这个时候只要func抛出异常就会进入main被捕获,这就导致没解锁,于是线程就被卡死了.
那么我们能不能把锁交给RAII思想设计一个锁的守卫管理呢?
template <class Lock>
class LockGuard
{
public:
LockGuard(Lock& lock)
:_lk(lock)
{
_lk.lock();
}
~LockGuard()
{
cout << "unlock" << endl;
_lk.unlock();
}
private:
Lock _lk;
};
看起来没啥问题,但是

原因在于锁是不允许拷贝的,所以:_lk(lock)报错.所以我们要改为
private:
Lock& _lk;
让它不进行拷贝,而是类内的_lk就是外面的锁本身.此外锁守卫本身不允许拷贝,所以还要
LockGuard(LockGuard<Lock>& lg) = delete;
LockGuard operator=(LockGuard<Lock>& lg) = delete;
内存泄漏
我们申请了资源但是没有进行释放,这就叫做内存泄漏.
我们在程序中开辟一块内存,但是我们发现在结束后,内存就自动被释放了,原因是进程在退出时,mm_struct会释放堆空间Linux的进程控制,因此一般的进程出现内存泄漏并没有太大的关系,只要进程不进入僵尸状态导致未被回收就没有问题.
那么内存泄漏的真正危害在哪?一般程序重启一下就解决了,那需要长期运行的呢?比如服务器和操作系统.这样的程序如果发生内存泄漏就会导致可用内存越来越少,这样很多服务就会操作失败.
那么如何解决呢?可以多使用RAII对程序进行管理,如果已经发生可以使用内存泄漏工具进行检测.比如valgrind,专门用于检测linux下内存泄漏问题
特殊类的设计
1.设计一个类,这个类只允许在堆上创建对象.
创建对象的时候肯定是通过构造函数创建的,如果我们把构造函数私有,类外就不能调用了,但是类内可以
class HeapOnly
{
public:
HeapOnly* GetObj()
{
return new HeapOnly;
}
private:
HeapOnly()
{
}
};
这样构造出来的HeapOnly就一定是在堆上的.但是由于GetObj是成员函数,要通过对象进行调用,但是现在我们就是要通过这个函数来构造对象.所以我们把它声明为static,这样就可以不用对象也能构造
HeapOnly* p = HeapOnly::GetObj();
但是创建了一个堆上的后,我们可以创建其在栈上的拷贝,所以我们还可以做防拷贝操作.声明为delete即可.
2.设计一个类,这个类只允许在栈上创建对象
思想同上
class StackOnly
{
public:
static StackOnly GetObj()
{
return StackOnly();
}
private:
StackOnly()
{}
};
但是这里不能禁止拷贝构造,因为传值返回需要一次拷贝.
另一种思路是把new进行重载
void* operator new(size_t size) = delete;
但是它有缺陷,我定义
static StackOnly st;
它依然不在栈上,而是在静态区
3.设计一个不能被拷贝的类
在C++98中,把拷贝构造和operator=声明为私有,这样类外既不能调用,也不能定义
class NoCopy
{
private:
NoCopy(NoCopy& cp);
NoCopy operator=(NoCopy& cp);
};
在C++11中则是定义为删除函数
class NoCopy
{
public:
NoCopy(NoCopy& cp)=delete;
NoCopy operator=(NoCopy& cp)=delete;
};
4.设计一个不能被继承的类
只需要将基类构造函数私有,这样派生类就无法调用基类构造函数进行构造
class NoHerit
{
private:
NoHerit()
{
}
};
在C++11中可以使用final堆类进行修饰
class NoHerit final
{
};
单例模式
设计模式是一套被反复使用,多数人知晓的经验总结,说白了就是代码套路.
我们之前已经学过一些设计模式,比如迭代器设计模式,适配器设计模式Stack&Queue.迭代器模式实际上隐藏了容器的底层结构,是基于面向对象的封装进行设计的.而适配器模式体现的则是复用
常见的还有工厂模式,装饰器模式,观察者模式等,以及最常用的单例模式.
单例模式指:一个类只能在全局有一个实例对象
假设一个进程有一个内存池,进程中多线程需要内存都要去内存池中取,那么这个内存池的类就可以设计为单例模式.
那么怎么实现?我现在不希望对象能够被随便创建,我就应该把构造函数封死,然后手动编写一个创建对象的函数.
class Singleton
{
public:
static Singleton GetInstace()
{
}
private:
Singleton()
{
}
};
然后我们希望的是只要创建了对象,所有东西访问该对象都是访问的同一个,所以我们可以创建一个静态对象,然后初始化为null,调用构造的时候判断,如果是空就说明该对象没有被创建过.同时还要禁止拷贝构造
class Singleton
{
public:
static Singleton* GetInstace()
{
if (_pinst == nullptr)
{
_pinst = new Singleton;
}
return _pinst;
}
Singleton(Singleton& s) = delete;
Singleton& operator=(Singleton& s) = delete;
private:
Singleton()
{
}
static Singleton* _pinst;
};
Singleton* Singleton::_pinst = nullptr;
但是目前还是有问题的,他有线程安全问题,如果应用在线程池,一定会有多个线程同时访问该线程池的问题.假设一开始没被实例化,多个线程来访问的时候发现这个对象是空,然后就进行创建,这就导致该对象会被实例化不止一次,不满足”单例”的设计要求.

