C++primer中提到的C++11新特性总结

decltype自动类型推定。decltype接受一个表达式，返回表达式的类型。可以接受最高层的修饰符，比如：const  int i； decltype(i) c =  I; c 类型为const int 类型

如果decltype中的参数被括号括起来，则被定义为，reference类型。

如果decltype((variable))则，定义的类型总是reference类型

constexpr 常量表达式。

int *const p = nullptr;  //p is aconst pointer to int 

定义别名 :

using SI = int;   //SI 为新类型名，和int类型相同。 g++ 调试通过。VS2012不支持

命名空间别名  ：

namespace newname = oldname;

const int *p = nullptr;      // p   is a pointer to a   constint

constexpr int *q = nullptr; //  q   isa   const pointer  to  int

在g++4.7上调试，int j = 0;  constexpr int  *p1 = &j; //未调式通过。

constexpr 定义函数时，返回值必须是字面值。

string 类型中添加to_string()函数，stoT  T代表任意类型，如T=I  stoi 字符串到int转换。

 

 

default 关键字

设置默认构造函数时使用。在类中定义了构造函数后，还想继续使用默认构造函数，则可以在函数成员列表后添加 =default ；=delete表示不定义。可以使用在不允许使用复制构造函数和赋值构造函数上

struct Sales_data {

   //  constructors added

   Sales_data() = default;

C++ Primer, Fifth Edition

Sales_data(conststd::string &s){}

}；//VS2012 调试不通过，g++4.7通过

 

emplace//在容器中插入元素。后边的元素依次向后移动。

template <class... Args>

iterator emplace (const_iterator position,Args&&... args); 在指定的位置插入元素。

emplace_back(SS);在容器尾部插入元素SS

auto

auto 关键字， 可以直接声明对象，且该对象的类型由对象的初始化表达式推定出来。

使用auto关键字时，必须有初始化式。auto 普通类型不接受最高层修饰符

const int ci =i, &cr = ci;

auto b =ci;  // b   is an   int (top-level   const  in  ci   is dropped)

auto c =cr;  // c   is an   int (cr  is an alias for   ci  whose  const  is top-level)

auto d =&i;  //  d   isan   int*(&   of an int  object is  int*)

auto e =&ci; // e   is   const int* (&  of a  const  object is low-level  const)

当定义为指针类型时，const不会丢失。

显式指定删除及显式指定缺省的函数声明 具备如下函数形式：

 struct A{

 A()=default; //C++11

 virtual ~A()=default; //C++11

 };

称之为缺省的函数。“=default；”记号部分指示编译器生成函数的缺省实作体。缺省的函数有两处优势：其一，比手工实作出来的代码更有效率，其二，把程序员从手工定义那些函数所引发的琐细事务中解脱出来。

与缺省函数对应，也存在指定删除函数：

 int func()=delete;

声明删除的函数在防止复制对象的方面尤其有用。C++类自动声明一个复制构造函数和一个赋值操作。要禁止这种默认行为，使用记号=delete：

 struct NoCopy{

 NoCopy & operator =( constNoCopy & ) = delete;

 NoCopy ( const NoCopy & ) =delete;

 };

 NoCopy a;

 NoCopy b(a); //compilation error,copy ctor is deleted

容器类：

forward_list  //前向list

内部实现指向下一个元素只有一个指针。而list有两个。插入，移动，提取元素，比其他顺序容器效率高。确定是不支持随机存取。

vector中增加shrink_to_fit 函数，可以缩小容量，使其和size大小相同。

增加data函数

 

    value_type* data() noexcept;

const value_type* data() constnoexcept; 

可以利用偏移量进行访问vector中的元素。

int* p =myvector.data();

 

  *p = 10;

  ++p;

  *p = 20;// p 移动到myvector[1]的位置。

  p[2] = 100;   //相对于p所指位置2单位的偏移量.也就是现在的myvector[3]

shared_ptr函数指针。

template <class T> class shared_ptr;   //<memory>可以自己定义删除函数。成员函数调用reset时，调用删除函数。

make_shared<T>(args) //返回一个shared_ptr类型

shared_ptr 指针get()成员函数返回管理的对象。

operator*

operator->  两个都是对管理的对象进行解引用操作dereferences pointer to the managed object 

reset	replaces the managed object  (public member function)
swap	swaps the managed objects  (public member function)
Observers
get	returns a pointer to the managed object  (public member function)
operator* operator->	dereferences pointer to the managed object  (public member function)
use_count	returns the number of shared_ptr objects referring to the same managed object  (public member function)
unique	checks whether the managed object is managed only by the current shared_ptr instance  (public member function)
operator bool	checks if there is associated managed object  (public member function)
owner_before	provides owner-based ordering of shared pointers  (public member function)

 

新增加final关键字定义类为final 则类无法被继承。

override关键字，

在基类为virtual关键字修饰，子类可以使用override修饰，子类中的方法必须和父类中的方法参数必须相同。否则出错。使用override修饰的子类，父类中必须存在且为virtual修饰。

在template<typename  Type>中我们可以把Type定义为friend,例如：

template<typename Type>

class Bar {

         friendType;

} 不管类Bar为什么类型，Type都是它的friend函数。

我们无法为一个模板类定义typedef，但是我们可以使用using定义别名。例如：

template<typename T>
using twin =pair<T,T>;
twin<string>  //pair<string,string>

 

 

lambda表达式

lambda 定义式   [capture_list] (argument。。。) { body ;}

capture_list 如果是& 则表示捕获的为引用传递，[&]  body中会自动推断参数。

如果是= 则表示值传递，[=]  body 中会自动推断参数.

而捕获列表变量之间以逗号隔开。

捕获列表应该保持最小捕获原则。在body中需要到的参数，应该在捕获列表中写出来。

如果捕获的参数前加”&”符号，则表示是引用。

initializer_list

初始化列表。

inline namespace  当声明命名空间为inline时，则在引用命名空间中的对象时，可以直接引用，而不用添加命名空间的名字

lambda表达式中如果需要定义返回值，则必须使用Trailingreturn type 例如：

[]()->int

{

}  //表示返回值为int类型。

初始化：

新标准中，可以直接通过{} 对类内的成员在定义时进行初始化。VS2012不支持，g++4.7支持；如成员变量 int  mm {10} //mm直接被初始化为;也可以直接使用” = ” 进行初始化。

对其他变量进行初始化时可以直接使用 {} 进行。

例如一个vector<int> vce;

vce = {1,2,3}; vce 初始化为含有三个元素的vector

function

function定义在functional头文件中，是定义函数指针的。

例如function<int(int,int)>f1; //定义一个指向返回int类型，参数为两个int类型的函数。

mem_fn(Ret T::* pm))  //把一个成员函数转换为函数对象。The return type is unspecified, but the type returned is a function object class with the properties described above。

bind函数bind (Fn&& fn, Args&&... args);

 

auto newCallable = bind (Callable,arg_list);  arg_list 由逗号隔开。

可以使用using  namespace std::placeholders ; 提供的占位符来确定具体那位被绑定。

绑定的时候应该进行依次绑定，否则调用的时候需要使用占位符进行标注，否则会出错。

例如:auto ss = bind (chenk,_1,6);调用的时候表示参数1需要自己输入，参数2为6，占位符其实就是表示调用ss时所对应的参数的位置的值出现在bind的对应位置上。

g(_1, _2)

 to

 f(a, b, _2, c, _1)

 That is, calling  g  calls  f  using g ’s arguments for the placeholders along with the

bound arguments, a ,  b , and  c . For example, calling  g(X, Y) calls

 f(a, b, Y, c, X)

不要和bind1st 等弄混，template <class Operation, class T>

  binder1st<Operation> bind1st (const Operation& op, const T& x);这个主要是和函数对象的操作符一起使用。

move(arg); 去掉arg的语义，把它当成一个右值。

左值是既可以出现在表达式左边，又可以出现在右边。左值表示永久存在。

右值只能出现在右边。右值代表临时存在。

noexcept

noexcept 修饰时，表示不抛出任何异常。成员函数中，noexcept跟随在const 或者引用限定符后，而在final，override，或者 = 0前面。

void recoup(int ) noexcept;

void recoup(int) throw();   //这两个函数其实是等同的，都是说不抛出异常。

noexcept(e); 如果e不抛出异常，则返回true。否则返回false；

父类，子类对应的成员方法，必须有相同的noexcept值。

random

头文件<random>

Engine 产生一系列随机无符号整数数

Distribution 使用一个Engine依据特殊的规则返回分配的随机数。

产生伪随机数：

default_random_engine e;

cout << e();  //会产生一个伪随机数。

 

使用uniform_int_distribution<unsigned>u(0,9) 产生0-9之间的数字。

u(e) //产生0-9之间的数字，包括0和9

一个给定的随机数生成器，将会每次运行时都产生相同的随机数序列。

可以通过定义一个seed来控制，当两个engine的seed相同时，则产生的随机数序列也是相同的。反之亦然。

一般可以使用系统时间作为seed值，但是当程序时在一个单独的自动反复运行的机械上时，这个方法将失效。因为每次产生的seed种子都相同，

 

产生real random

使用： uniform_real_distribution

cmath中增加lround函数，四舍五入。

bernoulli_distribution 伯努利方式这个属于一个普通函数，而不是模板，最后产生的结果只有bool类型，true或false。

normal_distribution<> 正态分布方式产生。

tuple

tuple类似于pair，但是他的参数可以是任意多个。

使用get<pos>(tuple  t) ; 获得第pos的t的元素

tuple_size<tupleType>::value  ;//获得tupleType中元素类型的个数。

tuple_element<I , tupleType>::type  //获得第i个元素的类型

tuple 定义了 < 和 == 比较的时候只能是两种类型相同的时候。

 

 

新版union中可以包含对象。

placement new表达式：

new (place-address) type

new (place-address) type(initializer-list);