c++ 11/14 (一)

• 弃用特性
• C兼容性
• auto改用途
• decltype引入
• using引入
• 对象初始化及初始化列表
• 面向对象
• 枚举类
• lambda
• 函数对象包装器
• 右值&意义

弃用特性

（会保留，但终究会从标准中消失） 弃用的特性（1）：如果一个类有析构函数，为其生成拷贝构造函数和拷贝赋值运算符的特性被弃用了。**

弃用的特性（2）：不再允许字符串字面值常量赋值给一个 char *。如果需要用字符串字面值常量赋值和初始化一个 char *，应该使用 const char * 或者 auto。

弃用的特性（3）：C++98 异常说明、 unexpected_handler、set_unexpected() 等相关特性被弃用，应该使用 noexcept。**

弃用的特性（4）：auto_ptr 被弃用，应使用 unique_ptr。

弃用的特性（5）：register 关键字被弃用。

弃用的特性（6）：bool 类型的 ++ 操作被弃用。

弃用的特性（7）：C 语言风格的类型转换被弃用，应该使用 static_cast、reinterpret_cast、const_cast 来进行类型转换。

其他诸如参数绑定（C++11 提供了 std::bind 和 std::function）、export 等特性也均被弃用。

C兼容性

.h文件

#ifdef __cplusplus
extern "C" {
   
#endif

int add(int x, int y);

#ifdef __cplusplus
}
#endif

nullptr 引入

传统C++ ： NULL = 0（ or NULL = (void*) 0 ）
C++11 /14：nullptr_t nullptr 空指针（!= 0）
使用NULL的情况改为使用nullptr

constexpr引入

用户显式的声明函数或对象构造函数在编译器会成为常数，编译器去验证函数应该是个常数（不是常数，会报错？）
C++11:

constexpr int fibonacci(const int n) {
   
    return n == 1 || n == 2 ? 1 : fibonacci(n-1)+fibonacci(n-2);
}

C++14:允许使用局部变量，循环和分支等简单语句

constexpr int fibonacci(const int n) {
   
    if(n == 1) return 1;
    if(n == 2) return 1;
    return fibonacci(n-1)+fibonacci(n-2);
}

auto 改用途

C ：register关键字请求让编译器将变量a直接放入寄存器里面，以提高读取速度 C++：register关键字仍支持，但是c++编译器也有自己的优化方式，即某些变量不用register关键字进行修饰，编译器也会将多次连续使用的变量优化放入寄存器中，例如入for循环的循环变量i。

传统C++ ：使用auto修饰的变量，是具有自动存储器的局部变量。如果一个变量没有声明为 register 变量，将自动被视为一个 auto 变量。

for(vector<int>::const_iterator itr = vec.cbegin(); itr != vec.cend(); ++itr)

C++11/14 ：auto 任意类型

std::vector<int> arr(5, 100);
for(auto itr= arr.begin(); itr != arr.end(); ++itr);
for(auto &i : arr) ;

auto i=5; //i int
auto arr = new auto(10);//arr int*

int array[] = {
   1,2,3,4,5};
for(auto &x : array) ;

auto不用于传参,不用于推导数组类型：

//int add(auto x,auto y);

/*
int arr[10] = {0};
 auto auto_arr = arr;
 auto auto_arr2[10] = arr;
*/

上述推导数组哪个不行？

decltype引入

auto 关键字对变量进行类型推导 decltype关键字对表达式进行推导得出类型，编译器分析表达式并得到它的类型，却不实际计算表达式的值。

auto x = 1;
auto y = 2;
decltype(x+y) z;   // z 是一个 int 型的

尾返回类型
传统C++:

template<typename R, typename T, typename U>
R add(T x, U y) {
   
    return x+y
}//必须明确指出返回类型。但事实上我们并不知道 add() 这个函数会做什么样的操作，获得一个什么样的返回类型。

C++11:

template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
   
    return x+y;
}// auto 关键字将返回类型后置

C++14:

template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
   
    return x+y;
}

using引入

1. 另类的typedef:

typedef int (*process)(void *);  
using process = int(*)(void *); // 同上, 更加直观

template <typename T>
using NewType = SuckType<int, T, 1>;    // 合法

2.类中/struct中 使用

• using父类方法，主要是用来实现可以在子类实例中调用到父类的重载版本（不影响原来的父类与子类的成员关系，但是using可以让子类使用原来不可见的父类成员）

class Base{
   
  void men()
  {
   
    cout<<"Base men1"<<endl;
  }
  void men(int value)
  {
   
    cout<<"Base men2"<<endl;
  }
}
class Sunclass:Base{
   
	using Base::men;

	void men(int value){
   
		cout<<"sub men";
	}
}
int main() {
   
    Subclass s;
    s.men() ;//Base men1
    s