【C++11新特性】

C++11 比赛中用到的新特性

【散列表】

在过去，不断有要求想将散列表(无序关系式容器)引进标准库。只因为时间上的限制，散列表才没有被标准库所采纳。虽然，散列表在最糟情况下(如果出现许多冲突 (collision) 的话)在性能上比不过平衡树。但实际运用上，散列表的表现则较佳。

因为标准委员会还看不到有任何机会能将开放寻址法标准化，所以目前冲突仅能通过链地址法 (linear chaining) 的方式处理。为避免与第三方库发展的散列表发生名称上的冲突，前缀将采用 unordered 而非 hash。

库将引进四种散列表，其中差别在于底下两个特性: 是否接受具相同键值的项目 (Equivalent keys)，以及是否会将键值映射到相对应的数据 (Associated values)。

散列表类型有无关系值接受相同键值std::unordered_set否否std::unordered_multiset否是std::unordered_map是否std::unordered_multimap是是

上述的类将满足对一个容器类的要求，同时也提供访问其中元素的成员函数: insert, erase, begin, end。

散列表不需要对现有核心语言做扩展(虽然散列表的实作会利用到 C++11 新的语言特性)，只会对头文件 <functional> 做些许扩展，并引入<unordered_set> 和<unordered_map> 两个头文件。对于其它现有的类不会有任何修改。同时，散列表也不会依赖其它标准库的扩展功能。

【auto】

C++11中引入的auto主要有两种用途：自动类型推断和返回值占位。auto在C++98中的标识临时变量的语义，由于使用极少且多余，在C++11中已被删除。前后两个标准的auto，完全是两个概念。

1. 自动类型推断

    auto自动类型推断，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推断，可以大大简化我们的编程工作。下面是一些使用auto的例子。

#include <vector>#include <map>using namespace std;int main(int argc, char *argv[], char *env[]){// auto a;                 // 错误，没有初始化表达式，无法推断出a的类型// auto int a = 10;        // 错误，auto临时变量的语义在C++11中已不存在, 这是旧标准的用法。// 1. 自动帮助推导类型auto a = 10;auto c = 'A';auto s("hello");// 2. 类型冗长map<int, map<int,int> > map_;map<int, map<int,int>>::const_iterator itr1 = map_.begin();const auto itr2 = map_.begin();auto ptr = [](){std::cout << "hello world" << std::endl;};return 0;};// 3. 使用模板技术时，如果某个变量的类型依赖于模板参数，// 不使用auto将很难确定变量的类型（使用auto后，将由编译器自动进行确定）。template <class T, class U>void Multiply(T t, U u){    auto v = t * u;}

2. 返回值占位

template <typename T1, typename T2>auto compose(T1 t1, T2 t2) -> decltype(t1 + t2){   return t1+t2;}auto v = compose(2, 3.14); // v's type is double

 

3.使用注意事项

①我们可以使用valatile，pointer（*），reference（&），rvalue reference（&&） 来修饰auto

auto k = 5;auto* pK = new auto(k);auto** ppK = new auto(&k);const auto n = 6;

②用auto声明的变量必须初始化

auto m; // m should be intialized  

③auto不能与其他类型组合连用

auto int p; // 这是旧auto的做法。

④函数和模板参数不能被声明为auto

void MyFunction(auto parameter){} // no auto as method argumenttemplate<auto T> // utter nonsense - not allowedvoid Fun(T t){}

⑤定义在堆上的变量，使用了auto的表达式必须被初始化

int* p = new auto(0); //fineint* pp = new auto(); // should be initialized auto x = new auto(); // Hmmm ... no intializer   auto* y = new auto(9); // Fine. Here y is a int*auto z = new auto(9); //Fine. Here z is a int* (It is not just an int)

⑥以为auto是一个占位符，并不是一个他自己的类型，因此不能用于类型转换或其他一些操作，如sizeof和typeid

int value = 123;auto x2 = (auto)value; // no casting using autoauto x3 = static_cast<auto>(value); // same as above 

⑦定义在一个auto序列的变量必须始终推导成同一类型

auto x1 = 5, x2 = 5.0, x3='r';  // This is too much....we cannot combine like this

⑧auto不能自动推导成CV-qualifiers（constant & volatile qualifiers），除非被声明为引用类型

const int i = 99;auto j = i;       // j is int, rather than const intj = 100           // Fine. As j is not constant// Now let us try to have referenceauto& k = i;      // Now k is const int&k = 100;          // Error. k is constant// Similarly with volatile qualifer

⑨auto会退化成指向数组的指针，除非被声明为引用

int a[9];auto j = a;cout<<typeid(j).name()<<endl; // This will print int*auto& k = a;cout<<typeid(k).name()<<endl; // This will print int [9]

【move和右值引用】

C++0x中加入了右值引用，和move函数。右值引用出现之前我们只能用const引用来关联临时对象（右值）（造孽的VS可以用非const引用关联临时对象，请忽略VS），所以我们不能修临时对象的内容，右值引用的出现就让我们可以取得临时对象的控制权，终于可以修改临时对象了！而且书上说配合move函数，可以大大提高现有C++的效率。那么是怎样提高它的效率的呢？看段代码先！

#include <iostream>#include <utility>#include <vector>#include <string>int main(){    std::string str = "Hello";    std::vector<std::string> v;     // uses the push_back(const T&) overload, which means     // we'll incur the cost of copying str    v.push_back(str);    std::cout << "After copy, str is \"" << str << "\"\n";     // uses the rvalue reference push_back(T&&) overload,     // which means no strings will copied; instead, the contents    // of str will be moved into the vector.  This is less    // expensive, but also means str might now be empty.    v.push_back(std::move(str));    std::cout << "After move, str is \"" << str << "\"\n";     std::cout << "The contents of the vector are \"" << v[0]                                         << "\", \"" << v[1] << "\"\n";}

Output:

After copy, str is "Hello"After move, str is ""The contents of the vector are "Hello", "Hello"

看完大概明白一点儿了,加上move之后,str对象里面的内容被"移动"到新的对象中并插入到数组之中了,同时str被清空了。这样一来省去了对象拷贝的过程。所以说在str对象不再使用的情况下，这种做法的效率更高一些！

也可以在函数返回时右值引用返回值的空间，不必要他复制

原来的直接返回是这样的

NODE ans = query(1);printf("%d\n", ans.mx1);

右值引用可以这样写

NODE&& ans = query(1);printf("%d\n", ans.mx1);

这样可以提高效率，没有真正复制query()返回的值给ans，而是引用了本来已经被销毁的内存；