[朝圣]Thinking with Bjarne

最新推荐文章于 2023-01-16 21:58:53 发布

BUAA1306KSY

最新推荐文章于 2023-01-16 21:58:53 发布

阅读量81

点赞数

本文链接：https://blog.csdn.net/BUAA1306KSY/article/details/39560483

版权

<pre name="code" class="cpp"><span style="font-family:SimSun;font-size:18px;">很神奇地，我最近在接触了一些java之后总是很怀念C++，虽然C++有着很多令人诟病的缺陷，但是正是由于它有多种缺陷，才让人对委员会的新标准C++ 11和C++ 14更为期待，而且修缮这个语言所引进的新的语义又是如此地引人入胜。</span>

OK，anyway，就算我这一暑假几乎没怎么碰C++，可是我还是忘不了它……听起来这倒像是某种莫名的情愫，不是男女的情爱，当然更不是搞基…… 于是乎，也许是上天注定地，让我看到了ZJW的朋友圈——Bjarne要来PKU做讲座，题目是The Essence of C++。哇，听名字就好屌，不是吗？C++的精华……他要讲什么呢？引用？OOP？一切自待9月22日见分晓。就这样，当我在阳光大厅见到Bjarne本人的时候，伴随着全场热烈的掌声，我的心情也变得异常激动。但是会场的音效却是令人失望的，再加上我本人功力不是特别高，于是乎现场所得有限。但是我怎么会这样放弃呢……凭借着强大的备忘录功能我留下一些不懂的名词，终于在第二天获得了很多有用的东西！ ——————————————————请叫我分割线——————————————————————————— Use a handle！使用指针来对堆中的对象进行操作在C++中是一个司空见惯的事情。但是，指针（引用）并不是Exception safe的。为了做到异常安全，需要让对象的每一次资源分配都具有原子性，使资源分配成为对象生命周期的一部分，这种技术叫做RAII（Resource Acquisition Is Initialization）。在《C++ Primer》中这样描述——通过定义一个类来封装资源的分配和释放，可以保证正确释放资源。

由于在一个典型C++程序中动态分配内存是频繁使用的资源，所以C++标准中提供一个RAII封装类，叫做auto_ptr，也就是智能指针。

智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。当然，智能指针还不止这些，还包括复制时可以修改源对象等。智能指针根据需求不同，设计也不同（写时复制，赋值即释放对象拥有权限、引用计数等，控制权转移等）。

《More Effective C++》中这样写到：Smart Ptr are objects that are designed to look, act, and feel like build-in pointers but to offer greater functionality. They have a variety of applications, including resource management.

智能指针的关键特点是：

资源分配后立即由资源管理对象接管。

资源管理对象用析构函数来确保资源释放。

OK，auto_ptr是一个历史比较悠久的智能指针。在C++ 11里面将会提供另外的三种智能指针——shared_ptr、unique_ptr、weak_ptr。

unique_ptr和auto_ptr十分类似，都只允许一个对象同时只被一个智能指针所指向，即一个对象的所有权是唯一的。但是区别在于，unique_ptr是移动语义，它将不允许赋值和拷贝。

auto_ptr<int> ap(new int(88 );

auto_ptr<int> one (ap) ; // ok

auto_ptr<int> two = one; //ok

unique_ptr<int> ap(new int(88 );

unique_ptr<int> one (ap) ; // 会出错

unique_ptr<int> two = one; //会出错

但是如果右值是可以被unique_ptr赋值和拷贝的

unique_ptr<int> GetVal( ){

unique_ptr<int> up(new int(88 );

return up;

}

unique_ptr<int> uPtr = GetVal();   //ok

实际上上述语句

unique_ptr<int> uPtr = GetVal();

等价于

<p style="line-height: 26px;"><span style="font-family:SimSun;font-size:18px;">unique_ptr<int> up(new int(88 );</span></p><p style="line-height: 26px;"><span style="font-family:SimSun;font-size:18px;">unique_ptr<int> uPtr2 = std:move( up) ; </span></p>

即一个是隐式的move语义，一个是显式的move语义。

那么使用std::move语义到底有什么作用呢？

来看下面的例子：

vector<string> s;
vector<string> ReadFile(string file)
{
    vector<string> tmp;
   //read
   return tmp;
}

如果将一个vector这样传入传出，将会导致的过程是——将tmp拷贝到一个临时对象中，销毁tmp，将临时对象拷贝到s中，销毁临时对象。如果vector的长度是n的话，无疑这样做的效率是O(n)的。

如果使用move语义，简单地将tmp“移动”给s，实际上是交换了tmp对象的所有权，那么效率显然会降低到常数。

<pre name="code" class="cpp">vector<string> s;
vector<string> Read()
{
   vector<string> tmp;
   //read
   return std::move(tmp);
}

因此显式的move语义降低了对象在函数中传入传出的代价。当然你觉得可以用指针或者引用来解决这个问题，但是作为函数的返回值，右值只能由一个const引用来指向。这意味着，你将不能对数据进行任何的改写。如果你想在堆中创建一个对象，将意味着又多出一个对象的生命周期需要程序员自己管理，会使在大规模的对象创建中徒增不必要的麻烦。

std::move语义的出现，将对象在子函数中传入传出的代价降低，在面对流对象的时候将会出人意料地方便。

shared_ptr允许多个shared_ptr拥有同一个对象，并且通过引用计数的方式控制对象的生命周期。由于它满足标准容器对元素的要求，因此可以作为标准容器的元素使用。

但是在多线程的条件下，多个指针指向同一个对象总会给人感觉是线程不安全的。shared_ptr对线程安全的支持是——多线程写同一个shared_ptr是不安全的，但是写拥有同一对象的不同shard_ptr是线程安全的。

weak_ptr是shared_ptr的助手，暂时先了解到这里，以后会有专门对智能指针的测试和学习。