跟Google学写代码--Chromium工程中禁止使用的C++11特性

Chromium是一个伟大的、庞大的开源工程，很多值得我们学习的地方。

前面写道：
《跟Google学写代码–Chromium/base–stl_util源码学习及应用》

《跟Google学写代码–Chromium/base–windows_version源码学习及应用》

《跟Google学写代码–Chromium/base–cpu源码学习及应用》

《跟Google学写代码–Chromium工程中用到的C++11特性》

《跟Google学写代码–Chromium工程中用到的C++11特性(Library Features)》

今天与大家分享的是chromium工程中，禁止使用的C++11的特性。

Inline Namespaces

The inline namespace mechanism is intended to support library evolution by providing a mechanism that support a form of versioning

通过一段代码，你就明白了什么是inline namespace：

#include<iostream>

namespace X
{
  inline namespace Y
  {
    void func()
    {
      std::cout << "func called" << std::endl;
    }
  }
}

namespace X2
{
  namespace Y2
  {
    void func2()
    {
      std::cout << "func2 called" << std::endl;
    }
  }
}

int main()
{
  X::func();
  X::Y::func();

  X2::Y2::func2();
  //X2::func2(); //it is wrong

  system("pause");
  return 0;
}

输出结果：
func called
func called
func2 called

有了inline namespace，确实容易造成一些混淆，迷惑我们的双眼，导致调用错误。

long long Type

为了存储更大的数字，我们想到了使用long long来表示，但是这是google c++ code style所禁止的，建议我们使用stdint.h。

Using <stdint.h> (or making your own surrogate) is very common in embedded development. It makes variable sizes and memory usage more obvious and porting a lot easier.

Date and time utilities

要使用base类中的关于time的类，不要再使用<chrono>。
关于base库中的Time和Timer接下来会跟大家一起分析。

Function Objects

要使用base库中的base::Callback。
关于base/callback接下来也会跟大家一起分享。

Regular Expressions

C++11终于在语言层面上对正则表达式进行了支持，但是chromium工程中不允许使用的。
因为使用了re2这个库：

RE2是一个下效准绳性的正则表达式库 ，由 Rob Pike 战 Russ Cox 两位去自谷歌的大牛用 C 完成。他俩同时也是 Go 语言的主导者。

Thread Library

c++11引入了thread，但是在chromium工程中，我们还是不能使用，因为已经使用了base库中的线程：
base::Thread is tightly coupled to MessageLoop which would make it hard to replace. We should investigate using standard mutexes, or unique_lock, etc. to replace our locking/synchronization classes.

<cfenv> and <fenv.h>

之所以不允许使用，是因为很多编译器还不是支持。
但是我们可以了解一下，技不压身：
参考博客:
http://blog.csdn.net/lion_hbeu/article/details/24013095

#include <stdio.h> /* printf */
#include <fenv.h> /* fegetround, FE_* */
#include <math.h> /* rint */
void show_all_except(void);
int main ()
{
    show_all_except();
    double d = 1e-40;
    float f;
    f = d;//这种精度丢失在编译过程中编译器编译不会提示，运行也没有问题
    show_all_except();
    return 0;
}

void show_all_except(void)  
{  
    //设置该参数表示可以访问浮点运算异常的状态值 
    #pragma STDC FENV_ACCESS ON 
    //获取所有可能的异常 
    int res = fetestexcept(FE_ALL_EXCEPT);  

    printf( "Status: " );  
    if(res & FE_INEXACT)//判断是否有精度损失的异常 
    {  
        printf( " inexact ");  
    }  
    if(res & FE_UNDERFLOW)//判断是否有下溢 
    {  
        printf( " underflow ");  
    }  
    if(res & FE_OVERFLOW)//判断是否有上溢 
    {  
        printf( " overflow ");  
    }  
    if(res & FE_DIVBYZERO)//判断是否有被0除 
    {  
        printf( " zero-divide ");  
    }  
    if(res & FE_INVALID)//判断是否有不合法的浮点运算 
    {  
        printf( " invalid ");  
    }  
    printf( " \n ");  
} 

std::shared_ptr

c++11引入了智能指针，这是一个千呼万唤始出来的结果。
但是对于shared_ptr会有很多的坑儿，所以不建议使用。
If dynamic allocation is necessary, prefer to keep ownership with the code that allocated it. If other code needs access to the object, consider passing it a copy, or passing a pointer or reference without transferring ownership. Prefer to use std::unique_ptr to make ownership transfer explicit. For example:

std::unique_ptr<Foo> FooFactory();
void FooConsumer(std::unique_ptr<Foo> ptr);

Do not design your code to use shared ownership without a very good reason.