用C++ 11重构

1.取代兰特

C++ 11中的一大收获必须是替换随机头中rand()可用的所有选项的使用.在许多情况下更换应该是直截了当的.rand()

Stephan T. Lavavej可能认为这一点最强,他的演示兰德()被认为是有害的.这些示例显示了[0,10]使用的统一整数分布rand():

#include <cstdlib>
#include <iostream>
#include <ctime>

int main() 
{
    srand(time(0)) ;

    for (int n = 0; n < 10; ++n)
    {
            std::cout << (rand() / (RAND_MAX / (10 + 1) + 1)) << ", " ;
    }
    std::cout << std::endl ;
}

并使用std :: uniform_int_distrubution:

#include <iostream>
#include <random>

int main()
{
    std::random_device rd;

    std::mt19937 e2(rd());
    std::uniform_int_distribution<> dist(0, 10);

    for (int n = 0; n < 10; ++n) {
        std::cout << dist(e2) << ", " ;
    }
    std::cout << std::endl ;
}

随之而来的应该是从std :: random_shuffle转移到std :: shuffle,这是为了弃用rand和Friends.最近在SO问题中讨论了为什么在C++ 14中不推荐使用std :: shuffle方法？.

请注意,不保证分布在不同平台上保持一致.

2.使用std :: to_string而不是std :: ostringstream或sprintf

C++ 11提供了std :: to_string,它可用于将数字转换为std :: string,它将生成内容作为等效的std :: sprintf.很可能这将用于代替std :: ostringstream或snprintf.这更方便,可能没有太大的性能差异,我们可以从C++文章中的快速整数到字符串转换看到,如果性能是主要关注点,可能有更快的替代方案:

#include <iostream>
#include <sstream>
#include <string>

int main()
{
    std::ostringstream mystream;  
    mystream << 100 ;  
    std::string s = mystream.str();  

    std::cout << s << std::endl ;

    char buff[12] = {0};  
    sprintf(buff, "%d", 100);  
    std::string s2( buff ) ;
    std::cout << s2 << std::endl ;

    std::cout << std::to_string( 100 ) << std::endl ;
}

3.使用constexpr代替模板元编程

如果您正在处理文字,可能会出现这样的情况:使用constexpr函数而不是模板元编程可能会产生更清晰且可能编译得更快的代码.想要速度的文章？使用constexpr元编程!提供了使用模板元编程确定素数的示例:

struct false_type 
{
  typedef false_type type;
  enum { value = 0 };
};

struct true_type 
{
  typedef true_type type;
  enum { value = 1 };
};

template<bool condition, class T, class U>
struct if_
{
  typedef U type;
};

template <class T, class U>
struct if_<true, T, U>
{
  typedef T type;
};

template<size_t N, size_t c> 
struct is_prime_impl
{ 
  typedef typename if_<(c*c > N),
                       true_type,
                       typename if_<(N % c == 0),
                                    false_type,
                                    is_prime_impl<N, c+1> >::type >::type type;
  enum { value = type::value };
};

template<size_t N> 
struct is_prime
{
  enum { value = is_prime_impl<N, 2>::type::value };
};

template <>
struct is_prime<0>
{
  enum { value = 0 };
};

template <>
struct is_prime<1>
{
  enum { value = 0 };
};

并使用constexpr函数:

constexpr bool is_prime_recursive(size_t number, size_t c)
{
  return (c*c > number) ? true : 
           (number % c == 0) ? false : 
              is_prime_recursive(number, c+1);
}

constexpr bool is_prime_func(size_t number)
{
  return (number <= 1) ? false : is_prime_recursive(number, 2);
}

constexpr版本更短,更容易理解,并且显然比模板元编程实现更好.

4.使用类成员初始化来提供默认值

正如最近所述,在声明中新的C++ 11成员初始化功能使初始化列表过时了吗？类成员初始化可用于提供默认值,并可简化类具有多个构造函数的情况.

Bjarne Stroustrup在C++ 11 FAQ中提供了一个很好的例子,他说:

这节省了一些打字,但真正的好处来自具有多个构造函数的类.通常,所有构造函数都为成员使用公共初始值设定项:

并提供了一个具有公共初始化程序的成员示例:

class A {
  public:
    A(): a(7), b(5), hash_algorithm("MD5"), s("Constructor run") {}
    A(int a_val) : a(a_val), b(5), hash_algorithm("MD5"), s("Constructor run") {}
    A(D d) : a(7), b(g(d)), hash_algorithm("MD5"), s("Constructor run") {}
    int a, b;
  private:
    HashingFunction hash_algorithm;  // Cryptographic hash to be applied to all A instances
    std::string s;                   // String indicating state in object lifecycle
};

并说:

hash_algorithm和s各自具有单个默认值的事实在代码混乱中丢失,并且在维护期间很容易成为问题.相反,我们可以分解数据成员的初始化:

class A {
  public:
    A(): a(7), b(5) {}
    A(int a_val) : a(a_val), b(5) {}
    A(D d) : a(7), b(g(d)) {}
    int a, b;
  private:
    HashingFunction hash_algorithm{"MD5"};  // Cryptographic hash to be applied to all A instances
    std::string s{"Constructor run"};       // String indicating state in object lifecycle
};

请注意,在C++ 11中,在类成员初始值设定项中使用的类不再是聚合,尽管在C++ 14中删除了此限制.

5.使用cstdint中的固定宽度整数类型而不是手动压缩的typedef

由于C++ 11标准使用C99作为规范参考,我们也得到固定宽度整数类型.例如:

int8_t
int16_t 
int32_t 
int64_t 
intptr_t

虽然其中有几个是可选的,但对于精确的宽度整数类型,C99部分中的以下内容7.18.1.1适用:

这些类型是可选的.但是,如果实现提供宽度为8,16,32或64位的整数类型,没有填充位,并且(对于具有二进制补码表示的有符号类型),它应定义相应的typedef名称.

我会将委托构造函数和类内成员初始值设定项添加到列表中.

通过使用委托构造器和类内初始化来简化

使用C++ 03:

class A
{
  public:

    // The default constructor as well as the copy constructor need to 
    // initialize some of the members almost the same and call init() to
    // finish construction.
    A(double data) : id_(0), name_(), data_(data) {init();}
    A(A const& copy) : id_(0), name_(), data_(copy.data_) {init();}

    void init()
    {
       id_ = getNextID();
       name_ = getDefaultName();
    }

    int id_;
    string name_;
    double data_;
};

使用C++ 11:

class A
{
  public:

    // With delegating constructor, the copy constructor can
    // reuse this constructor and avoid repetitive code.
    // In-line initialization takes care of initializing the members. 
    A(double data) : data_(data) {}

    A(A const& copy) : A(copy.data_) {}

    int id_ = getNextID();
    string name_ = getDefaultName();
    double data_;
};

For-each语法:

std::vector<int> container;

for (auto const & i : container)
  std::cout << i << std::endl;

如果所有的所有权都遵循RAII原则,那么这篇博客文章提出了零规则,允许摆脱C++ 11中的三/四/五规则.

但是,Scott Meyers 在这里表明,如果稍微更改代码(例如,用于调试),则不明确地编写析构函数,复制/移动构造函数和赋值运算符会引发细微问题.然后他建议显式声明这些函数的默认(C++ 11特性):

~MyClass()                           = default;
MyClass( const MyClass& )            = default;
MyClass( MyClass&& )                 = default;
MyClass& operator=( const MyClass& ) = default;
MyClass& operator=( MyClass&& )      = default;

使用统一初始化语法 进行变量初始化

widget w(x); // old
widget w{x}; // new

避免像c ++最令人烦恼的解析之类的问题(Herb Sutter在链接文章中解释了新方法优越的其余原因)

功能:std :: move

"明确区分复制和移动资源"

std::string tmp("move");
std::vector<std::string> v;
v.push_back(std::move(tmp));
//At this point tmp still be the valid object but in unspecified state as
// its resources has been moved and now stored in vector container.

使用constexpr优化简单的数学函数,特别是如果它们在内部循环中调用.这将允许编译器在编译时计算它们,从而节省您的时间

例

constexpr int fibonacci(int i) {
    return i==0 ? 0 : (i==1 ? 1 : fibonacci(i-1) + fibonacci(i-2));
}

另一个示例是用于std::enable_if限制特定模板函数/类中允许的模板参数类型.当你隐式假设一些关于模板类型的属性并且它只是一行额外的代码时,这会使你的代码更安全(如果你没有使用SFINAE来约束旧代码中可能的模板参数)

例:

template
<
   typename T, 
   std::enable_if< std::is_abstract<T>::value == false, bool>::type = false // extra line
>
void f(T t) 
{ 
 // do something that depends on the fact that std::is_abstract<T>::value == false
}

更新1:如果你有一个在编译时已知大小的小数组,你想要避免std :: vector中堆分配的开销(意思是:你想要堆栈上的数组),你只能选择C++ 03是使用c风格的数组.改为std::array.这是一个简单的更改,为std :: vector +堆栈分配提供了很多功能(比我之前说的堆分配快得多).

优先于作用域枚举而不是无作用域枚举

在C ++ 98枚举中，没有像以下代码段这样的枚举范围。此类枚举器的名称属于包含枚举的范围，即该范围内的其他名称均不得相同。

enum Color{ blue, green, yellow };
bool blue = false;    // error: 'blue' redefinition

但是，在C ++ 11中，scoped enums可以解决此问题。scoped enum被声明为var enum class。

enum class Color{ blue, green, yellow };
bool blue = false;     // fine, no other `blue` in scope
Color cc = blue;       // error! no enumerator `blue` in this scope
Color cc = Color::blue; // fine
auto c = Color::blue;  // fine

的枚举数scope enums类型更强。但是，将枚举数unscoped enums隐式转换为其他类型

enum Color{ blue, green, yellow };
std::vector<std::size_t> getVector(std::size_t x);
Color c = blue;

if (c < 10.1) {             // compare Color with double !! 
    auto vec = getVector(c); // could be fine !!
}

但是，scoped enums在这种情况下将失败。

enum class Color{ blue, green, yellow };
std::vector<std::size_t> getVector(std::size_t x);
Color c = Color::blue;

if (c < 10.1) {             // error !
    auto vec = getVector(c); // error !!
}

通过修复 static_cast

if (static_cast<double>(c) < 10.1) {
   auto vec = getVector(static_cast<std::size_t>(c));
} 

unscoped enums 可能会被预先声明。

enum Color;          // error!!
enum class Color;    // fine

既scoped和unscoped枚举支持基础类型的规范。为默认的基本类型scoped enums是int。Unscoped enums没有默认的基础类型。

使用并发API

首选基于任务而不是基于线程

如果要doAsyncWork异步运行函数，则有两个基本选择。一种是基于线程的

int doAsyncWork();
std::thread t(doAsyncWork);

另一个是基于任务的。

auto fut = std::async(doAsyncWork);

显然，与基于线程相比，doAsyncWork通过基于任务的返回值更容易。使用这种方法很容易，因为从中返回的未来提供了get函数。如果发出异常，则该功能甚至更为重要，因为它也提供对该异常的访问。task-basedstd::asyncgetdoAsyncWorkget

Thread-based要求手动管理线程耗尽，超额预订，负载平衡以及对新平台的适应。但是Task-based通过std::async默认启动策略，这些缺点都没有。

这里有几个链接：

C ++中的并发

并行和并发的C / C ++编程抽象