C++ 0x/11 终于通过了,真是个很爽的消息。于是乎我决定对新的东西系统学习一下。

首先当然要从tr1开始，智能指针实际上我已经用过很多次了，但是为了完整起见，还是写出来记录一下。

当然，从简单到复杂，现在接触的部分不是很复杂，不过暂时够用了。

首先是C++0x/11的新东东：auto关键字，decltype关键字和lambda表达式

auto关键字和decltype关键字都是类型推导，不同的是auto是在申明时推导类似C#里的var，而decltype只是对值，表达式等的类型推导。

auto a = 0; //这是正确的

auto a; // 这是错误的，因为在申明时无法推导类型

a = 0;

对于decltype有如下规则

1. 如果表达式e是一个变量，那么就是这个变量的类型。
2. 如果表达式e是一个函数，那么就是这个函数返回值的类型。
3. 如果不符合1和2，如果e是左值，类型为T，那么decltype(e)是T&；如果是右值，则是T。

下一项，lambda表达式

lambda表达式主要用于简化匿名函数的写法，方便堆代码用的。（C++终于支持匿名函数了）

标准形式是 外部变量->返回值 {函数体}

当然“->返回值”可以省去，这时候会有返回值类型推导

对于引用的外部变量的形式，见下表（参考维基百科的）

继续继续，贴这三个部分的测试代码：

#include <string>
#include <iostream>
#include <algorithm>

int main() {
      std::string vec = "314159265359";
      /**
       * decltype 类型推导
       * 如果表达式e是一个变量，那么就是这个变量的类型。
       * 如果表达式e是一个函数，那么就是这个函数返回值的类型。
       * 如果不符合1和2，如果e是左值，类型为T，那么decltype(e)是T&；如果是右值，则是T。
       */
     int a;
     double b;
     typedef decltype (a * b) type_ab; // 表达式类型，类型是double
     typedef decltype ((a)) type_a; // 左值，类型是int&
     /**
      * auto 类型推导
      * 类似C#里的var，在声明时推导类型
      */
     for(auto i = 0; i < vec.size(); i ++) {
         std::cout<< vec[i];
     }
     std::cout<< std::endl;
     /**
      * lambda表达式
      * 标准形式： [capture](parameters)->return_type {body}
      * 其中“->return_type ”是可选的，仅当要指定返回值的时候使用
      */
     int count = 0, sum = 0;
     std::sort(vec.begin(), vec.end(), [&count](const char& l, const char& r) -> bool {
         count ++;
         return r > l;
     });
     std::for_each(vec.begin(), vec.end(), [&](const char& v){
         sum += v - '0';
     });
     std::cout<< "排序操作次数 => "<< count<< std::endl<<
         "总和 => "<< sum<< std::endl;
     return 0;
}

// 最后，三项综合，就出现了这种奇葩的函数模板
// 这一段来自维基百科，就懒得自己试了
template< typename LHS, typename RHS>
   auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}

然后接下来是智能指针，先贴一段东东：

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

// ============================================================
// 公共包含部分
// 自动导入TR1库
// ============================================================

/**
* 导入智能指针（smart_ptr）
* 如果是G++且支持c++0x草案1（tr1版本）的smart_ptr[GCC版本高于4.0]
* 则会启用GNU-C++的智能指针
*
* 如果是VC++且支持c++0x草案1（tr1版本）的smart_ptr[VC++版本高于9.0 SP1]
* 则会启用VC++的智能指针
*
* 否则启用boost中的smart_ptr库（如果是这种情况需要加入boost库）
*/

// VC9.0 SP1以上分支判断
#if defined(_MSC_VER) && (_MSC_VER == 1500 && defined (_HAS_TR1) || _MSC_VER > 1500)
    // 采用VC std::tr1库
    #include <memory>
#elif defined(__GNUC__) && __GNUC__ >= 4
    // 采用G++ std::tr1库
    #ifndef __GXX_EXPERIMENTAL_CXX0X__
        #include <tr1/memory>
        namespace std {
            using tr1::bad_weak_ptr;
            using tr1::const_pointer_cast;
            using tr1::dynamic_pointer_cast;
            using tr1::enable_shared_from_this;
            using tr1::get_deleter;
            using tr1::shared_ptr;
            using tr1::static_pointer_cast;
            using tr1::swap;
            using tr1::weak_ptr;
        }
    #else
        #include <memory>
    #endif
#else
    // 采用boost tr1库
    #include <boost/tr1/memory.hpp>
    namespace std {
        using tr1::bad_weak_ptr;
        using tr1::const_pointer_cast;
        using tr1::dynamic_pointer_cast;
        using tr1::enable_shared_from_this;
        using tr1::get_deleter;
        using tr1::shared_ptr;
        using tr1::static_pointer_cast;
        using tr1::swap;
        using tr1::weak_ptr;
    }
#endif

这段代码是什么呢？只是一个例子，自动导入smart_ptr库。当然，其他的tr1的库的导入也可以用这种方法。这段代码支持GNU-C++、VC++，如果电脑里的C++版本不够则会导入BOOST里的智能指针库，这时候要安装BOOST库，贴完这一段，就可以使用神奇的std::shared_point了。

智能指针实现了在C++下的自动内存管理，同时使智能指针的用法和普通指针没有太大的区别，最重要的是它的效率并不弱于裸指针。

据说2009年的boost的智能指针性能消耗大约在5%，这个很可以有。

它里面采用了引用计数器，如果计数为0，则被认为是不能再被仍和变量访问到，就会被自动delete。

其中std::shared_ptr是智能指针，一下是最简单的用法

std::shared_ptr<int> a = std::shared_ptr<int>(new int()),
    b = std::shared_ptr<int>(new int());
scanf("%d %d", a.get(), b.get());
printf("%d\n", *a + *b);

你不需要在函数结束后delete资源，一切都是自动的。

另外智能指针上还有个重要的东西叫std::weak_ptr，这是智能指针的一个监视器，内部不会改变引用技术，但是可以用于获取智能指针，当资源正常时lock函数会返回智能指针，当资源被释放了后会产生空指针。主要用途是避免访问已经释放了的资源导致的Run Time Error的好东东。

另外，使用智能指针必须注意的两点：

1. 避免引用成环

引用成环会导致引用计数永不为0，造成内存泄漏，比如在类a，b，c里，各有一个成员变量p，使得a.p = &b, b.p = &c, c.p = &a; 那么即便没有方法可以访问这几个类后，计数也不会为0，就会永驻内存。或者最简单的自环，a.p = &a; 引用技术至少为1。

struct foo {
    typedef std::shared_ptr<foo> type_ptr;
    type_ptr p;
};
// 这个函数执行一次浪费一个sizeof(std::shared_ptr<foo>)的内存
void fun () {
    foo::type_ptr p = foo::type_ptr(new foo());
    p->p = p;
}

具体数值视系统位数而定。

2. 一个指针智只能被一个智能指针维护

如果一个地址同时被两个或两个以上智能指针维护会出现什么事？当某一个智能指针引用技术为0的时候，资源会被释放，而另一个就像使用了一个指向已释放资源的指针，什么后果就不用多说了吧。

int* p = new int();
std::shared_ptr<int> a = std::shared_ptr<int>(p),
b = std::shared_ptr<int>(p);
scanf("%d %d", a.get(), b.get());
printf("%d\n", *a + *b);

如果你执行上面的代码，你就会爽到了。但是这个还不明显，也容易避免，我举个更明显的例子。

class foo {
public:
    typedef std::shared_ptr<foo> type_ptr;
    //Blablabla.

    type_ptr what_are_you_want_to_do() {
        // 一堆不知道干嘛的代码后
        return type_ptr(this);
    }
};

int main() {
    foo::type_ptr p = foo::type_ptr(new foo());
    p->what_are_you_want_to_do();
    return 0;
}

运行一下，你又爽到了。但是某些情况下我们需要返回自己的智能指针怎么办呢，又有个新玩意，std::enable_shared_from_this<> ，只要继承它，就有一个成员方法shared_from_this用于返回自身的智能指针。其内部使用一个weak_ptr维护，这就是weak_ptr的一个重要使用了。

class foo: public std::enable_shared_from_this<foo> {
public:
    typedef std::shared_ptr<foo> type_ptr;
    //Blablabla.

    type_ptr what_are_you_want_to_do() {
        // 一堆不知道干嘛的代码后
        return shared_from_this();
    }
};

然后，对于智能指针的类型转换，需要用到std::const_pointer_cast，std::dynamic_pointer_cast，using std::static_pointer_cast，强制类型转换是不行滴，一定要有类型检查。

最后，智能指针的记录先到这里，以后有用到新的东西再记上来。

Well done.