1. auto关键字：编译器可以根据初始值自动推导出类型。//但是不能用于函数传参以及数组类型的推导
2. nullptr关键字：nullptr是一种特殊类型的字面值，它可以被转换成任意其它的指针类型。而NULL一般被宏定义为0，在遇到重载时可能会出现二义性问题。
3. 智能指针：C++11新增了shared_ptr,weak_ptr,unique_ptr,auto_ptr用来管理内存
4. 初始化列表：使用初始化列表来对类进行初始化
5. 右值引用：基于右值引用可以实现移动语义和完美转发，消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。

参考回答2：
1. 关键字及新语法
  auto关键字
  nullptr关键字
  for循环
2. STL容器
  std::array
  std::forward_list
  std::unordered_set
  std::unordered_map
3. 多线程
  std::thread
  std::atomic
  std::condition_variable
4. 智能指针内存管理
5. 其他
  std::function、std::bind封装可执行对象
  lambda表达式
  右值引用
  可变参数模板

#include <iostream>
using namespace std;
void func(void* i) {
  cout << "func1" << endl;
}
void func(int i) {
  cout << "func2" << endl;
}
void main(int argc,char* argv[]) {
  func(NULL);
  func(nullptr);
  getchar();
}

template<class ... T>
void func(T ... args) {
  cout << "num is " << sizeof ...(args) << endl;
}
int main() {
  func();
  func(1);
  func(1, 2.0);
  system("pause");
  return 0;
}

左值：非临时性对象的表达式，有名字，可以取地址。
右值：临时性对象的表达式，没有名字，临时生成的，不可以取地址。如：立即数、函数的返回值。

右值引用只能绑定一个将要销毁的对象，我们可以自由地将一个右值引用的资源“移动”到另一个对象。通过&&来获得右值引用。
//右值引用的主要目的是为了实现转移语义和完美转发，消除两个对象交互时不必要的对象拷贝，也能够更加简洁明确地定义泛型函数。
避免拷贝，提高性能，实现move()

int &&r = 42;   //正确，字面常量是右值
int &&r2 = r;   //错误，r1是左值
//虽然不能将一个右值引用直接绑定到一个左值上，但我们可以显式地将一个左值转换为对应的右值引用类型
int &&r3 = std::move(r);  //OK

为什么要使用智能指针？
  智能指针的作用是管理一个指针。new申请的空间在函数结束时忘记释放，会造成内存泄漏。使用智能指针可以避免这个问题，因为智能指针是一个类，当超出了类的作用域时，类会自动调用析构函数释放内存，不需要手动释放内存空间。

四种智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr
1. auto_ptr
实现独占式拥有的概念，同一时间只能有一个智能指针可以指向该对象，但auto_ptr在C++11中被摒弃，其问题在于：
* 对象所有权的转移。比如在函数传参过程中，对象所有权不会返还，从而存在潜在的内存奔溃问题。
* 不能指向数组，也不能作为STL容器的成员。
auto_ptr<string> p1 (new string ("aaaaaa"));
auto_ptr<string> p2;
p2 = p1;  //auto_ptr不会报错
此时不会报错，p2剥夺了p1的所有权，但是当程序运行时访问p1将会报错。所以auto_ptr存在潜在的内存奔溃问题。    
2. unique_ptr（替代auto_ptr）
实现独占式拥有的概念，同一时间只能有一个智能指针可以指向该对象，因为无法进行拷贝构造和拷贝赋值，但是可以进行移动构造和移动赋值。
unique_ptr<string> p1 (new string ("aaa"));
unique_ptr<string> p2;
p2 = p1;  //报错
另外unique_ptr还有更聪明的地方，当程序试图将一个unique_ptr赋值给另一个时，如果源unique_ptr是个临时右值，编译器允许这么做；如果源unique_ptr将存在一段时间，编译器将禁止这么做。
unique_ptr<string> pu1(new string("hello world"));
unique_ptr<string> pu2;
pu2 = pu1;  //#1 not allowed
unique_ptr<string> pu3;
pu3 = unique<string>(new string("You"));  //#2 allowed
3. shared_ptr
实现共享式拥有的概念，即多个智能指针可以在指向相同的对象，该对象及相关资源会在其所指对象不再使用之后，自动释放与对象相关的资源。
4.weak_ptr
weak_ptr是一种不控制对象生命周期的智能指针，它指向一个shared_ptr管理的对象。weak_ptr只是提供了对管理对象的一个访问手段，weak_ptr设计的目的是为了配合shared_ptr而引入的一种智能指针来协助shared_ptr工作。    
解决shared_ptr相互引用时，两个指针的引用计数永远不会下降为0，从而导致死锁的问题。
weak_ptr是对对象的一种弱引用，可以绑定到shared_ptr，但不会增加对象的引用计数。

问：shared_ptr是如何实现的？
1. 构造函数中计数初始化为1
2. 拷贝构造函数中计数值加1
3. 赋值运算符中，左边的对象引用计数减1，右边的对象引用计数加1
4. 析构函数中引用计数减1
5. 在赋值运算符和析构函数中，如果减1后为0，则调用delete释放对象。

当两个对象相互使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。

class Parent;
class Child;
class Parent {
private:
    shared_ptr<Child> ChildPtr;
public:
    void setChild(shared_ptr<Child> child) {
        this->ChildPtr = child;
    }
    void doSomething() {
        if (this->ChildPtr.use_count()) {
        }
    }
    ~Parent() {}
};
class Child {
private:
    shared_ptr<Parent> ParentPtr;
public:
    void setParent(shared_ptr<Parent> parent) {
        this->ParentPtr = parent;
    }
    void doSomething() {
        if (this->ParentPtr.use_count()) {
        }
    }
    ~Child() {}
};
int main() {
    weak_ptr<Parent> wpp;
    weak_ptr<Child> wpc;
  {
    shared_ptr<Parent> p(new Parent);
    shared_ptr<Child> c(new Child);
    p->setChild(c);
    c->setParent(p);
    wpp = p;
    wpc = c;
    cout << p.use_count() << endl; //2
    cout << c.use_count() << endl; //2
  }
    cout << wpp.use_count() << endl;  //1
    cout << wpc.use_count() << endl;  //1
}

为了解决循环引用导致的内存泄漏，引用了weak_ptr弱指针，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但不指向引用计数的共享内存，但是其可以检测到所管理的对象是否已经被释放，从而避免非法访问。