侯捷 C++11/14 笔记

已于 2022-08-04 13:35:51 修改
阅读量767 收藏 5
点赞数 2
分类专栏： C++ 文章标签： c++ 哈希算法 散列表
于 2022-07-28 20:35:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eeemmm/article/details/126043308
版权

侯捷 C++11/14 笔记

原文地址：侯捷 C++11/14 笔记

Variadic Template

概述

可变参数模板。

  1. 谈的是模板Templates：

    • 函数模板
    • 类模板

  2. 变化的是模板参数：

    • 参数个数：利用参数个数逐一递减的特性，实现递归函数的调用，使用函数模板完成。
    • 参数类型：利用参数个数逐一递减以致参数类型也逐一递减的特性，实现递归继承或递归复合，以类模板完成。
void print()
{
}
 
template <typename T, typename... Types>                //这里的...是关键字的一部分：模板参数包
void print(const T& firstArg, const Types&... args)     //这里的...要写在自定义类型Types后面：函数参数类型包
{
    cout << firstArg << endl;
    print(args...);                                     //这里的...要写在变量args后面：函数参数包
}

  1. 注意三种不同的...的应用环境，这些都是语法规则，所以记住即可。

  2. 还要注意的是，在可变模板参数内部可以使用sizeof...(args)得到实参的个数。

  3. 如果同时定义了：

template <typename... Types>
void print(const Types&... args)
{/*......*/}

该函数重载了void print()，void print(const T& firstArg, const Types&... args) 是其特化版本，编译器会优先调用特化版本。

应用

  1. 实现函数的 递归调用

    举了一个unordered容器中hash函数的计算例子：万用的哈希函数，函数入口return hash_val(c.fname, c.lname, c.no);

class CustomerHash{
public:
    std::size_t operator() (const Customer& c) const {
        return hash_val(c.fname, c.lname, c.no);
        // 2-1-1-...-1-3
    }
};
 
template <typename T, typename... Types> // 1
inline void hash_val(size_t& seed, const T& val, const Types&... args){
    hash_combine(seed, val);
    hash_val(seed, args);
}
 
template <typename... Types> // 2
inline size_t hash_val(const Types&... args){
    size_t seed = 0;
    hash_val(seed, args...);
    return seed;
}
 
template <typename T> // 3
inline void hash_val(size_t& seed, const T& val){
    hash_conbine(seed, val);
}

递归调用

  1. 实现递归继承
template <typename... Values> class tuple;
template <> class tuple<> {};

template <typename Head, typename... Tail>
class tuple<Head, Tail...>
    : private tuple<Tail...>                  //注意这里的私有继承
{
    typedef tuple<Tail...> inherited;
public:
    tuple() {}
    tuple(Head v, Tail... vtail)
        :m_head(v), inherited(vtail...) {}

    Head head() { return m_head; }
    inherited& tail() { return *this; }       //这里涉及派生类到基类的类型转换

protected:
    Head m_head;
};

递归继承

模板表达式中的空格

C++11可以去掉模块表达式前面的空格。

nullptr

标准库允许使用nullptr取代0或者NULL来对指针赋值。

  • nullptr 是个新关键字
  • nullptr 可以被自动转换为各种 pointer 类型，但不会被转换为任何整数类型
  • nullptr的类型为std::nullptr_t，定义于 头文件中
void f(int);
void f(void *);

f(0);        // 调用 f(int).
f(NULL);     // 如果定义NULL为0，则调用 f(int)，否则具有二义性
f(nullptr);  // 调用 f(void *).

auto

  1. C++11 auto可以进行自动类型推导。
    • C语言默认的局部变量是auto类型的
    • C++11 auto可以进行自动类型推导
  2. 使用auto的场景：类型太长或者类型太复杂

一致性初始化（uniform initialization）

C++11之前初始化时存在多个版本 {}，（），=。让使用者使用时比较混乱，C++11提供一种万用的初始化方法，就是使用大括号{}。

原理解析：当编译器看到大括号包起来的东西{t1,t2...tn}时，会生成一个initializer_list<T>（initializer_list关联至一个array<T,n>）。调用函数（例如构造函数ctor）时该array内的元素可被编译器分解逐一传给函数；元素逐一分解传递给函数进行初始化。

但是如果调用函数自身提供了initializer_list<T>参数类型的构造函数时，则不会分解而是直接传过去。直接整包传入进行初始化。所有的容器都可以接受这样的参数。

Initializer_list

int i;      // 未初始化
int j{};    // j = 0
int* p;     // 未初始化
int* q{};   // q = nullptr

  1. initializer_list<T>使用举例：

    • initializer_list<T>是一个class（类模板），这个必须类型要一致，跟模板不定的参数类型相比，模板不定的参数类型可以都不一样。
    • initializer_list<T>类似于容器的使用方法

  2. initializer_list源码剖析：

    • initializer_list<T>背后有array数组支撑，initializer_list关联一个array<T,n>
    • initializer_list<T>包含一个指向array的指针，它的拷贝只是一个浅拷贝，比较危险，两个指针指向同一个内存。

  3. initializer_list在STL中的使用：

    • 所有容器都接受指定任意数量的值用于构造或赋值或者insert()或assign()。
    • 算法max()和min()也接受任意参数。

explict

explicit关键字一直存在，只能作用在构造函数中，目的是阻止编译器进行不应该允许的构造函数进行隐式转换。声明为explicit的构造函数不能进行隐式转换，只能允许使用者明确调用构造函数。

C++11之前，只有non-explicit one argument的构造函数才能进行隐式转换，2.0之后支持more than one argument的构造函数的隐式转换。

基于范围的for循环

for (decl : coll) {
    statement
}

// 例子
vector<double> vec;

//...
for(auto elem:  vec) {...};     // 赋值，无法改变容器的内容
for(auto& elem:  vec) {...};    // 引用

基于范围的for循环对于explicit类型申明的转换是不可以的。

= default, = delete

在 C++ 中，如果自定义了 big-five 函数，编译器就不会再生成默认的相关函数，但是如果我们在后边加上= default 关键字，就可以重新获得并使用编译器为我们生成的默认函数（显式缺省:告知编译器即使自己定义了也要生成函数默认的缺省版本）；

=delete关键字相对于上面来说则是相反的，=delete表示不要这个函数，就是说这个函数已经删除了不能用了，一旦别人使用就会报错（显式删除：告知编译器不生成函数默认的缺省版本)，引进这两种新特性的目的是为了增强对“类默认函数的控制”，从而让程序员更加精准地去控制默认版本的函数。

补充：

1、编译器提供的默认函数：

C++中，当我们设计与编写一个类时，若不显著申明，则类会默认为我们提供如下几个函数：

  1. 构造函数(A())
  2. 析构函数（~A()）
  3. 拷贝构造函数(A(A&))
  4. 拷贝赋值函数（A& operator=(A&)）
  5. 移动构造函数（A(A&&)）
  6. 移动赋值函数（A& operator=(A&&)）

注意：拷贝函数如果涉及指针就要区分浅拷贝（指针只占4字节，浅拷贝只把指针所占的那4个字节拷贝过去）和深拷贝（不仅要拷贝指针所占的字节，还要把指针所指的东西也要拷贝过去）；

默认提供全局的默认操作符函数：

  1. operator
  2. operator &
  3. operator &&
  4. operator *
  5. operator->
  6. operator->*
  7. operator new
  8. operator delete

2、何时需要自定义big-three(构造函数、拷贝构造、拷贝赋值)/big-five(新增移动构造函数、移动赋值函数)？

如果类中带有pointer member（指针成员），那我们就可以断定必须要给出 big-three ；
如果不带，绝大多与情况下就不必给出 big-three 。

3、default、delete关键字使用示例

=default, =delete

在c++中，如果你自定义了big-five函数，编译器就不会再为你生成默认的相关函数，但是如果我们在后边加上= default关键字，就可以重新获得并使用编译器为我们生成的默认函数（显式缺省:告知编译器即使自己定义了也要生成函数默认的缺省版本）；

=delete关键字相对于上面来说则是相反的，=delete表示不要这个函数，就是说这个函数已经删除了不能用了，一旦别人使用就会报错（显式删除：告知编译器不生成函数默认的缺省版本)，引进这两种新特性的目的是为了增强对“类默认函数的控制”，从而让程序员更加精准地去控制默认版本的函数。

image-20220802201319128

Alias Template

template <typename T>
using Vec = std::vector<T, MyAlloc<T>>

//使用
Vec<int> coll;

Alias Template 无法特化。

应用实例(引出模板模板参数)

考虑这样一种需求，假设我们需要实现一个函数test_moveable(容器对象，类型对象)，从而能实现传入任意的容器和类型，都能将其组合为一个新的东西：容器<类型>，这样的话我们的函数应该怎么设计呢？

（1）解法一：函数模板(无法实现)

template <typename Container, typename T>
void test_moveable(Container cntr, T elem)
{
    Container<T> c;            //[Error] 'Container' is not a template
    
    for(long i=0; i<SIZE; ++i)
        c.insert(c.end(), T());
    
    output_static_data(T());
    Container<T> c1(c);
    Container<T> c2(std::move(c));
    c1.swap(c2);
}

（2）解法二：函数模板+iterator+traits(可以实现)

template<typename Container>
void test_moveable(Container c)
{
    typedef typename iterator_traits<typename Container::iterator>::value_type Valtype;
    
    for(long i=0; i<SIZE; ++i)
        c.insert(c.end(), Valtype());
    
    output_static_data(*(c.begin()));
    Container<T> c1(c);
    Container<T> c2(std::move(c));
    c1.swap(c2);
}

这样做是可以达到效果的，但是却改变了函数签名，使用的时候我们需要这样调用：test_moveable(list<int>())，和我们开始设计的是不一样的。那么，有没有 template 语法能够在模板接受一个 template 参数 Container 时，当 Container 本身又是一个 class template ，能取出 Container 的template 参数？例如收到一个vector<string>，能够取出其元素类型string？那么这就引出了模板模板参数的概念。也就是下面的解法三。

（3）解法三：模板模板参数 + alias template(可以实现)

template <typename T,
          template <typename T> // 模板模板参数中的T可以不写，默认就是前面的T
              class Container
         >
class XCls
{
private:
    Container<T> c;
public:
    XCLs()
    {
        for(long i=0; i<SIZE; ++i)
            c.insert(c.end(), T());
 
        output_static_data(T());
        Container<T> c1(c);
        Container<T> c2(std::move(c));
        c1.swap(c2);
    }
};

// 使用时会报错
XCls<MyString, vector> c1;        //[Error] vector的实际类型和模板中的Container<T>类型不匹配

这是因为 vector 其实有两个模板参数，虽然第二个有默认值，我们平时也可以像vector<int>这样用。但是在模板中直接这样写类型是不匹配的（ Container 只有一个模板参数 ）。所以这里就用到了我们一开始提到的模板别名，只要传入的是vector的模板别名就可以了，如下所示：

//不得在function body之内声明
template<typename T>
using Vec = vector<T, allocator<T>>;
 
XCls<MyString, Vec> c1;

Type Alias

类型别名类似于typedef。

using func = void(*)(int, int);
//相当于
typedef void (*func)(int, int);

using 的用法：

  1. 打开命令空间或者命令空间的成员
  2. 类似第一种，打开类的成员
  3. 类型别名和模板别名（C++ 11开始支持）
using std::cin;                 //1
using _Base::_M_alloacte;       //2
using func = void(*)(int, int); //3

noexpect

保证该函数不会丢出异常，可以在后面加上条件,也就是说在某种条件满足情况下，不会抛出异常。

void foo() noexpect;
void foo() noexpect(true);

一般异常处理流程：当程序发生异常时会将异常信息上报返回给调用者，如果有异常处理则处理，如果该调用者没有处理异常则会接着上报上一层，若到了最上层都没有处理，就会调用std::terminate()->std::abort()，然后终止程序。

{% note warning %}
移动构造函数和移动赋值函数。如果构造函数没有noexcept，vector将不敢使用它。
{% endnote %}

override

override用于明确要重写父类的虚函数上，相当于告诉编译器这个函数就是要重写父类虚函数这样一个意图，让编译器帮忙检查，而没有这个关键字，编译器是不会帮你检查的。

override

final

final新增两种功能：

  1. 禁止基类被继承
  2. 禁止虚函数被重写

decltype

decltype 定义

引入新关键字decltype可以让编译器找出表达式的类型，为了区别typeof，以下做一个概念区分：

  • typeof是一个一元运算，放在一个运算数之前，运算数可以是任意类型，非常依赖平台，已过时，由decltype代替；理解为：我们根据typeof()括号里面的变量，自动识别变量类型并返回该类型；
  • typedef：定义一种类型的别名，而不只是简单的宏替换；
  • define：简单的宏替换；
  • typeid() 返回变量类型的字符串，用于print变量类型。

decltype 用法

  1. 用来声明函数的返回值类型，一种新的指定函数返回值类型的方式；
template<typename T1, typename T2>
auto Add(T1 x, T2 y) -> decltype(x + y);
  1. 模板之间的应用

模板之间的应用

  1. 用来求 lambda 表达式的类型

    lambda 是匿名的函数对象或仿函数，每一个都是独一无二的；如果需要声明一个这种对象的话，需要用模板或者 auto ；如果需要他的 type ，可以使用 decltype ；lambda 没有默认构造函数和析构函数。

lambda表达式

Lambdas

lambda 语法以及调用方式

定义： lambda 是一组功能的组合定义， lambda 可以定义为内联函数，可以被当做一个参数或者一个对象，类似于仿函数。

最简单的形式：

[] {
    statements
};

auto l = [] {
    statements
};

l();

完整形式：
lambda表达式

含义
[]lambda 导入器，取用外部变量
()类似函数参数
mutable[]中的导入数据是否可变
throwSpec抛出异常
retType类似函数返回值
{}类似函数体

image-20220802201742502

image-20220802201822504

C++11新特性(侯捷)——课程笔记(三)
NiuYutao的博客
07-10 356
这部分主要讲uniform initialization，一致性初始化。之前的内容：(1)类似vector<vector<int>>后面的空格自C++11以来可以去掉；(2)nullptr关键字；(3)auto不做总结。 一、概述 1. 背景 在C++11之前，初始化操作可以用很多种方法来实现，比如说小括号，大括号以及赋值符号，如下所示： Rect r1 = { 3, 7, 20, 25, &area, &print }; Rect r1(3, 7, 20,
侯捷C++八部曲笔记（一、面向对象）
weixin_42065178的博客
06-03 5519
侯捷C++八部曲笔记（一、面向对象）
侯捷c++11课程学习笔记
dsaaf21的博客
10-23 878
文章目录decltypelambdauniform initializationinitializer_listvariadic tmplates=default,=delete右值引用与左值引用移动语义与完美转发移动语义写一个move aware class完美转发智能指针auto_ptr(c++11已弃用)unique_ptrshared_ptrweak_ptr decltype 使用它让编译器来推测出一个表达式的类型，相当于typeof 三个用途： ①用来声明return type ②用于元编程
【C++标准11-14-侯捷】---学习笔记
plain_rookie的博客
03-21 1862
第一讲 语言 第一节 头文件header files （1）标准库都在std名称空间中，全名为std::+名字； （2）旧版本就是#include<stdio.h>也可以兼容使用； 1.2 看源代码需要全文检索工具 1.3 测试是否支持并设置C++2.0，__cplusplus 1.4 主要学习内容—C++2.0版本 第2节 Variadic Templates可变参数模板（重量级改变） 2.1 print（）为例 （1）const Type&… args表明接收任意数量任意类
C++11新特性(侯捷)——课程笔记(一)
NiuYutao的博客
07-08 680
课程大纲 一、语言 Variadic Templates，move Semantics，auto，Range-base for loop，Initializer list，Lambdas 二、标准库 type_traits，Unordered容器，forward_list，array，tuple，Con-currency，RegEx
侯捷C++11课程笔记---第一次课
qq_47997583的博客
11-05 243
侯捷C++11课程笔记 第一课：演进，环境与资源 1.C++Standard之演化 C++ 98（1.0） C++03（TR1） C++11（2.0） C++14 2.Header files C++ 2.0新特性包括语言和标准库两个层面，后者以header files形式呈现 C++ 标准库的header files不带（.h），例如 #include 新式的C header files不带（.h），例如 #include 旧式的C header files带（.h），例如 #include<
侯捷C++八部曲笔记（三、设计模式）
weixin_42065178的博客
06-07 3743
侯捷C++八部曲笔记（三、设计模式）
侯捷C++八部曲笔记（二、STL标准库和泛型编程）
weixin_42065178的博客
06-05 3569
侯捷C++八部曲笔记（二、STL标准库和泛型编程）
侯捷C++面向对象高级开发（上）笔记
d_mail的博客
04-19 1226
函数定义在构造函数body内部，自动声明为inline，即类中的成员函数缺省都是内联的，但能否内联要看编译器，在构造函数外部声明内联函数要加inline关键字。3.inline函数仅仅是一个对编译器的建议，所以最后能否真正内联，看编译器的意思，它如果认为函数不复杂，能在调用点展开，就会真正内联，并不是说声明了内联就会内联，声明内联只是一个建议而已。2.在一个大的软件工程里面，可能会有多个文件同时包含一个头文件，当这些文件编译链接成一个可执行文件上时，就会出现大量“重定义”错误。
侯捷C++视频笔记——C++面向对象高级编程（上）
weixin_45067603的博客
01-19 4791
C++面向对象高级编程（上） 01、C++编程简介 学习目标： 1.学习良好的编写C++类的形式，包括两种，分别是无指针成员类(如Complex)和有指针成员类(如String) 2.学习类之间的关系，即继承，复合和委托。 02、头文件和类的声明 1.C和C++在数据和函数的区别： C中存在数据以及函数，函数用来处理数据。缺点是缺少关键字管理数据，数据均为全局，难以作限制 C++中通过类将数据和函数包在一起，以类为个体来创建对象。是面向对象的语言。 2.防卫式声明: #ifndef _name_ #defi
侯捷C++11课程笔记---第三次课
qq_47997583的博客
11-06 311
侯捷C++11课程笔记—第三次课 侯捷C++11课程笔记 第三课：Spaces in Template Expressions,nullptr and std::nullptr_t,Automatic Type Deduction with auto 1.Spaces in Template Expressions vector<list<int> >; //OK in each C++ version vector<list<int>>; //OK
侯捷 | C++11 新特性 | 学习笔记
最新发布
m0_74795952的博客
10-11 1487
auto 的一个典型应用场景是用来定义 stl 的迭代器。我们在使用 stl 容器的时候，需要使用迭代器来遍历容器里面的元素；不同容器的迭代器有不同的类型，在定义迭代器时必须指明。return 0;可以看出来，定义迭代器 i 的时候，类型书写比较冗长，容易出错。然而有了 auto 类型推导，我们大可不必这样，只写一个 auto 即可。//使用 auto 代替具体的类型return 0;
【侯捷 C++标准11】课程笔记以及个人注释（附带课程资源）
qq_42234461的博客
10-09 3797
前言 上周我们学习了【侯捷 C++ 面向对象高级开发】课程笔记以及个人注释（附带课程资源） 趁热打铁，继续学习。 这个系列教程主要讲述了Cpp11和14的新特性，只谈新东西。 这个教程我之前摸索学习了大概几节课，现在重新系统学习一下。 该课程笔记会记录我认为所有重要的、有用的知识点。 重要说明： 侯捷老师说得非常好，十分详细，一定要自己看看才可以知道我这个笔记在说什么。 很多东西我觉得比较泛用，如auto，range-based for，我就没有记下来。 课程资源 源自公众号：编程指北 链接: htt
C++学习笔记 (侯捷—上)
qq_27087743的博客
02-21 898
目录 1、C与C++的区别： 2、c++的头文件与类的声明 3、inline（内联）函数 4、access level(访问级别) 5、构造函数 6、常量成员函数 : const member functions 7、参数传递： pass by value vs. pass by reference(to const) 8、返回值传递：return by value vs. ret...
C++11新特性(侯捷)——课程笔记(九)
NiuYutao的博客
07-16 690
本部分的内容包括右值引用(rvalue reference)以及move语义的初步介绍。 一、Rvalue references Rvalue references are a new reference type introduced in C++ that help solve the problem of unnecessary copying and enable perfect forwarding. When the right-hand side of an assignment is a
C++11/14学习笔记（未完成）
哆啦A瑶的博客
10-13 364
本篇内容为侯捷《C++ 11》听课笔记，只讨论在C++中出现的新内容。 0、准备工作 0.1、C++ Standard演化 C++版本 版本名称 说明 C++ 98 1.0 C++ 03 TR1, Technical Report 1 许多TR1的特性存在std::tr1中，现在TR1的内容已经被放到STD中，因此现在在std命名空间中 ...
侯捷C++课程笔记04: C++2.0新特性
ncepu_Chen的博客
04-07 3081
侯捷C++课程笔记04: C++2.0新特性语言新特性模板表达式中的空格`nullptr`和`std::nullptr_t`使用`auto`自动推断类型uniform initialization 语言新特性 模板表达式中的空格 在C++11之前,多层模板参数在嵌套时,最后的两个>之间要加一个空格,以避免和>>运算符混淆;C++11之后就不需要这样做了 vector<list<int> >; // 左右版本均能通过编译 vector<list<int&
【学习笔记】侯捷C++学习笔记（一）
一条小咸鱼的成长之路
04-18 1648
由于编译器每次都需要打开头文件才能判定是否有重复定义，因此在编译大型项目时，ifndef会使得编译时间相对较长，因此一些编译器逐渐开始支持#pragma once的方式。当然，缺点就是如果不同头文件中的宏名不小心“撞车”，可能就会导致你看到头文件明明存在，但编译器却硬说找不到声明的状况——这种情况有时非常让人郁闷。C++ 的 class 是在 C 的 struct 结构上拓展而来的，比 struct 引入了更多的功能和关键字。声明范围的情况，此时外界无法直接调用该类的构造函数，即该类无法生成对应的对象。
C++11笔记二
干煸四季豆
04-23 155
) { num=n; }//普通构造函数 private: int num; }; class Test2 { public: explicit Test2(int n) { num=n; }//explicit(显式)构造函数 private: int num; }; int main() { Test1 t1=12;//隐式调用其构造函数,成功 Test2 t2
侯捷c++笔记stl
08-13
关于侯捷的C++笔记中的STL部分，我可以给你一些基本的信息。STL（标准模板库）是C++的一个重要组成部分，它提供了一系列的模板类和函数，用于实现常用的数据结构和算法。 STL主要包括以下几个部分： 1. 容器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AWei_i_i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值