C++11新特性总结

最新推荐文章于 2024-06-15 15:56:31 发布

追烽少年x

最新推荐文章于 2024-06-15 15:56:31 发布

阅读量691

点赞数 1

文章标签： c++ 开发语言

原文链接：http://c.biancheng.net/view/7751.html

版权

最近再学习了一下C++11中的一些新的特性，C++11添加的这些新的特性，可以说让C++语言变得更加的现代化。比如新加入得Lambda表达式。
下面我们来介绍一下一些新的特性：

C++11新特性

一、变量和基本类型

一、变量和基本类型

1.long long 类型

long long 类型：长整形，占8字节，64位的。可表示范围：
-2^63 ~ 2 ^ 63 -1。
要使用long long 类型的整数必须标注对应的后缀：
对于有符号的long long 类型，后缀用"LL"或者"II"标识，就比如"10LL"就表示有符号超长整数10.
对于无符号的long long 类型，后缀用"ULL"或者"UII"标识，就比如"10ULL"就表示无符号超长整数10.
如果想要了解当前平台long long 类型的取值范围：
可以使用一下3个宏：
LLONG_MIN:代表当前平台最小的 long long 类型整数
LLONG_MAX:代表当前平台最大的 long long 类型整数
ULLONG_MAX:代表当前平台上最大的 unsigned long long 类型整数（无符号超长整型的最小值为 0）；

LLONG_MIN
LLONG_MAX
ULLONG_MAX

2.列表初始化(统一初始化)

在C++ Primer 第五版中，有如下的语句：
初始化不是赋值，初始化的含义是创建变量时赋予其一个初始值，而赋值的含义是把对象的当前值擦除，以一个新值替代。在C++11全面使用{}进行初始化，这种初始化的方式成为列表初始化。

#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std;

class Foo
{
public:
    Foo(int) {};
    ~Foo() {};
};

int main()
{
    int n0{};
    int n1{ 1 };
    int n2 = { 1 };
    double d = double {1.2};

    string s1{'a','b' ,'c' ,'d'};
    string s2{ s1,2,2 };
    string s3{ 0x61,'a'};
    string s4{ "Hello World!"};
    
    // new 操作符也可以初始化
    int* p = new int{1};
    int* pArr = new int[3]{ 123 };
    // 类对象初始化
    Foo a3 = { 123 };
    Foo a4{ 123 };
    std::cout << "Hello World!\n";
}

无论是类变量、数组、STL容器、类构造等都统一使用{}初始化。

3.nullptr 常量

nullptr 是 nullptr_t 类型的右值常量，专用于初始化空类型指针。nullptr_t 是 C++11 新增加的数据类型，可称为“指针空值类型”。也就是说，nullpter 仅是该类型的一个实例对象（已经定义好，可以直接使用），如果需要我们完全定义出多个同 nullptr 完全一样的实例对象。

#include <iostream>
#include <cstddef>
using namespace std;
template<typename T>
constexpr T Clone(const T& t)
{
    return t;
}

void G(int* t)
{
    cout << "Func is called!" << endl;
}

void Func(int n)
{
    cout << "int n" << endl;
}
void Func(void* p)
{
    cout << "void* p" << endl;
}

int main()
{
    // nullptr 可以被隐式转换成任意的指针类型
    int* a1 = nullptr;
    char* a2 = nullptr;
    double* a3 = nullptr;

    // 调用Func(int n)
    Func(0);
    // 调用Func(int n)，不符合预期
    Func(NULL);
    // 使用nullptr 解决问题
    Func(nullptr);
    
    G(nullptr);
    G(NULL);
    G(0);
    // 正常编译
    G(Clone(nullptr));
    // Error:非文字零不能是空指针常量
    // G(Clone(NULL));
    //  Error:非文字零不能是空指针常量
    // G(Clone(0));
    std::cout << "Hello World!\n";
}

如上代码所示：Func(NULL)调用的是Func(int n)不符合预期，预期是调用Func(void* p),所以加入nullptr来解决问题。nullptr的类型为nullptr_t，能够隐式地转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。

4.constexpr(泛华常量表达式)

constexpr 关键字的功能是使指定的常量表达式获得在程序编译阶段计算出结果的能力，而不必等到程序运行阶段。C++ 11 标准中，constexpr 可用于修饰普通变量、函数（包括模板函数）以及类的构造函数。
常量表达式（const experssion）：是指
(1)值不会改变
(2)在编译过程就能得到计算结果的表达式。

1.constexpr修饰普通变量

 // constexpr 修饰普通变量
    constexpr int N = 1 + 2 + 3;
    int arr[N] = {0};

2.constexpr修饰函数的返回值，这样的函数成为"常量表达式函数"。
注意：constexpr并非可以修饰任何函数的返回值，函数必须满足4个条件。
(1)函数必须有返回值，返回值不能为void。

constexpr void display() {
    //函数体
}

该函数不是"常量表达式函数"。
(2)整个函数的函数体中，除了可以包含 using 指令、typedef 语句以及 static_assert 断言外，只能包含一条 return 返回语句.

constexpr int display(int x) {
    int ret = 1 + 2 + x;
    return ret;
}

该函数体有多条语句，不是"常量表达式函数"。
(3)函数在使用之前，必须有对应的定义语句。我们知道，函数的使用分为“声明”和“定义”两部分，普通的函数调用只需要提前写好该函数的声明部分即可（函数的定义部分可以放在调用位置之后甚至其它文件中），但常量表达式函数在使用前，必须要有该函数的定义。

#include <iostream>
using namespace std;

// 常量表达式函数的声明
constexpr int Display(int x);
// 常量表达式函数的定义
constexpr int Display(int x)
{
    int ret = 1 + 2 + x;
    return ret;
}

int main()
{
    // int n = 5;
    // n是变量,进行如下声明时,报错
    // int arr[n] = {0};
    // constexpr 修饰普通变量
    constexpr int N = 1 + 2 + 3;
    int arr[N] = {0};
    int a[Display(1)] = { 1,2,3,4};
    cout << a[2] << endl;
    std::cout << "Hello World!\n";
}

(4)return 返回的表达式必须是常量表达式

#include <iostream>
using namespace std;
// 常量表达式函数的声明
constexpr int Display(int x);
// 常量表达式函数的定义
constexpr int Display(int x)
{
    int ret = 1 + 2 + x;
    return ret;
}
int NUM = 3;
constexpr int Play(int x)
{
    return NUM + x;
}

int main()
{
    // int n = 5;
    // n是变量,进行如下声明时,报错
    // int arr[n] = {0};
    // constexpr 修饰普通变量
    constexpr int N = 1 + 2 + 3;
    int arr[N] = {0};
    int a[Display(1)] = { 1,2,3,4};
    cout << a[2] << endl;
    // 报错:NUM的值不可用作常量
   /* int b[Play(0)] = { 1,2,3,4 };
    cout << a[2] << endl;*/
    std::cout << "Hello World!\n";
}

3.修饰类的构造函数
对于strcut或者class 不能用constexpr来修饰，

// 错误：constexpr在此处无效
constexpr struct MyType
{
    const char* name;
    int age;
};

正确的做法应该是在该类型的内部添加一个常量构造函数。如下所示：

struct MyType
{
   constexpr MyType(const char* name, int age) 
        :name(name), age(age) {}
    const char* name;
    int age;
};

注意，constexpr 修饰类的构造函数时，要求该构造函数的函数体必须为空，且采用初始化列表的方式为各个成员赋值时，必须使用常量表达式。
4.constexpr修饰模板函数

//模板函数
template<typename T>
constexpr T dispaly(T t) {
    return t;
}

5.constexpr与指针：

const int *p1=nullptr;		//常量指针
constexpr int *p2=nullptr;	//constexpr只能在开头，等效于指针常量（和const相反）
(等效于 int *const p2=nullptr;)

5.类型别名声明

大家都知道我们可以使用typedef 来为类型取一个别名，例如

// 为unsigned int 声明一个叫做uint_t的别名
typedef unsigned int uint_t;

但是别名只是别名，并不是新的类型。下面这样操作是错的：

void func(unsigned int);
// 错误别名不是新的类型
void func(uint_t);

虽然用typedef 来定义类型非常方便，但是也有局限性，就比如：使用typedef 来声明模板的别名。

// 每一个模板实例化都需要声明一个别名;
typedef std::map<std::string, int> map_int_t;
typedef std::map<std::string, string> map_str_t;

如果我们想要做到如下声明： typedef std::mapstd::string,T ；
我们就只能这样做了：

template<typename T>
struct Str_Map
{
    typedef std::map<std::string, T> type;
};
// 在这里 type 被声明为 std::map<std::string, T>的别名
Str_Map<int>::type map_int_t;
Str_Map<std::string>::type map_str_t;

但是C++11使用using 来声明别名比较简单：
就比如如下的语法：

template<typename T>
using map_str_tNew = std::map<std::string, T>;

在这里使用using 给std::map<std::string, T>;模板取了别名：map_str_tNew 。接下来就可以这样使用
map_str_tNew map;
接下来我们来对比一下这两种语法：

// 声明普通类型的别名
typedef unsigned int uint_t;
using uint_tNew = unsigned int;
// 给实例模板取别名
typedef std::map<std::string, int> map_int_t;
using map_int_tNew = std::map<std::string, int>;

可以看到typedef 的写法就和声明变量是一样的，只需要在类型前面加上typedef 即可。但是这也有一定的缺陷,就比如函数指针的声明定义：

// func_t是函数指针类型
typedef void (*func_t)(int, int);

但是using的用法是立即跟随新的标识符，之后使用类似赋值的操作，吧把现有的类型赋值给"新类型"。

// func_t是函数指针类型
using func_t = void (*func_t)(int, int);

下面通过一个实例来看下具体using是如何定义模板的：

void Test(int a, int b)
{
    cout << "a + b = " << a + b << " " << "Test is called" << endl;
}

/* C++98/03 */
template <typename T>
struct func_t
{
    typedef void (*type)(T, T);
};
// 使用 func_t 模板
func_t<int>::type xx_1;
/* C++11 */
template <typename T>
using func_t = void (*)(T, T);
// 使用 func_t 模板
func_t<int> xx_2;

这里xx_2是void(*)(int,int)得别名，也可以说是函数指针的别名。我们就可以这样使用xx_2。

 xx_2 = Test;
 xx_2(10,10);

需要注意的是使用using 并不会创建一个新的类型，同样只是一个别名。上面的func_t 是一个模板但是这个模板不是类模板也不是函数，而是新的模板的别名。

6.auto自动类型推导

1.C++11中用auto关键字来支持自动类型推导。也就是在编译期间自动推导出变量的类型。
使用auto时必须对变量进行初始化。
auto 关键字的语法如下：auto name = value
auto 用法举例：

auto n = 10;
auto m = 10.2;
auto p = &n;
auto url = "https://www.baidu.com/";

n 变量被自动推导为int,并且被赋初值为10；
m 变量被自动推导为double,并且被赋初值为10.2；
m 变量被自动推导为int*,并且指向为n的地址；
url 变量被自动推导为const char*,并且初始化为"https://www.baidu.com/"；
我们还可以使用一个表达式，例如：

int n = 0;
auto* p = &n, m = 10;

p的类型为int ，所以m变量也是int.
2.我们来看下auto的高级用法：

int x = 0;
// p1是int* 类型,auto被推导为int
auto* p1 = &x;
// p2是int* 类型,auto被推导为int*
auto p2 = &x;
// p3是int& 类型,auto被推导为int
auto& p3 = x;
// p3是int& 类型,auto被推导为int&,p4赋初值p3
auto p4 = p3;

接下来我们再来看下auto与const的结合。

int x = 0;
// p1为const int类型,auto被推导为int
const auto p1 = x;
// auto 被推导为const int类型
auto p2 = p1;
// p3的类型为const int& ,auto被推导为int
const auto& p3 = x;
// auto被推导为const int类型
auto& p4 = p3;

从上面的例子中我们来总结一下：
如果类型不为引用时，auto的推导结果不保留const属性。如p2
如果类型为引用时，auto的推导结果保留const属性。如p4
3.auto的使用限制
除了必须初始化之外,auto还有如下限制：
①auto 不能在函数的参数中使用。
②auto不能用于类的非静态成员。
③auto关键字不能定义数组，比如：

char url[] = "http://c.biancheng.net/";
auto  str[] = url;  //str 为数组，所以不能使用 auto

④不能用于模板。比如：

template<class T>
class A
{
public:
};
A<int> a1;
// 错误，auto不能用于模板
A<auto> a2;

4.auto的使用场景：
①用来定义STL的迭代器。
比如：

vector<vector<int>> v;
// 普通声明迭代器
vector<vector<int>>::iterator i = v.begin();
// 使用auto
auto i = v.begin();

7.decltype类型推导

decltype和auto一样都是在编译时期进行自动类型推导。既然有了auto为什么还要有decltype呢？因为auto并不适用于所有的自动类型推导。auto和decltype都可以推导出变量的类型但是他们的用法不相同：

auto valname = value;
decltype(exp) valname = value;

其中valname 是变量名，value 是赋给变量的值,exp是表达式。auto是根据=右边的值推导出变量的类型。decltype是根据exp表达式推导出变量的类型和=右边的值没有关系。另外auto要求变量必须初始化，但是decltype没有要求。所以decltype可以写成下面这种形式：

decltype(exp) valname;

exp的注意事项：按照道理来说exp可以是任意类型的表达式，但是该表达式必须有结果，并且结果不能为void.
decltype的简单用法：

int a=0;
// b被推导为int
decltype(a) b=1;
// c被推导为double
decltype(5.0) c=1.0;
// c被推导为double
decltype(c + 10.0) d;

从上面可以看到decltype能够根据变量、常量、表达式自动推导变量的类型。

decltype 推导规则
上面的例子让我们初步感受了一下 decltype 的用法，但你不要认为 decltype 就这么简单，它的玩法实际上可以非常复杂。当程序员使用 decltype(exp) 获取类型时，编译器将根据以下三条规则得出结果：
如果 exp 是一个不被括号( )包围的表达式，或者是一个类成员访问表达式，或者是一个单独的变量，那么 decltype(exp) 的类型就和 exp 一致，这是最普遍最常见的情况。
如果 exp 是函数调用，那么 decltype(exp) 的类型就和函数返回值的类型一致。
如果 exp 是一个左值，或者被括号( )包围，那么 decltype(exp) 的类型就是 exp 的引用；假设 exp 的类型为 T，那么 decltype(exp) 的类型就是 T&。
具体例子参看C语言中文网
decltype就写这么多吧。

欢迎大家一起交流和学习！

参考博客：
C语言中文网
 C++11新特性一览表
 cpprefrence