从0开始自制解释器——实现简单的加法计算器 为什么要学习编译器和解释器呢？文中的作者给出的答案有下面几个：为了深入理解计算机是如何工作的：一个显而易见的道理就是，如果你不懂编译器和解释器是如何工作的那么你就不明白计算机是如何工作的编译器和解释器用到的一些原理和编程技巧以及算法在其他地方也可以用到。学习编译器和解释器能够学到并强化这些技巧的运用为了方便日后能编写自己的编程语言或者专用领域的特殊语言接下来我们就从0开始一步一步的构建自己的解释器。跟着教程先制作一个简单的加法计算器，为了保证简单，这个加法计算器能够解析的表达式需要满足下面几点：目前只支持加法运算目前只支持两个10以内的整数的计算表达式之间不能有空格只能计算一次加法举一个例子来说，它可以计算诸如"1+2"、"5+6" 这样的表达式，但是不能计算像 "11+20"(必须是10以内)、"1.1+2"(需要两个数都是整数)、"1 + 2"(中间不能有空格)、"1+2+3"(只能计算一次加法)有了这些限制，我们很容易就能实现出来。实现的算法假设我们要计算表达式 5+6。这里主要的步骤是通过字符串保存表达式，然后通过索引依次访问每个字符，分别找到两个整数和加法运算符，最后实现两个整数相加的操作。第一步，我们的索引在表达式字符串的开始位置，解析得到当前位置的字符是一个整数，我们给它打上标记，类型为整形，值为5。第二步，索引向前推进，解析当前位置的字符是一个+。还是给它打上标记，类型为plus，值为+。第三步，索引继续前进，解析到当前位置的字符是一个整数，我们给它打上标记，类型为整形，值为6最后一步，根据得到的两个整数以及要执行的算术运算，我们将两个数直接进行相加得到最终结果具体的代码首先我们定义这个标记的类型，目前支持整数以及加法的标记typedef enum e_TokenType { CINT = 0, //整型 PLUS //加法运算符 }ETokenType; // 这里因为只支持10以内的整数，所以表示计算数字的字符只有一个，加上字符串最后的结束标记，字符数组只需要两个即可 typedef struct Token { ETokenType type; //类型 char value[2]; //值 }Token, *LPTOKEN;接着定义一些全局变量来保存算术运算的表达式和当前指针的索引char* g_pszUserBuf = NULL; char* g_pPosition = NULL;接着我们定义一个函数来模拟上述说到的不断解析每一个字符的过程bool get_next_token(LPTOKEN pToken) { char* sz = g_pPosition; g_pPosition++; pToken->value[0] = '\0'; if (*sz >= '0' && *sz <= '9') { pToken->type = CINT; pToken->value[0] = *sz; return true; } else if (*sz == '+') { pToken->type = PLUS; pToken->value[0] = *sz; return true; } else { pToken->value[0] = '\0'; return false; } }最后我们定义一个函数来执行获取每个标记并最终计算结果的操作int expr() { int val1 = 0, val2 = 0; Token token = { 0 }; if (get_next_token(&token) && token.type == CINT) { val1 = atoi(token.value); } else { printf("首个字符必须是整数"); return -1; } if (get_next_token(&token) && token.type == PLUS) { } else { printf("第二个字符必须是操作符，并且当前只支持 + 运算"); return -1; } if (get_next_token(&token) && token.type == CINT) { val2 = atoi(token.value); } printf("%d+%d=%d\n", val1, val2, val1 + val2); }在main函数里面我们只需要建立一个缓冲来保存字符，并且在循环中不断等待用户输入，完成解析并输出结果即可// 重制当前解析环境 void reset() { memset(g_pszUserBuf, 0x00, 16 * sizeof(char)); scanf_s("%s", g_pszUserBuf); g_pPosition = g_pszUserBuf; } int main() { g_pszUserBuf = (char*)malloc(16 * sizeof(char)); while (1) { printf(">>>"); reset(); if (strcmp(g_pszUserBuf, "exit") == 0) { break; } expr(); } return 0; }最终执行的结果如下最后的总结程序我们已经写完了，你可能觉得这个程序太简单了，只能做这点事情。别着急，后面将会逐步的去完善这个程序。以便它能实现更加复杂的运算。最后我们来引入一些概念性的东西：我们将输入内容按照一定规则打上的标记被称之为Token上述get_next_token函数体现的将一段字符串分割并打上有意义的标签的过程被称为词法分析。解释器工作的第一步就是将输入的字符串按照一定的规则转换为一系列有意义的标记。完成这个工作的组件被称之为词法分析器，也可以被称为扫描器或者分词器

从0开始自制解释器——综述 作为一个程序员，自制自己的编译器一直是一个梦想。之前也曾为了这个梦想学习过类似龙书、虎书这种大部头的书，但是光看理论总有一些云里雾里的感觉。看完只觉得脑袋昏昏沉沉并没有觉得有多少长进。当初看过《疯狂的程序员》这本书，书里说，真正能学会编译原理并不是靠看各种书然后通过相关考试，而是有一天你的领导找到你对你说：“小X啊，你是我们公司技术能力最强的人，咱们现在用的编译器性能有点跟不上，要不你看看能不能改进一下”。所以想要学习编译原理相关的知识首先要做的还是实践——实现一个自己的编译器。之前也看过类似的教你如何自制编译器，但是他们有一个共同的问题就是在很大程度上都借助第三方工具，隐藏了一些底层的细节。我希望的是每一行代码都是自己的完成的。所以一直怀揣着这个梦想直到最近我找到了一篇教程。一起写一个简单的编译器——魔力Python。这篇教程是实用Python完成的，但是这里我不打算使用Python，我打算实用最纯粹的C 语言来完成这个任务，我考虑使用C主要基于以下几个原因:Python 有一些封装的细节，不方便全方位的展示相关算法。原教程使用的就是Python，还用一样的话思路会受到教程的影响，要真正的理解需要自己一行行的敲代码，最好的方式就是用另一种语言来实现同样的算法现在市面上大多数都是用c来实现编译器，如果后续想要更近一步学习编译原理可以考虑在我完成的这版中很方便的加入一些新学的知识点自己有使用C的能力，而且用C写编译器自带装B属性基于以上理由，我准备开始跟着教程使用C来实现自己的解释器。这并不是一篇教程什么的，更多的是作为一篇实践笔记。而且根据我之前写的Vim专栏的经验来说，将它已专栏的形式发布出来之后鸽的可能性更小，更有动力来完成它。当然如果各位能从专栏中学到什么那就更好了。总之后面让我们一起进入学习编译原理的路程吧

MFC程序中使用QT开发界面 如果你有一个现成的MFC项目在做维护，但是你厌倦了使用MFC繁琐的操作来做界面美化，或者你需要在这个项目中用到QT里面好用的某些功能；亦或者是你需要使用某些只能在MFC中使用的组件，但是界面这部分已经用QT做好了。那么这篇文章可能可以帮助到你演示环境使用Visual Studio 2019 + QT5.12.8 版本添加QT依赖首先创建一个基于对话框的MFC工程，当然其他的像是多文档、单文档工程也是可以的，只是为了简单起见我这里用的是对话框然后通过鼠标右键点击项目，然后依次点击属性 --> C/C++ -->常规在工程的附加头文件中添加上QCore、QGui、QWidget和QT的头文件路径这里记得按照对应编译选项来选择包含64位或者32。接着在连接器-->常规 中的附加库目录中添加qt的lib库最后再在连接器-->输入中添加依赖的lib文件，需要注意的是，debug版本需要链接上带d的lib文件，release则链接上不带d的。先编译一下，如果没有问题，qt相关的配置已经完成了添加信号槽机制MFC是基于Windows 消息队列来处理和响应ui事件的，而qt是采用信号槽机制来响应的，我们虽然添加了qt的依赖，但是现在只能使用其他的qt库，无法使用qt中的信号槽，需要额外添加一些组件来使mfc支持信号槽。好在这部分需求qt相关的研发人员已经考虑到了，可以在github中找到 QMfcApp我们可以将这两个文件给拷贝下来，添加到项目中。并且在cpp文件相应位置添加上 #include "pch.h"包含预处理头中间会有报错，这是因为在Unicode 字符集下 CString 中的字符串类型是 wchar_t* QString::fromLocal8bit 无法 从 wchar_t* 转化为 char* 所以这里可以修改一下，使用 QString::fromStdWString(),然后进行编译在QMfcApp.cpp的注释里面可以看到，如何使用它/*! Creates an instance of QApplication, passing the command line of \a mfcApp to the QApplication constructor, and returns the new object. The returned object must be destroyed by the caller. Use this static function if you want to perform additional initializations after creating the application object, or if you want to create Qt GUI elements in the InitInstance() reimplementation of CWinApp: \code BOOL MyMfcApp::InitInstance() { // standard MFC initialization // ... // This sets the global qApp pointer QMfcApp::instance(this); // Qt GUI initialization } BOOL MyMfcApp::Run() { int result = QMfcApp::run(this); delete qApp; return result; } \endcode \sa run() */首先在app类的InitInstance 函数中初始化QApplication类BOOL CMFCWithQtApp::InitInstance() { CWinApp::InitInstance(); QMfcApp::instance(this); return true; }然后需要重写 app类的run 方法，在该方法中调用QMFC 的run方法int CMFCWithQtApp::Run() { int result = QMfcApp::run(this); delete qApp; return result; }再次编译一下，完成了往mfc中添加信号槽机制的功能添加qt界面在项目中新建一个界面类，让他继承自QWidget，如下// MainUI.h #pragma once #include <QWidget> class MainUI: public QWidget { Q_OBJECT public: MainUI(QWidget* parent = nullptr); ~MainUI(); }; //MainUI.cpp #include "pch.h" #include "MainUI.h" #include <QPushButton> MainUI::MainUI(QWidget* parent) : QWidget(parent) { setWindowTitle("Qt Windows"); setFixedSize(800, 720); QPushButton* pBtn = new QPushButton(QString::fromLocal8Bit("这是一个Qt按钮"), this); } MainUI::~MainUI() { }然后在App 类的 InitInstance 中启动该界面BOOL CMFCWithQtApp::InitInstance() { CWinApp::InitInstance(); QMfcApp::instance(this); MainUI ui; ui.show(); QMfcApp::exec(); return FALSE; }然后编译，这个时候发现会在链接的时候包一些错误，找不到一些 meta 的函数的定义配置元编译过程传统的c/c++ 从源代码到生成可执行文件的过程需要经过预编译、编译、链接。而qt在预编译前会进行元编译，生成一个moc_开头的源码文件，后续编译的真正的文件其实是这个元编译生成的文件。MFC项目不会经历这一步，所以会报错。在MainUI.h 上点击右键，选择属性, 将项目类型选择为自定义生成工具然后应用，这个时候会出现新的选项在命令行和输入这两栏中分别填入 "moc.exe" "%(FullPath)" -o ".\GeneratedFiles\moc_%(Filename).cpp" "-fpch.h" "-f../MainUI.h" 和 .\GeneratedFiles\moc_%(Filename).cpp命令行的含义是会使用moc元编译器编译当前文件，并将生成的文件放入到当前目录下的GeneratedFiles子目录中，并且以moc_开头作为文件名，后面 -f 表示生成的新文件中会包含 #include "pch.h" 和 #include "../MainUI.h" 然后在文件中选择右键，编译。这样将会生成moc文件(两边的双引号也好包含进去)如果编译的时候报找不到moc.exe 这样的错误，请配置QT中的bin路径到环境变量中我们将新生成的文件添加到项目中再次编译，成功过后点击运行就可以看到qt界面已经展示出来了一些问题的处理窗口出来了，但是在我的环境下出现两个问题，关闭窗口后进程无法退出；程序退出后出现内存泄露的问题针对这两个问题可以在QMfcApp.cpp 文件中修改// 表示在最后一个qt窗口退出时，关闭QApplication setQuitOnLastWindowClosed(true); //将之前的false改为true// ~QMfcApp() 中添加这两句，当析构完成后关闭进程 HANDLE hself = GetCurrentProcess(); TerminateProcess(hself, 0);测试信号槽我们可以在MainUI中添加信号槽MainUI::MainUI(QWidget* parent) : QWidget(parent) { setWindowTitle("Qt Windows"); setFixedSize(800, 720); QPushButton* pBtn = new QPushButton(QString::fromLocal8Bit("这是一个Qt按钮"), this); connect(pBtn, &QPushButton::clicked, [=]() { QMessageBox::information(this, QString::fromLocal8Bit("信号槽"), QString::fromLocal8Bit("这是由信号槽弹出来的")); }); }点击按钮之后，消息框也正常弹出来了使用qt designer 设计界面使用 qtdesigner 设计这样一个界面qtdesigner 会生成一个.ui文件，在qt的开发环境中，会自动使用uic.exe 将这个文件生成一个对应的.h文件。我们先将ui文件导入到项目，并且按照之前的步骤设置自定义生成工具，填入如下命令行"uic.exe" "%(FullPath)" -o ".\ui_%(Filename).h"并且填写上输出路径.\ui_%(Filename).h编译之后会生成一个对应的ui_MainUi.h 文件，修改对应的MainUI.h 头文件，加上关于它的引用，并且添加一个ui的对象指针//MainUI.h #pragma once #include <QWidget> #include "ui_Main.h" class MainUI: public QWidget { Q_OBJECT public: MainUI(QWidget* parent = nullptr); ~MainUI(); private: Ui::mainUI* m_pUI; };在类的构造中，使用ui对象来产生界面元素//MainUI.cpp #include "pch.h" #include "MainUI.h" #include <QPushButton> #include <QMessageBox> MainUI::MainUI(QWidget* parent) : QWidget(parent), m_pUI(new Ui::mainUI()) { m_pUI->setupUi(this); connect(m_pUI->pushButton, &QPushButton::clicked, [=]() { QMessageBox::information(this, QString::fromLocal8Bit("qt 信号槽测试"), m_pUI->lineEdit->text()); }); } MainUI::~MainUI() { delete m_pUI; }执行效果如下

动态内存与智能指针 c/c++语言的一大特色是在于可以动态的进行内存管理，而这也是它的难点所在。程序出现问题，原因经常在动态内存管理这块，比如分配内存后没有及时释放，或者当前线程提前释放了其他线程也会使用的内存。而c++11中新增的智能指针能在一定程度上解决这些问题动态内存与智能指针在c++中动态内存的管理是通过一对运算符来完成的: new和delete ，new为对象分配空间并返回一个指向该对象的指针。delete 接受一个动态对象的指针，销毁对象并释放相关内存动态内存的管理十分困难，有时候会忘记释放内存，这种情况下会产生内存泄漏。有时在尚有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。为了更容易也更安全的使用动态内存，新的标准提供了两种智能指针类型来管理动态对象。shared_ptr 类类似于vector 智能指针也是模板。创建智能指针时，必须提供额外的信息——指针可以指向的类型。智能指针的用法与普通指针类似。解引用一个智能指针返回它指向的对象，箭头运算符可以返回对象中的成员shared_ptr<string> p = new string; if(nullptr != p && p->empty()) { *p = "hello world"; //字符串为空的时候，将一个新值赋予string }最安全的分配和使用动态内存的方法是调用一个名为 make_shared 的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回此对象的 shared_ptr。shared_ptr<int> p3 = make_shared<int>(42); //初始化p3 指向一个值为42的int类型 shared_ptr<string> p4 = make_shared<string>(10, '9'); //p4指向一个值为 "9999999999" 的string shared_ptr<int> p5 = make_shared<int>(); //指向一个值初始化的int，即，值为0当shared_ptr 进行拷贝和赋值操作时，每个shared_ptr 都会记录有多少个其他的shared_ptr 指向相同的对象auto p = make_shared<int>(42); //此时p指向的对象只有一个引用值 auto q = p; //此时p指向的对象有两个引用者我们可以认为每一个shared_ptr 都有一个关联的计数器，通常称其为引用计数。无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr 赋一个新值或者shared_ptr 被销毁时，他所关联的计数器就会递减。当指向一个对象的最后一个shared_ptr 被销毁时，shared_ptr 类就会自动销毁此对象。shared_ptr 并不是万能的，也会出现内存泄漏的问题。这种情况一般出现在容器中。如果在容器中存放了shared_ptr ，然后重新排列了容器，从而不需要某些元素。在这种情况下应该确保使用earse删除某些不再需要的shared_ptr 元素直接管理内存相对与智能指针直接使用new 和 delete很容器出错。当内存耗尽时，new会失败，会抛出一个bad_alloc 异常。我们可以改变使用new的方式来阻止它抛出异常int *p1 = new int; //如果分配失败则会抛出异常 int *p2 = new (nothrow) int; //如果分配失败，new返回一个空指针我们称这种形式的new为定位new。定位new允许我们传递额外的参数给到new，在此例子中我们传递一个标准库中的nothrow 对象，告知它在内存不足的时候不要抛出异常。如果这种形式的new不能分配所需内存，它会返回一个空指针动态对象的生命周期一直到它被手动释放为止。这样就给使用者造成了一个额外的负担，调用者必须记得释放内存。使用new和delete 管理动态内存存在三个常见问题：忘记delete内存。造成内存泄漏问题使用已经释放掉的对象。通过在释放内存后将指针置为空，有时可以检出这种错误同一块内存多次释放坚持只使用智能指针就可以避免所有这些问题。对于一块内存只有在没有任何智能指针指向它的情况下，智能指针才会自动释放它shared_ptr 和 new 结合使用接受指针参数的智能指针构造函数是 explicit 的。因此，我们不能将一个内置指针隐式转化为智能指针,必须使用直接初始化的方式shared_ptr<int> p1 = new int(1024); //错误，这里需要将int* 隐式转化为shared_ptr<int> 类型 shared_ptr<int> p2(new int(1024)); //正确默认情况下一个用来初始化智能指针的普通指针必须指向使用new创建的动态内存(malloc 创建的需要自定义释放操作),因为智能指针默认采用delete来释放它所关联的对象。我们可以将智能指针绑定到一个指向其他类型的资源的指针上面，但是为了这样做，必须提供自己的操作来代替delete不要混合使用普通指针和智能指针。void process(shared_ptr<int> ptr) { // 进入到函数中时，ptr 所在的引用计数加1 } //函数结束时, ptr 所在对象的引用计数减 1 shared_ptr<int> p(new int(42)); //引用计数为1 process(p); //在函数内部，引用计数加1，变为2 //执行完成后，引用计数减1，变为1，此时对象不会被销毁 *p = 100; //可以进行赋值，此时对象还未被销毁 int* p1 = new int(42); process(shared_ptr<int>(p1)); //进入函数后，由于p1 自身不是智能指针，所以在函数结束之后，智能指针的计数为0，会销毁对应的对象 *p1 = 100; //错误，此时对象已被销毁 智能指针定义了一个get函数用来返回一个普通的指针，此函数是为了这样一种情况而设计的：我们需要像不能使用智能指针的代码传递一个内置指针，但这段代码中不能使用delete来销毁这个指针所指向的对象我们不能将get返回的指针再绑定到另一个智能指针上。智能指针和异常当发生异常时，普通的指针如果在异常发生之后进行delete操作，那么资源回收操作可能会被中断，而智能指针不会void f() { shared_ptr<int> sp(new int(24)); //即使后面发生异常，sp指针在函数结束时计数变为0，对象被释放 } void f() { int* p = new int(24); //这里发生异常的话，后面的delete 不会被执行，可能发生内存泄漏 delete p; }有些资源由于提供的是c函数级别的接口，因此需要手动进行释放，就会存在与动态内存一样的问题，忘记释放资源。这种情况我们也可以使用智能指针的技术来自动管理资源。例如我们的socket程序，在最后需要调用shutdown 和 closesocket来关闭void clear_socket(socket* sk) { shutdown(*sk); closesocket(*sk); } socket s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); shared_ptr<socket> ps(&s, clear_socket); //链接服务器 //程序推出后会自动调用clear_socket 来释放socket资源智能指针可以提供对动态分配的内存安全而有方便的管理，但是这建立在正确使用的前提下。为了方便的使用智能指针，我们必须坚持一些基本原则：不使用相同的内置指针初始化多个智能指针不delete get函数返回的指针不使用get初始化或者reset另一个指针指针如果使用get返回的指针，记住当最后一个对应的智能指针被销毁后，你的指针就变为无效了如果使用智能指针管理的资源不是new分配的，记住传递给它一个删除器unique_ptrunique_ptr 拥有它所指向的对象。某一个时刻只能有一个 unique_ptr 指向一个给定的对象。当unique_ptr 被销毁时，它所指向的对象也会被销毁unique_ptr 不支持拷贝操作，没有类似 make_shared 的操作。unique_ptr<string> p1(new string("hello world")); unique_ptr<string> p2(p1); //错误：unique_ptr 不支持拷贝 unique_ptr<string> p3; p3 = p1; //错误：unique_ptr 不支持赋值虽然不能拷贝和赋值unique_ptr ,但是可以调用release或者reset将指针的所有权从一个(非const)unique_ptr 转移给另一个unique_ptrreset 成员接受一个可选的指针参数，令unique_ptr 重新指向给定的指针。如果unique_ptr 不为空，它原来指向的对象被释放。release会切断unique_ptr 和它原来管理的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或者给另一个智能指针赋值，如果我们不用另一个智能指针保存release返回的指针，则需要手工释放指针指向的资源p2.release(); //错误，p2指向的资源不会正常释放 auto p = p2.release(); delete p;不能拷贝unique_ptr 的规则又一个例外: 我们可以拷贝或者赋值一个将要被销毁的unique_ptr。最常见的例子是从函数返回一个unique_ptrunique_ptr<int> clone(int p){ return unique_ptr<int>(new int(p)); }还可以返回一个局部对象的拷贝:unique_ptr<int> clone(int p) { unique_ptr<int> ret(unique_ptr<int>(p)); return ret; }类似于shared_ptr， unique_ptr 默认情况下使用delete 释放它指向的对象。我们也可以重载一个unique_ptr 中默认的删除器。但是unique_ptr 管理删除器的方式与shared_ptr 不同。重载一个unique_ptr 中删除器会影响到unique_ptr 类型以及如何构造该类型的对象。与与重载关联容器的比较运算相似，我们必须在尖括号中unique_ptr 指向类型之后提供删除容器类型。在创建或者reset 一个这种unique_ptr 类型的对象时，必须提供一个指定类型的可调用对象weak_ptrweak_ptr 是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr 管理的对象。将一个shared_ptr绑定到一个 weak_ptr。不会改变shared_ptr 的引用计数。一旦最后一个指向对象的shared_ptr 被销毁，对象就会被释放。即使有weak_ptr 指向对象，对象还是会被销毁由于对象可能不存在，所以不能直接使用weak_ptr 来访问对象，需要先调用lock函数，此函数检查weak_ptr 指向的对象是否仍然存在。如果存在，lock返回一个指向共享对象的shared_ptr。只要此shared_ptr 存在，它所指向的对象也会一直存在.if(shared_ptr<int> np = wp.lock()) { //在if中np 和wp 共享对象 }动态数组new 和数组标准库提供了一个可以管理new 分配的数组的unique_ptr 版本，为了用一个unique_ptr 管理动态数组，我们必须在对象类型后面跟一对方括号:unique_ptr<int[]> up(new int[10]); up.release(); //自动用delete[] 销毁其指针shared_ptr 不直接支持管理动态数组。如果希望使用shared_ptr 管理动态数组，必须提供自己定义的删除器:shared_ptr<int> sp(new int[10], [](int* p){delete[] p;}); sp.reset();shared_ptr 未定义下标运算符，因此我们通过shared_ptr 访问动态数组时需要使用get获取到内置指针，然后用它来访问数组元素** allocator 类当分配一块大内存时，我们通常计划在这块内存上按需求构造对象，这种情况下使用new分配时会立即执行对象的构造操作，会造成一定的开销string *const p = new string[n]; //构造n个空白的string delete[] p;上述代码在new 的同时已经调用了n次string 的构造函数。但是我们可能不需要n个string对象，少量的即可满足。 这样我们就可能创建一些永远也用不到的对象。而且对于那些要使用的对象，我们也在初始化之后立即赋予了它们新值，每个被使用的元素被赋值了两次，第一次是在默认初始化的时候，第二次是在赋值时。标准库中定义了allocator 类可以帮助我们将内存分配和对象构造分离开来。allocator<string> alloc;//可以分配string的allocator对象 auto const p = alloc.allocate(n); //分配n个未初始化的stringallocator 分配的内存是未构造的。我们按照需要在此内存中构造对象。成员函数construct接受一个指向将要被构造的内存的指针，同时可以接受额外参数作为构造对象时的参数。auto q = p; //q 指向下一个将要被构造的位置 alloc.construct(q++); //构造一个空字符串 alloc.construct(q++, 10, 'c'); //构造一个'cccccccccc'的字符串 alloc.construct(q++, "hi"); //构造一个 "hi" 字符串当我们使用完对象后必须调用destroy 来销毁它们while(q != p) { alloc.destroy(--q); }这里要注意我们只能对真正构造了的元素进行destroy操作destroy之后这些内存并没有完全交换给系统，还需要调用deallocate 来完成alloc.deallocate();

关联容器 之前介绍过标准库中的顺序容器，顺序容器是元素在内存中按照一定顺序进行排列的，都是按线性结构进行排列。除了顺序容器外，c++中还有关联容器。与顺序容器不同的是，关联容器中元素是按照关键字来保存和访问的。与之相对的顺序容器是按它们在容器中的位置来顺序的保存和访问的。关联容器支持高效的查找和访问。两个主要的关联容器类型是map和set。标准库提供8种关联容器，这8个容器见的不同体现在3个维度或者是一个set，或者是一个map或者要求不重复的关键字，或者允许重复关键字按顺序保存元素或者无序保存允许重复关键字的容器都包含单词 multi ，不保持关键字按顺序存储的容器的名字都以单词unordered 开头这8中容器分别是 map、set、multimap、multiset、unordered_map、unordered_set、unordered_multimap、unordered_multiset关联容器概述关联容器不支持顺序容器中的位置相关操作，例如 push_back、push_front。原因是关联容器是按照关键字存储的，这些操作对关联容器没有意义对于map、multimap、set、multiset 关键字类型必须定义元素的比较方法。默认情况下标准库使用关键字类型的< 运算符来比较两个关键字在介绍关联容器的操作之前，我们需要了解名为pair的标准库类型。一个pair保存两个数据成员。类似容器，pair是一个用来生成特定类型的模板。当创建一个pair时，需要提供两个类型名，pair的数据成员将具有对应的类型。两个类型不要求一样pair<string, string> anon; pair<string, size_t> word_count; pair<string, vector<int>> line;初始化时，会调用类型的默认构造函数进行初始化，也可以为每个成员提供初始化器:pair<string, string> author{"James", "Joyce"};pair 的数据成员是public的，两个成员分别命名为first和second。我们用普通的成员访问符号来访问它们。关联容器的操作关联容器定义了额外的类型别名key_type: 此容器类型的关键字类型mapped_type: 每个关键字关联的类型：只适用与mapvalue_type: 对于set，与key_value 相同；对于map，为 pair<const key_type, mapped_type>set<string>::value_type v1; //v1 是一个string set<string>::key_value v2; //v2 是一个string map<string, int>::value_type v3; //v3 是一个pair<const string, int> map<string, int>::key_type v4; //v4 是一个string map<string, int>::mapped_type v5; //v5 是一个int我们使用作用域运算符来提取一个类型的成员。当解引用一个关联容器的迭代器的时候，会得到一个类型为容器的value_type 的值的引用。对map而言，value_type 是一个pair 类型，其first成员保存const的关键字，second成员保存值auto map_it = word_count.begin(); cout << map_it->first; cout << " " << map_it->second; map_it->first = "new key"; //错误 first是const类型 ++map_it->second;set 的迭代器是const的。关联容器中键值是无法通过迭代器进行修改的。只能通过迭代器读，每次修改键值都会导致容器中元素的重新排序。因此不允许通过迭代修改键值我们通常不能对关联容器使用泛型算法。关键字是const这一特性意味着不能将关联容器传递给修改或者重排容器元素的算法。关联容器可以使用只读取元素的算法。但是很多这类算法都要搜索序列。由于关联容器中的元素不能通过它们的关键字进行快速查找，因此对其使用泛型算法几乎总是一个坏主意关联容器中有一个find的成员，我们可以使用find算法来根据关键字查找元素。关联容器的insert成员可以向容器中添加一个元素或者元素范围。因为set和map无法包含关键字重复的元素，因此插入已存在的元素对容器没有任何影响vector<int> ivec = {2, 4, 6, 8, 2, 4, 6, 8}; //ivec 有8个元素 set<int> set2; set2.insert(ivec.cbegin(), ivec.cend()); //set2 现在有4个元素 set2.insert({1, 3, 5, 7, 1, 3, 5, 7}); //set2 现在有8个元素对一个map执行insert操作时，需要记住元素类型是pair。通常在insert的参数列表中创建一个pair//向word_count 插入word的4种方法 word_count.insert({word, 1}); word_count.insert(make_pair(word, 1)); word_count.insert(pair<string, size_t)>(word, 1)); word_count.insert(map<string, size_t>::value_type(word, 1));insert 的返回值依赖于容器类型和参数。对于不包含重复关键字的容器，添加单一元素的insert和emplace版本返回一个pair，告诉我们插入是否成功。pair的first成员是一个迭代器，指向具有给定关键字的元素；second成员是一个bool值，指出元素是插入成功还是已经存在于容器中。如果关键字已经存在于容器中，则insert什么也不做，且返回值中的bool部分为false。如果关键字不存在，元素被插入容器，且bool值为true对于允许重复关键字的容器，接受单个元素的insert操作返回一个指向新元素的迭代器。这里无须返回一个bool值，因为insert总是向这类容器中加入一个新元素关联容器定义了三个版本的erase。可以通过传入一个迭代器或者一个迭代器对来删除一个元素或者一个元素范围。如果指定的元素被删除，函数返回void关联容器提供一个额外的erase函数，它允许传入一个key_type 参数，删除所有匹配给定关键字的元素，返回实际删除元素的数量。对于map和unordered_map 容器提供了下标运算，下标中填入key_type的值，得到value_type，如果关键字不在map中，会为它创建一个元素并插入map中。使用容器的find访问关联容器，传入key_type，如果能找到对应值，返回一个指向对应元素的迭代器，否则返回一个指向容器end()位置的迭代器的使用容器的count方法，传入key_type，返回容器中相同关键字元素的个数对于map使用find代替下标操作，使用下标如果未找到对应关键字则会插入一个新的元素，这样会产生未知行为。如果我们只想知道一个给定关键字是否在map中，而不想改变map，这种情况下应该使用find。对于不允许存储重复关键字的关联容器来说，通过关键字查找元素只会找到一个，而对于允许重复关键字的关联容器来说，会返回第一个元素的迭代器，而相同关键字的元素会相邻存储。在遍历所有相同关键字的元素时，可以首先使用find找到第一个元素的迭代器，然后使用count找到公有多少个元素。最后循环递增迭代器即可访问到所有相同关键字的元素string search_item("Alain de Botton"); auto enteris = authors.count(search_item); auto iter = authors.find(search_item); while(enteris) { cout << iter->second << endl; ++iter; --enteris; }除了上述方法，还可以使用 lower_bound和 upper_bound；lower_bound 指向第一个对应的元素，upper_bound 指向匹配的最后一个元素的下一个位置。如果未找到对应元素，则二者指向同一个迭代器，指向一个不影响排序的关键字插入位置for(auto beg = authors.lower_bound(search_item), end = authors.upper_bound(search_item); beg != end; ++beg) { cout << beg->second << endl; }解决此问题的最后一个方法是直接使用容器的equal_range函数。该函数返回一个pair，保存的是两个迭代器。指向的位置与 lower_bound 和 upper_bound 相同解决此问题的最后一个方法是直接使用容器的equal_range函数。该函数返回一个pair，保存的是两个迭代器。指向的位置与 lower_bound 和 upper_bound 相同for(auto pos = authors.equal_range(search_item); pos.first != pos.end; ++pos.first) { cout << pos.first->second << endl; }无序容器新标准中定义了4种无序关联容器，这些容器不是使用比较运算符来组织元素，而是使用一个哈希函数和关键字类型的 == 运算符。在关键字类型的元素没有明显的序关系时，无序容器是非常有用的。对于自定义类型的关键字，无法直接在无序容器中使用，还需要提供该类型的hash操作。

泛型算法 好久没有更新博客了，最近一直想把我以前的老笔记本换成 Arch + dwm 的样式来使用。现在基本已经弄完了。后面会考虑将我的心得发出来。从0开始一点点的增加自己需要的功能确实很繁琐但是也挺有趣的。闲话就到这里，这篇文章继续记录我学习c++ 11的内容。这篇主要是泛型算法相关的内容标准容器自身提供的操作少之又少，在多数情况下可能希望对容器进行其他操作，例如排序、删除指定元素等等。标准库容器中并未针对每个容器都定义成员函数来实现这些操作，而是定义了一组泛型算法，它们实现了一组经典算法的公共接口，可以使用于不同类型的元素和多种容器类型。也就是相同一组算法可以处理多种容器类型概述之所以是泛型的，主要是这些通用算法不依赖于具体的容器类型，所有相同算法采用相同的接口迭代器的存在使得算法不依赖于具体的容器类型，但是算法依赖于元素类型的相关操作，例如我们可以简单的使用下面的代码来说明这个bool find(beg, end, val) { for(auto iter = beg; iter != end; ++iter) { if(*iter == val) { return true; } } return false }上述代码并不限定于只能使用某种类型的容器，只要容器中迭代器支持递增操作，并且元素本身支持比较运算即可。泛型算法本身不会执行容器的操作，它们只会运行于迭代器之上，执行迭代器的操作，最多也就只会修改迭代器所指向的元素的值。对容器自身没有影响。算法永远不会改变底层容器的大小。算法可能改变容器中保存的元素的值，也可能在容器中移动元素。但是永远不会直接添加或者删除元素（当然插入迭代器例外）初识泛型算法除了极少数例外，标准库算法都是对一个范围内的元素进行操作。我们将此元素范围称之为输入范围，接受输入范围的算法总是使用前两个参数来表示此范围。两个参数分别是指向要处理的第一个元素和尾元素之后位置的迭代器。理解基本算法的方法就是了解它们是否读取元素、改变元素或者重新排列元素顺序只读算法一些算法只会读取输入范围内的元素，而从不改变元素。find就是这样一个算法。一些常见的只读算法如下：find:查找容器中出现某个元素的位置，需要容器中元素类型实现 == 操作count: 返回容器中出现某个元素的次数，同样需要容器中元素类型实现 == 操作accumulate: 计算某个迭代器范围内，所有元素的和，需要容器中元素类型实现 + 操作equal: 比较两个序列中元素值是否完全相同，它接受三个参数，前两个表示一个容器的迭代器范围。最后一个参数代表第二个容器的起始位置一般来说对于只读取而不改变元素的算法，通常最好使用cbegin和cend 获取const版本的迭代器。那些只接受一个单一迭代器来表示第二个序列的算法，都假定第二个序列至少与第一个序列一样长。写容器元素的算法这类算法需要确保，容器原大小不能小于我们要求算法写入的元素数目。由于算法不会执行容器操作，因此它们自己不可能改变容器大小一种保证算法有足够元素空间来容纳输出数据的方式是使用插入迭代器，插入迭代器是一种向容器中添加元素的迭代器拷贝算法接受3个迭代器，前两个表示一个源容器的范围，第三个迭代器是目的容器的起始位置的迭代器。同样的源容器的长度不能超过目的容器的长度定制操作很多算法都会比较输入序列中的元素，默认情况下，这类算法使用元素类型的< 或者 == 运算符来完成比较操作。标准库还为这些算法定义了额外的版本，允许我们提供自已定义的操作来代替默认运算符。例如sort 算法默认使用元素类型的 < 运算符，但是可以使用sort的重载版本，额外定义比较的规则向算法传递参数标准库中可以接受的比较函数一般返回一个bool值，表示是否小于或者是否相等。函数接受一个参数或者两个参数。在c++新标准中将这个函数叫做谓词，接受一个参数的函数被成为一元谓词，接受两个参数的函数叫做二元谓词。vector<string> words; //初始化 words //...... bool isShorter(const string& s1, const string& s2) { return s1.size() < s2.size(); } sort(words.cbegin(), words.cend(), isShorter);lambda 表达式在介绍lambda 表达式之前，需要先介绍可调用对象这个概念可调用对象：对于一个对象或者一个表达式，如果可以对其使用调用运算符，则称它是可调用的；例如，e是一个可调用对象，则我们可以编写代码e(args) ，其中args是一个逗号分割的一个或者多个参数的列表到目前为止，我们只接触了函数和函数指针这两类可调用对象，还有其他两种可调用对象：重载了函数调用运算符的类，以及lambda表达式。一个lambda 表达式表示一个可调用的代码单元。我们可以将其理解为一个未命名的内联函数，定义形式如下capture list -> return type {function body}capture list 捕获列表，是一个lambda 所在函数中定义的局部变量的列表。parameter list 函数的参数列表return type 是函数返回值类型function body 是函数体，需要执行的具体代码段与普通函数不同的是 lambda 必须使用尾置返回来指定返回类型我们可以忽略参数列表和返回值,但是必须包含捕获列表和函数体auto f = [] {return 42;};如果lambda 表达式中没有明确指定返回类型，函数体中包含任何单一 return 语句之外的内容，则返回voidlambda 的调用方式和普通函数的调用方式一样，都是调用运算符cout << f() << endl;lambda 表达式不能有默认参数[] (const string& str1, const string& s2) { return s1.size() < s2.size(); }; vector<string> words; stable_sort(words.begin(), words.end(), [](const string& s1, const string& s2){ return s1.size() < s2.size(); });lambda 表达式一般出现在一个函数中，使用其局部变量，但是它只能访问那些明确指明的变量。一个lambda通过将局部变量包含在其捕获列表中来指明将会使用这些变量。捕获列表指引lambda 在其内部包含访问局部变量所需的信息[sz](const string& s){ return a.size() >= sz; }lambda 捕获和返回与参数传递类似，变量捕获的方式可以是值或者引用。void func1() { size_t v1= 42; auto f = [v1]{return v1;}; v1 = 0; auto j = f(); //j 是42， 因为在定义lambda的时候传入的是v1的拷贝，后续v1 的改变不影响捕获中v1 的值 }被捕获变量的值是在lambda创建时拷贝，因此随后对其修改不会影响到lambda内对应的值void func2() { size_t v1 = 42; auto f = [&v1](){return v1;}; v1 = 0; auto j = f(); //j 是0，f保存v1的引用，而非拷贝 }引用捕获与返回引用有着相同的限制，必须保证调用在调用lambda表达式时，是存在的。捕获的都是函数的局部变量，如果lambda 在函数结束之后执行，捕获的引用指向的局部变量已经消失。可以在函数中返回一个lambda表达式，此时返回的lambda 中不应该包含引用捕获使用引用捕获的时候需要注意，在一次或者多次调用lambda表达式的时候应该保证引用的对象仍然有效，同时需要保证对象的值是我们所期待的。因此在使用lambda的时候尽量减少捕获变量的数量，同时尽量不使用引用捕获除了显式列出我们希望使用的所来自所在函数的变量外，还可以让编译器根据lambda体中的代码来推断我们要使用哪些变量。为了指示编译器推断捕获列表，应在捕获列表中写一个&或者=，表示采用引用捕获或者值捕获我们也可以混合使用隐式捕获和显式捕获，混合使用时，捕获列表的第一个元素必须是一个&或者=。当混合使用了显式捕获和隐式捕获时。显式捕获的变量必须与使用隐式捕获不同的方式。当使用值捕获的时候，默认情况下lambda表达式是不能改变其值的，如果希望改变一个被捕获的变量的值，就必须在参数列表后加上关键字 mutablevoid f3() { size_t v1 = 42; auto f = [v1] ()mutable{return ++v1;}; v1 = 0; auto j = f(); // j = 43 }一个引用捕获的变量是否可以修改依赖于此引用指向的是一个const 类型还是一个非const类型void fnc4() { size_t v1 = 42; auto f2 = [&v1]{return ++v1;}; v1 = 0; auto j = f2(); //j = 1 }// 错误，由于有除return之外的其他语句，因此编译器推断lambda 表达式返回void，但是返回了具体值 transform(v1.begin(), v1.end(), vi.begin(), [](int i){ if(i < 0) return -i; else return i; }); //正确，只有return语句，编译器可以推断出返回int类型 transform(v1.begin(), v1.end(), vi.begin(), [](int i){ return (i < 0)? -i : i; }); //正确，明确指定了返回int类型 transform(v1.begin(), v1.end(), vi.begin(), [](int i)->int{ if(i < 0) return -i; else return i; });参数绑定lambda 表达式适用于只在一两个地方使用的简单操作，如果多个地方都需要使用到相同的操作，就需要写上相同的lambda表达式。这个时候最好的办法是定义一个函数。在需要进行捕获的情况下使用函数就不是那么容易了。例如有的泛型算法只传递一个参数，但是我们在函数中需要两个参数。这种情况下就需要用到参数绑定标准库中定义了一个bind函数。可以将bind作为一个函数适配器。它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表auto newCaller = bind(callable, arg_list);其中 callable 是一个可调用对象，返回的newCaller 是一个新的可调用对象，而arg_list 中的参数可能包含形如 _n 的名字，其中n是一个整数。这些参数是“占位符”。表示 newCaller 的参数。它们占据了传递给newCaller的参数位置。数值n表示生成的可调用对象中参数的位置。_1为newCaller的第一个参数，_2 为第二个参数。以此类推auto wc = find_if(words.begin(), words.end(), bind(check_size, _1, sz));此时调用生成一个可调用对象，将check_size 的第二个参数绑定到sz的值，当find_if 对words中的string调用这个对象的时候，这些对象会调用check_size 将给定的string 和 sz 传递给它，因此 find_if 可以有效的对输入序列中的每一个string调用check_size 实现string与 sz的比较_n 都定义在一个名为 placeholders 的命名空间中，而这个命名空间本身定义在std命名空间中。每次在使用_n 这样的名字时，都需要声明这个命名空间。using std::placeholders::_1; using std::placeholders::_2;每个占位符都必须提供单独的using声明，这样比较麻烦。可以使用另一种不同形式的 using 语句using namespace std::placeholders;我们可以使用bind 给可调用对象中参数重新排序，例如f是一个可调用对象，它有5个参数auto g = bind(f, a, b, _2, c, _1);生成的新的可调用对象g接受两个参数，分别是 _2, _1。在调用g时相当于void g(_1, _2) { f(a, b, _2, c, _1); }当我们执行 g(x, y) 最终会执行 f(a, b, y, c, x)在执行时会将 bind 中传入的参数拷贝到原来的函数参数中，如果想向原函数传递引用，可以使用标准库中的 ref函数auto g = bind(f, ref(a), b, _2, c, _1)上述代码中，在执行g的时候会向f中拷贝a的引用。_1, _2 本身在传值的时候可以传入引用再谈迭代器除了之前介绍的迭代器，标准库还定义了几种额外的迭代器：插入迭代器：这些迭代器被绑定到一个容器上，可以用来向容器插入元素流迭代器：这些迭代器绑定到流中，可以用来遍历所有关联的IO流反向迭代器：这些迭代器向后而不是向前移动，除了 forward_list 之外的标准库容器都有迭代器移动迭代器：这些专用迭代器不是拷贝其中的元素，而是移动它们。插入迭代器插入迭代器是一种迭代器适配器，它接受一个容器，生成一个迭代器，能实现向给定容器添加元素。插入迭代器有三种类型，差异在于元素插入的位置:back_iterator: 创建一个使用push_back 的迭代器front_iterator: 创建一个使用push_front 的迭代器inserter: 创建一个使用insert 的迭代器iostream 迭代器虽然iostream并不是容器，但是标准库定义了可以用于这些IO类型对象的迭代器。istream_iterator 读取输入流，ostream_iterator 向一个输出流写数据。这些迭代器将它们对应的流当作一个特定类型的元素序列来处理。通过使用流迭代器，我们可以使用泛型算法从流对象读取数据以及向其写入数据。istream_iterator<int> in(cin), eof; accumulate(in, eof, 0); // 从标准输入中读取整数，并计算它们的和 ostream_iterator<int> out(cout); copy(vec.begin(), vec.end(), out); //将vector中的数据拷贝到ostream流中，也就是输出vector 中的元素istream_iterator 允许使用懒惰求值，即只在需要时进行数据读取泛型算法结构任何算法最基本的特性是它要求其迭代器提供哪些操作。算法要求的迭代器操作可以分为5个迭代器类型：输入迭代器：只读不写；单遍扫描，只能递增输出迭代器：只写不读；单遍扫描，只能递增前向迭代器：可读写，多遍扫描，只能递增双向迭代器：可读写，多遍扫描，可递增递减随机访问迭代器：可读写，多变扫描，支持全部迭代器运算5 类迭代器类似容器，迭代器也定义了一组公共操作。一些操作所有迭代器都支持，另外一些只有特定类别的迭代器才支持。输入迭代器可以读取序列中的元素。一个输入迭代器必须支持：用于比较两个迭代器的相等和不想等运算符用于推进迭代器的前置和后置递增运算符用于读取元素的解引用运算符，解引用只会出现在赋值运算符的右侧箭头运算符输出迭代器可以看作是输入迭代器功能上的补集，只写而不读元素，输出迭代器必须支持用于推进迭代器的前置和后置递增运算解引用运算符，只出现在赋值运算符的左侧前向迭代器可以读写元素，这类迭代器只能在序列中沿一个方向移动。前向迭代器支持所有输入和输出迭代器的操作。双向迭代器可以正向/反向读写序列中的元素。除了支持所有前向迭代器的操作之外，双向迭代器还支持前置和后置的递减运算符。随机访问迭代器提供在常量时间内访问序列中任意元素的能力。除了支持双向迭代器的所有功能外，还支持：用于比较两个迭代器相对位置关系的运算符 (<、<=、>和>=)迭代器和一个整数值的加减运算(+、+=、-、-=)，计算结果是迭代器在序列中前进或者后退给定整数个元素后的位置用于两个迭代器上的减法运算符，得到两个迭代器的距离下标运算符 iter[n] 与 *(iter[n]) 等价算法形参模式大多数算法具有如下4种形式之一：alg(beg, end, other, args)alg(beg, end, dest, other, args)alg(beg, end, beg2, other, args)alg(beg, end, beg2, end2, other, args)其中alg 是算法名字，beg和 end表示算法所操作的输入范围，几乎所有算法都接受一个输入范围。是否有其他参数依赖于要执行的操作。dest参数表示算法可以写入的目的位置的迭代器。算法假定按其需要写入数据，不管写入多少个元素都是安全的。如果dest是一个直接指向容器的迭代器，那么算法将输出数据写到容器中已经存在的元素内。更常见的情况是，dest被绑定到一个插入迭代器或者是一个ostream_iterator。接受单独的beg2 或者 beg2和end2的算法用这些迭代器表示第二个输入范围，这些算法通常使用第二个范围中的元素与第一个输入范围结合来进行一些运算算法命名规范除了参数规范，算法还遵循一套命名和重载。这些规则处理诸如：如何提供一个操作代替默认的 < 或者 == 运算以及算法是将输出数据写入到一个序列还是一个分离的目的位置等问题接受谓词参数来代替 < 或者== 运算符的算法，以及那些不接受额外参数的算法，通常都是重载的函数。一个版本用元素自身的运算符来比较元素，另一版本接受一个额外的谓词参数来代替 <或者==unique(beg, end); unique(beg, end, comp); //使用comp函数比较元素接受一个元素值的算法通常有另一个不同名版本，该版本接受一个谓词，代替元素值，接受谓词参数的算法都有附加的_if 后缀find(beg, end, val); find_if(beg, end, pred); //pred 是一个函数，查找第一个令pred返回真的元素默认情况下，重排元素的算法将重排后的元素写回给指定的输入序列。这些算法还提供了另一个版本，将元素写到一个指定的输出目的位置。这类算法都在名字后加一个_copyreverse(beg,end); reverse(beg,end,dest); //将元素按逆序拷贝到dest一些算法还提供_copy和_if 版本，这些版本接受一个目的位置迭代器和一个谓词remove_if(v1.beg(), v1.end(), [](int i){return i % 2}); remove_if(v1.beg(), v1.end(), back_inserter(v2), [](int i){return i % 2});特定容器算法与其他容器不同，链表定义了几个成语啊函数形式的算法。，它们定义了独有的sort、merge、remove、reverse和unique。这些链表中定义的算法的性能比通用版本要高的多。与通用版本中的不同，链表中的特有操作会改变容器。

顺序容器 所有容器类都共享公共的接口，不同容器按不同的方式进行扩展，这个公共接口使得学习容器更加容器。我们基于这种容器所学习的内容也都适用于其他容器。每种容器都提供了不同的性能和功能权衡一个容器就是一些特定类型对象的集合。顺序容器为程序员提供了控制元素存储顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器的位置相对应。顺序容器概述所谓的顺序容器是指，在内存中数据存储有一定顺序。数据结构中的顺序容器有：可变数组、队列、数组、链表、栈。c++ 标准库中的顺序容器提供了快速顺序访问元素的能力。但是这些容器在一下方面都有不同的性能折中向容器中添加或者删除元素的代价非顺序访问容器中元素的代价标准库中顺序容器主要有：vector：可变大小的数组。支持快速随机访问，在尾部之外插入或者删除元素可能会很慢dque：双端队列，支持快速随机访问，在头尾位置插入/删除元素速度很快list：双向连标，只支持双向顺序访问，在list中任何位置进行插入删除操作速度都很快forward_list: 单向链表，只支持单向顺序访问，在链表任何位置插入删除元素速度很快array: 固定大小的数组，支持快速随机访问，不能添加或者删除元素string: 与vector容器类似，但专门用于保存字符，随机访问快。在尾部插入与删除速度快c++ 标准库中的容器是经过精心优化设计过的。性能通常会是同类数据结构中最好的。现代c++ 程序应该使用标准库容器，而不是原始的数据结构（如内置数组）通常使用vector 是最好的选择，除非你有很好的理由选择其他容器一下是一些选择容器的基本原则:除非你有很好的理由选择其他容器，否则使用vector如果你的程序有很多小的元素，且额外开销很严重，否则不要使用list或者forward_list如果程序要求随机访问元素，应该使用vector 或者deque如果程序要求在容器中间插入或者删除元素，应该使用list或者forward_list如果程序要在头尾位置插入或者删除元素，但是不会在中间位置插入删除元素，则应该使用deque如果程序只有在读取输入时才需要在容器中间插入元素，随后需要随机访问元素，则： 6.1 首先确定是否真的需要在容器中间位置添加元素。当处理输入数据时通常很容易向vector中添加数据，然后再调用标准库的sort函数，来重排元素，避免在中间位置添加元素 6.2 如果必须在中间位置插入元素考虑在输入阶段使用list，一旦输入完成，将list中的内容拷贝到一个vector中如果你不确定该使用哪种容器，可以在程序中只使用vector 和list公共的操作，不使用下标操作，使用迭代器，避免随机访问容器库概述迭代器迭代器是访问容器中元素的公共接口所有迭代器都通过解引用运算符来实现这个操作。标准库中的所有迭代器都定义了递增运算符，从当前元素移动到下一个元素。部分容器的迭代器也定义了递减运算符，用于从一个元素移动到上一个元素一个迭代器范围是由一对迭代器来表示的。两个迭代器分别指向同一个容器的元素或者尾元素之后的位置。如果两个迭代器满足以下两个条件，则这两个迭代器构成一个迭代器范围：它们指向同一个容器中的元素，或者是容器最后一个元素之后的位置我们可以通过反复递增begin 来到达end位置，换句话说，end不在begin之前如果两个迭代器构成一个迭代器范围，则：如果begin和end相等，则范围为空如果begin和end不等，则范围至少包含一个元素，且begin指向该范围中的第一个元素我们可以对begin递增若干次，使得begin== end容器类型成员每个容器都定义了多个类型，我们已经使用了其中的3种：size_type、iterator、const_iterator除了正向的迭代器，容器库还提供了反向遍历容器的迭代器，反向迭代器就是一种反向遍历容器的迭代器。与正向迭代器相比各种操作的含义也都发生了颠倒。例如对一个反向迭代器执行++操作，会得到上一个元素。剩下的就是类型别名了。通过类型别名，我们可以在不了解容器中元素类型的情况下使用它，如果需要元素类型可以使用容器的value_type ，如果需要元素类型的一个引用可以使用reference或者const_reference。begin 和 end 成员begin 和 end 操作生成一个指向容器中第一个元素和尾元素之后位置的迭代器范围。begin和end有多个版本。带r的版本返回反向迭代器，带c的版本返回const型迭代器容器定义和初始化可以将一个容器初始化为另一个容器的拷贝将一个新容器创建为另一个容器的拷贝的方法有两种：可以直接拷贝整个容器，或者拷贝由一个迭代器对指定的元素范围为了创建一个容器为另一个容器的拷贝，两个容器的类型及其元素类型必须匹配。当传递迭代器参数来拷贝一个范围时，就不要求容器类型是相同的了。而且新容器和原容器中的元素类型也可以不同，只要能将拷贝的元素转化为要初始化的容器的元素类型即可在新标准中我们对一个容器进行列表初始化标准库array在定义之处就应该给出具体的大小，而且后续不允许修改它的大小我们不能直接对内置数组执行拷贝或者对象赋值操作，但是array对象允许赋值和swap我们直接使用 = 运算符来将一个容器赋值为另一个容器的拷贝，但是要求容器类型完全相同，array也支持这种操作顺序容器(array除外)还定义了一个assign的成员，assign操作用参数所指定的元素替换左边容器中的所有元素list<string> name; vector<const char*> oldstyle; name = oldstyle; //错误 = 要求两侧容器类型完全相同 name.assign(oldstyle);可以使用swap交换两个容器中的内容，要求两个容器类型完全相同。除了array外，swap不对任何元素进行拷贝、删除或者插入操作，可以保证在常量时间内完成容器大小操作每个容器都有三大与大小相关的操作。size: 返回容器中元素数目empty: 当容器中元素数量为0时，返回true，否则返回falsemax_size: 返回一个大于或者等于该类型容器所能容纳的最大元素数的值关系运算符除了无序容器外的所有容器都支持关系运算符关系运算符左右两边的运算对象必须是相同类型的容器，且必须保存相同类型的元素比较的过程与比较string大小的过程类似如果两个容器具有相同大小且所有元素都两辆对应相等，则两个容器相等。否则两个容器不等如果两个容器大小不同，但较小容器中每个元素都等于较大容器中对应元素。则较小容器大于较大容器如果两个容器都不是另一个容器的前缀自序列，则它们的比较结果取决于第一个不相等的元素的比较结果容器的相等运算符实际上是使用元素的==运算符实现比较的。而其他关系是使用元素的< 运算符顺序容器的操作向顺序容器中添加元素push_back：将内容追加到容器尾部push_front: 将内容添加到容器的首部insert: 在容器的特定位置插入0个或者多个元素,返回插入元素位置的迭代器emplace_back、emplace_front、emplace: 这些函数是直接在容器内部进行元素构造，而上述函数是将内容进行拷贝。从效率上讲emplace 函数会高一些使用这些操作时必须记得不同类型的容器使用不同的元素分配策略，而这些策略直接影响性能。访问顺序容器每个顺序容器中都有一个front 函数，返回容器内第一个元素的引用。而除了forward_list 之外的所有顺序容器都有一个back成员函数。另外可以使用at来访问随机位置的元素记住，这些访问函数返回的都是引用删除元素pop_front: 删除首元素pop_back: 删除尾元素erase: 可以从容器中删除指定位置的元素,可以传入一个范围，删除指定范围内的元素特殊的 forward_list 操作在对forward_list 进行增删操作的时候，需要找到对应位置的前驱节点，而单向链表无法很容器的找到一个节点的前驱节点。因此对单向链表，提供了类似 insert_after、emplace_after、erase_after等操作改变容器大小可以使用resize 来增大或者缩小容器大小,如果是缩小容器大小，则指向被删除元素的迭代器、引用、指针都会失效容器操作可能使迭代器失效在向容器中添加元素后：如果容器是vector或者string，且存储空间被重新分配，则指向容器的迭代器、指针都会失效。如果存储空间未重新分配，指向插入位置之前的迭代器、指针、引用仍然有效，但是指向插入位置之后元素的迭代器、指针和引用将会失效对于deque，插入到首尾位置之外的任何位置都会导致迭代器、指针和引用失效。如果在首尾位置添加元素，迭代器会失效，但指向存在的元素的引用和指针不会失效对于list和forward_list，指向容器的迭代器、指针和引用仍然有效删除一个元素后，指向原来被删除元素的迭代器、指针和引用都会失效。对于forward_list 和list来说，指向容器其他位置的迭代器、引用和指针仍然有效对于deque，如果在首尾之外的任何位置删除元素，那么指向被删除元素以外的其他元素的迭代器、引用和指针也会失效。如果是删除deque的尾元素，则尾后迭代器也会失效。但是其他迭代器、引用和指针不受影响，如果删除首元素，这些也不会受到影响对于vector和string，指向被删除元素之前元素的迭代器、引用和指针仍然有效删除元素时尾后迭代器总是会失效使用insert插入元素后可以保存返回的迭代器，然后用该迭代器进行迭代可以保证迭代器有效不要保存end返回的迭代器vector 容器是如何增长的为了支持快速随机访问，vector 将元素连续存储。如果往容器中添加一个新元素时，发现容器空间已经不够了，就需要重新分配空间。并将已有元素逐一拷贝到新的内存空间中，然后添加新元素。为了避免这种代价，标准库实现者采用了可以减少容器空间重新分配次数的策略。当不得不获取新的内存空间时，vector和string的实现通常会分配比新的空间需求更大的内存空间vector和string也提供了一些成员函数，允许我们与它的实现中内存分配部分互动。capacity: 告诉我们容器在不扩张内存空间的情况下可以容纳多少个元素reserve: 允许我们同志容器它应该准备保存多少个元素一般来讲，vector 的实现采用的策略似乎是在每次需要分配新内容空间时将当前容量翻倍额外的string操作除了顺序容器共同的操作之外，string类还提供了一些额外的操作。这些操作中的大部分要么是提供string类和C风格字符串之间的互相转换，要么是增加了允许我们用下标代替迭代器的版本。substr: 返回一个string，它是原始string的一部分或者全部的拷贝可以使用insert、erase、assign 来改变字符串的内容append可以在字符串尾部添加一个新字符串; replace 进行查找替换搜索操作标准库中提供了6个不同的搜索函数，每个函数有4中不同形式的重载版本。每个搜索操作都返回string::size_type 值，表示匹配发生位置的下标。如果搜索失败返回一个名为string::npos 的static成员s.find(arg): 查找字符串中第一次出现某个字符串的位置s.rfind(arg): 查找字符串中最后一次出现某个字符串的位置s.find_first_of(arg): 在s中查找arg中任意一个字符第一次出现的位置s.find_last_of(arg): 在s中查找arg中任意一个字符最后一次出现的位置s.find_first_not_of(arg): 在s中查找第一个不在arg 中的字符s.find_last_not_of(arg): 在s中查找最后一个不在arg 中的字符compare 函数compare函数用于比较两个大小字符串，与C标准库中的strcmp类似数值转化to_string: 将数值数据转化为字符串stod: 将字符串转化为doublestof: 将字符串转化为floatstoi: 将字符串转化为intstol: 将字符串转化为longstoul: 将字符串转化为 unsigned longstoll: 将字符串转化为 long longstoull: 将字符串转化为 unsigned long longstold: 将字符串转化为 long double容器适配器适配器是标准库提供的一组概念，能使某种事物的行为看起来像另一种事物一样。一个容器适配器接受一种已有的容器类型，使其行为看起来像另一种事物一样标准库提供了三种适配器: stack、queue、priority_queue(优先级队列)所有的适配器都要求容器具有添加和删除元素的能力。stack 只要求类型容器具有 push_back、pop_back 操作因此可以使用除了array 和 forward_list 之外的任何容器类型来进行构造queue 要求容器类型具有 back、push_back、front、pop_back 因此它可以构造在list 或者deque之上但不能基于vector 构造; priority_queue 要求容器类型具有push_back、front、pop_back之外还要求容器具有随机访问的能力，所以它必须构造在vector之上

IO库 c++ 语言中不直接处理输入和输出，而是通过一族定义在标准库中的类型来处理IO，这些类型支持从设备读取数据、向设备写入数据的IO操作。设备可以是文件、控制台窗口等。还有一些IO运行内存IO，即可以从string中读写数据。IO库IO类最开始接触的c++ 中的io是我们从控制台接受输入的istream和输出到控制台中的ostream。除了基本的istream和ostream以外标准库中还定义了如下的基本类型iostream 用于读写流的基本类型istream、wistream: 从流读取数据ostream、wostream: 向流写入数据iostream、wiostream：从流中读写数据fstream 定义了读写命名文件的类型ifstream、wifstream: 从文件中读写数据ofstream、wofstream: 向文件中写入数据fstream、wfstream: 读写文件sstream 定义了读写内存string对象的类型istringstream、iwstringstream: 从string中读取数据ostringstream、owstringstream: 向string中写入数据stringstream、wstringstream: 读写string其中带w的都是款字节版本无法对io对象进行拷贝或者赋值、因此在函数中无法返回IO类型也无法传递IO类型，只能使用IO类型的引用读写一个IO对象会改变其状态，所以在函数中传递和返回IO的对象不能是const的一个流如果发生错误，其上后续的IO操作都会失败。只有当一个IO流处于无错误状态时，我们才能从它读取数据。因此代码通常应该在使用一个流之前检查它是否处于良好状态，确定一个流对象的状态最简单的方式是将它作为一个条件来使用。作为条件使用只能告诉我们流是否有效，而无法告诉我们具体发生了什么。IO库定义了一组与机器无关的iostate类型，这个类型中使用二进制位来表示每种状态。目前定义了4种错误类型：badbit: 流崩溃failbit: IO操作失败eofbit: 流到达了文件结束位置goodbit: 流未处于错误状态在实际使用时可以将具体值与这些预定义的值做位与运算，得到具体的原因流对象的rstate 成员返回当前流的状态，setstate用来设置流状态。clear不带参用来清理所有错误标志位。clear的带参版本接受一个iostate值，表示流的新状态io操作比较耗时，所以操作系统为了效率会提供缓冲机制。输入输出并不是立即执行的，操作系统提供了一个缓冲区，在适当的实际会使用缓冲区的数据，统一执行输入输出操作。导致刷新的原因有很多：程序正常结束，在main函数执行return时，会进行刷新操作缓冲区满时，会进行换新操作程序中使用操作符例如endl来显式的刷新缓冲区输出操作结束后，使用操作符unitbuf 设置流的内部状态来清空缓冲区，默认情况下cerr 是设置了unitbuf 的，因此cerr的内容都是实时刷新的一个输出流被关联到另一个输出流。当读写被关联到另一个流时，关联到的流的缓冲区会被刷新除了使用endl、flush、ends 都可以来刷新缓冲区。endl在刷新的同时会插入换行符，flush则不添加任何字符，ends会添加一个空字符如果想在每次输出后都刷新缓冲区，可以使用unitbuf 操作符，它告诉流，每次执行写操作之后都进行一个flush操作cout << unitbuf; cout << nounitbuf;如果程序崩溃，缓冲区是不会被刷新的标准库是将cin和cout关联到一起了，所以每次执行cin都会导致cout的缓冲区被刷新可以使用tie 方法将自身关联到另一个流上。tie 带参数的版本，需要传入一个指向ostream 的指针，将自己关联到这个ostream中tie 不带参数的版本用来查询自身关联到了哪个输出流上，返回对应输出流的指针，如果未被关联，则返回空指针每个输入流最多只能关联到一个输出流，但是多个输入流可以关联到同一个ostream文件IO当我们要读写一个文件时可以使用文件流对象ifstream in(ifile); //传入文件名，构造一个ifstream 并打开文件 ofstream out; //定义一个文件输出流，这个流不关联到任何文件当我们定义了空的文件流对象后可以使用open函数将对象和文件关联起来。可以手动调用close函数关闭文件。也可以在fstream对象被销毁时由它的构造函数自动调用close每个流都有一个关联的文件模式，用来指出该如何使用文件in: 以读的方式打开out: 以写的方式打开app: 每次写操作前均定位到文件尾部ate: 每次打开文件后立即定位到文件尾部trunc: 截断文件binary：以二进制的形式打开文件string 流当我们的某些工作是对文本进行处理，而其他一些工作是处理行内的单词时通常可以使用 istringstream 即要在一行字符串中取出单个单词时可以使用字符串流

类 最近好像很久没有更新过关于c++ primer 的读书笔记了，一来自己最近遇到了烦心事，中断了一段时间的读书。第二个是因为我有点想写点随笔之类的东西了，中间更新了两篇随笔《关于读书》、《我的五年计划》。第三个是因为关于类这部分的内容确实有点多了，要读完也需要花费一定时间。因此更新就慢了起来。我发现我已经忘记了如何给这类文章取名字了，还是看着以前的项目想起来的。既然我定下来了未来5年的发展计划，那么从现在开始就应该坚持下来了。定义抽象数据类型这里定义抽象数据类型就是定义一个类，只要学过c++的对定义一个类并并不陌生，这里就不再详细的说明该如何定义一个类了。这部分主要需要注意：1类的const成员函数：一般类的成员函数会隐式的传入当前对象的地址即 ClassExample::func(ClassExample* this);const型的成员函数传入的是一个const型的this指针，ClassExample::func(const ClassExample* this); 从这个角度上说不允许在常函数里面修改对象的值。同时由于const类型无法自动转化为非const类型，所以const型对象只能调用const成员函数。类的作用域：类本身就是一个作用域，类中的所有成员定义在类这个作用域中。编译器在编译类的时候分两步，首先编译成员的声明，然后编译成员函数，因此在成员函数中可以随意使用类的其他成员而不用关心这些成员出现的顺序。如果一个函数在概念上属于这个类，但是不定义为类的成员函数，一般将这个类定义在类声明的头文件中访问控制与封装一般来说定义类的时候应该将类中的数据成员定义为私有或者保护类型，通过成员函数来访问类的数据成员，这样有两个好处：当我们发现数据成员的值不正常的时候，由于类外部是无法访问到数据成员的，所以在调试时只用关注改变了该数据成员的函数即可使用者在使用时只需要关注类提供的功能，不需要知道它里面具体的实现。只用调用类方法就好了，不用关注该如何设置数据成员到此为止，书中提到了两种访问权限，public和private：public: 后定义的成员可以在整个程序内被访问private: 后定义的成员只能在类的成员函数中被访问每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者达到类的结尾为止使用class或者struct关键字定义的唯一区别是默认的访问控制符，class默认是private、而struct默认的是public友元在某些时候，可能必须要在类外部使用类的私有成员，这个时候可以将对应的函数或者类声明为类的友元函数或者友元类，友元函数或者友元类可以随意使用类的私有成员。如果类想把一个函数作为它的友元，只需要增加一条以friend 关键字开始的函数声明语句即可友元声明只能出现在类内部，但是在类内出现的具体位置不限，友元不是类的成员也不受它所在区域访问控制级别的约束。需要注意在设计时尽量考虑清楚是不是一定要用到友元，毕竟友元已经在一定程度上破坏了类的封装性类的其他特性除了一些基本的使用和访问权限控制外，书中还提到了类的其他特性：在类中，常有一些规模较小的函数合适于被声明成内联函数。定义在类内部的成员是自动inline的，当然也可以显式的声明为inline函数，这样就可以在类外部定义我们可以仅仅只声明而暂时不定义它，这种声明有时候被称作前向声明。这个类在声明之后，定义之前是一个不完全类型。不完全类型可以用于定义该类型的指针或者引用，也可以声明以该类型作为参数或者返回该类型的函数。对一个类来说，在创建它的对象之前必须被定义。因为编译器在创建对象的时候必须知道类对象占多少存储空间如果一个类指定了友元类，那么这个友元类的成员函数可以访问此类包括非公有成员在内的所有成员友元关系不具备传递性，每个类单独控制自己的友元类或者友元函数除了令整个类作为友元之外，还可以只为某个成员函数单独提供访问权限。当把成员函数声明为友元的时候，我们必须明确指出该成员属于哪个类如果一个类想把一组重载函数声明为友元，它需要对这组函数中的每一个分别声明类的作用域一个类就是一个作用域，在类的外部类成员都被隐藏起来了。在c++ 中，内层作用域中的同名成员会覆盖外层，当函数内部或者类内部定义了与全局作用域相同的变量时，要使用全局作用域中的变量可以使用::类构造函数相关在构造函数中初始化列表相当于先定义再赋值，而要做到对成员变量定义的同时初始化，可以使用初始值列表的形式在某些场合下初始值列表必不可少：初始化const成员或者引用成员构造函数初始值列表只说明用于初始化成员的值，而不限定初始化的具体执行顺序成员的初始化顺序与他们在类中定义的顺序一致。构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序最好令构造函数初始值的顺序与成员声明的顺序保持一致。而且如果可能的话，尽量避免使用某些成员初始化其他成员类的静态成员类的静态数据成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据。类似的类的静态函数成员也不与任何对象绑定在一起。它们不包含this指针，静态函数成员不能被声明成const类型，也不能在静态函数成员中调用非类的静态成员不能在类的内部初始化类的静态成员，static关键字只能出现在类内部声明语句中，定义的时候不能加static关键字针对constexpr类型的static成员，可以在类内定义类内初始值由于静态数据成员不与类绑定，所以在计算类大小的时候可以不用考虑静态成员。这样就可以在类内定义该类型的静态数据成员，而非静态数据成员只能定义为该类型的指针或者引用+BEGIN_SRC c++class Menu{private:static Menu me1; Menu* me2; Menu& me3;};+END_SRC另外我们可是用静态成员做成员函数的默认实参

c++基础之函数 距离上次更新又过了一周，又该更新新的读书笔记了。本次更新的主要是c++中函数部分的内容c++ 中的函数与c语言中的函数大致用法或者语法是一样的，这里就不就这点详细展开了。需要注意的是c/c++中并没有规定函数中参数的求值顺序，所以在调用函数时需要特别注意，在传递实参的同时不要修改实参的值，也就是不要写类似func(i, ++i)这样的语句局部对象高级语言中，名字只是用来访问对象所在内存的一个工具，一个对象可以分为对象名和它实际所占的内存空间。这个对象名有它的作用域，对象所在内存有自己的声明周期。这二者不是一个概念，不要弄混淆了。变量的作用域一般只在它所定义的语句块中起作用。但是变量本身根据定义位置不同，生命周期也不同，例如int func() { for(int i = 0; i < 10; i++); }上述代码中i这个名称仅仅在for循环中有效，而i所指代的变量，它会一直持续到函数结束(可以参考鄙人曾经写过的关于c++反汇编分析相关的内容)根据定义位置的不同，变量分为局部变量和全局变量；局部变量，或者在书中有一个新的名字叫自动对象，对于局部变量来说，当代码执行到变量定义语句时创建该对象，当到达定义所在语句块的末端时销毁它，只存在于块执行期间的对象称作自动对象全局变量：定义在函数外部的变量称之为全局变量，全局变量的生命周期从程序启动时创建到程序结束时销毁。除了这两类以外，还有在函数中使用static关键字定义的局部静态变量，局部静态变量在程序第一次经过对象定义语句时初始化，并且直到程序终止时才会销毁。在此期间即使对象所在的函数结束执行也不会对它有影响。它与全局变量的生命周期相同，只是它的变量名被限定在了函数内部(关于什么时候为它分配内存，什么时候销毁的详细内容，也可以参考鄙人曾今写过的关于static的汇编分析)参数传递参数传递主要有值传递、指针传递和引用传递值传递：将实参的值拷贝到形参，然后执行函数，函数中对形参的改变不影响函数外的实参指针传递：指针值本身也是一个拷贝，在函数中可以通过对指针进行解引用操作来间接的改变函数外的实参引用传递：引用本身是对象的别名，可以在函数中通过对引用的修改，来修改函数外实参的值（其实本质上也是通过指针来进行修改）根据这几种传参方式，我们总结出来这样几点：需要改变实参的值，只能传递指针或者引用由于存在值拷贝，所以在传递大的结构体的时候尽量传递结构体的指针或者引用，如果不想修改结构体的值，可以将形参定义为const型函数通过return语句只能返回一个值，如果要返回多个值，可以使用指针或者引用。return 语句本身会进行拷贝，并且在赋值给外部变量时也会进行拷贝，尽量返回4或者8个字节的结构，对于大的结构体尽量使用引用来返回当形参有顶层const时，传给它常量对象或者非常量对象都是可以的。int func(const int i); int func(int i);由于顶层const被自动忽略，所以在上面代码会报错，两个函数的名称、形参列表实际上是相同的。数组形参除了上述这样常规的参数传递，函数中也可以传递数组，这个时候数组会自动退化为指针，例如面试或者笔试题中，经常会问到的一个问题size_t size_arr(int[10] i) { return sizeof(i); }这个时候，如果传递数组的首地址，在函数中会退化为指针，所以实际计算的是int*指针所占的内存。根据平台的不同，指针大小为4字节(32位版本)或者8字节(64位版本)如果想要真正的传递数组，可以使用引用的方式size_t size_arr(int (&arr)[10]) { return sizeof(arr); }此时arr表示有10个int型数据的数组的引用，最终得到的结果应该是 sizeof(int) * 10由于传递数组名时，数组名会退化为指针，所以如果只传递数组名，则在函数中无法确定数组的大小，为了解决这个问题，一般有3种方案：使用特殊标记，表示数组的结尾，一般字符串会这么干传递两个指针，表示数组的首地址和尾部地址，可以使用标准库中的begin 和 end 函数分别获取数组的首地址与尾地址显式传递一个表示数组元素个数的形参。这种情况一般使用下标运算，当下标达到这个指定值时退出循环当我们传递的是多维数组时，按照两个思路进行分析，多维数组其实是数组的数组，传递数组名实质上是数组的首元素地址。根据这两个原则进行分析，在传递多维数组时，后面的维度是数组元素类型，不能省略。而真正传递的是第一个该类型元素的地址。void print(int (*matrix)[10]); void print(int matrix[][10], int rowSize); //等价定义上述定义中，数组的第一维被忽略掉，第二维是10个整数的数组。上面的两个定义其实是等价的可变形参与以往使用 ... 来表示可变形参不同的是，在c++ 中新增了一个名为initializer_list 的标准库类型，这个类型只能处理所有实参类型相同的情况，对于实参类型不同的情况，可以使用可变参函数模板。initializer_list 本身是一个类似与list的结构，但是与list不同的是，initializer_list中的对象永远是常量，无法修改该容器中的值，换一个角度来说，也就无法修改实参的值了。void error_msg(initializer_list<string> il) { for(auto beg = il.begin(); beg != il.end(); ++beg) { cout << *beg << " "; } cout << endl; } //由于它是一个容器，所以在传递值的时候应该使用一对花括号把所有值括起来 if(expected != actual) { error_msg({"functionX", "expected", "actual"}); }else { error_msg({"functionX", "okay"}); }返回类型和return语句函数根据返回值类型可以分为三大类，无返回值的函数、返回普通值的函数、返回指针或者引用的函数。无返回值的函数无返回值的函数不要求非要有return 语句，这类函数在最后一句执行完后会隐式的执行return语句如果无返回值的函数需要在中间位置提前退出的话，可以使用return语句另一个使用return的场景是，直接在return后面加上函数调用，不过被调用的函数需要也是无返回值的函数返回普通值的函数有返回值的函数，必须使用return 返回一个值，返回的值必须与函数的返回类型相同，或者能隐式的转化成函数的返回值要注意保证所有路径都有返回值，一般编译器能发现这类情况，但是有的编译器不能，如果执行了没有返回值的分支，将产生未定义错误不要返回局部对象的指针或者引用函数的调用优先级与点运算和箭头运算的优先级相同，并且也附和左结合律函数的返回类型决定函数调用是否是左值，调用一个返回引用的函数得到一个左值，其他返回类型得到右值，我们能为返回类型是非常量引用的函数结果赋值当返回一个容器时，c++ 11开始，可以返回由大括号组成的初始化列表针对main函数来说，最后可以不加return语句，如果最后没有return 则编译器默认给它加上一个return 0返回数组指针的函数因为数组不能被拷贝，所以不能直接返回数组，不过可以返回数组的指针或者引用定义指向数组的指针采用的是int (*p)[10]; 的方式，同样的定义返回数组指针的函数，只需要把p定义为函数形式即可:int (*func(int i))[10];。上述定义写起来比较麻烦，而且也不容易理解，因此可以使用类型别名的方式来简化定义方式int odd[] = {1, 3, 5, 7, 9}; int even[] = {2, 4, 6, 8, 10}; decltype(odd)* arrPtr(int i) { return (i % 2) ? &odd, &even; }当我们直到返回的数组指针具体指向哪个数组，可以使用decltype关键字来声明函数的返回类型。从c++11 开始，提供了一种新的定义方式，即尾置返回类型的方式auto func(int i) -> int (*)[10];函数重载c++ 与 c语言中的一个很大的不同就是c++ 允许函数重载。同一作用域内的几个函数名称相同，但形参列表不同的，称之为函数重载。注意这里的几个前提条件：同一作用域、函数名称相同、形参列表不同；这些条件缺一不可。而且这里说的是形参列表不同，返回值不同的不能算是重载。main函数作为入口函数，只能有一个顶层const不影响传入的参数，因此认为顶层const与普通形参相同，不认为是重载如果传入的参数是引用或者指针，可以根据它所指向的对象是否为const来进行区分，所以底层const可以作为重载由于非const型参数能转化为const型，所以当传参中多个函数都满足，编译器会优先选择const版本在实际使用时，根据调用时的传参，来与一组重载函数中的某一个关联起来，这个过程叫做函数匹配或者叫做重载确定一般情况下函数匹配过程很容易分别出来，要么是形参个数不同，要么是类型毫无关系，但是也有例外，例如：形参中存在默认值形参中一种类型可以转化为另一种类型目前来说调用函数的时候会出现下列三种情况：可以从一堆重载函数中正确匹配，编译通过没有函数复合调用时传入的实惨，此时编译报错，无法找到对应函数多个重载形式都复合传入的实惨，此时编译报错，存在二义性不要在局部作用域中定义函数，因为局部作用域内出现重名情况时，会进行名称覆盖特殊用途的语言特性默认实参在定义函数时，对于后续多次调用时，传入相同实参值的形参，可以给予一个默认值。这样在调用这个函数时，针对提供了默认值的参数，可以传参也可以不传函数调用时按照实参位置解析，默认实参负责填补函数调用缺少的尾部实参内联函数一般函数调用涉及到参数的拷贝，返回值的拷贝，以及最终栈的回收等一系列操作。调用函数存在一定的性能开销，因此为了提高性能或者提高代码的重复使用率，c中可以使用宏定义来定义一个短小的常规操作，最终编译时会被编译器展开。但是宏定义无法对传入参数进行校验，而且需要注意的问题较多，不好理解。C++中引入内联函数，它与宏的功能类似，是一种没有额外开销的函数一般在函数的返回值类型前面加上inline 关键字就定义了一个内联函数并不是所有的函数都可以定义为内联函数。内联函数用于优化规模小、流程直接、调用频繁的函数，很多编译器不支持内联递归函数。而且一个大于75行的函数也不大可能在调用点内联展开constexpr 函数constexpr 函数是指能用于常量表达式的函数。constexpr函数与普通函数的定义相同，不过要遵循几项约定：函数的返回值以及所有形参类型都是字面值类型函数体中必须有且只有一条return语句在编译阶段，constexpr函数会被直接替换为它返回的具体的值，为了便于函数正常展开，constexpr函数默认都是内联函数由于在编译阶段编译器需要知道内联函数和constexpr 函数的定义。因此这两种函数可以重复定义。但是定义时要保证内容完全相同，基于这个理由，可以将这两种函数统一放到一个头文件中，在需要使用的时候包含它调试帮助可以使用assert预处理宏与NODEBUG宏，其中assert只有在调试模式下才会起作用，而NODEBUG宏则表示当前在发布模式下，此时assert函数不会起作用另外C++ 也定义一些名字便于调试：__FILE__: 当前代码所在文件的名称__LINE__: 当前代码所在行数__TIME__: 当前代码文件被编译的时间__DATE__: 当前代码文件被编译的日期__func__: 当前代码所在的函数函数匹配在大多数情况下，很容易分辨某次调用应该选择哪个重载函数，然而当几个重载函数的形参数量相等以及某些形参的类型可以由其他类型转化得来时，这项工作就不那么容易了。void f(); void f(int); void f(int, int); void f(double, double = 3.14); //调用 f(5.6);函数匹配过程一般经历如下步骤：确定候选函数和可行函数第一步选定本次调用对应的重载函数集，集合中的函数被称之为候选函数。候选函数具备两个特点，一是与被调用的函数同名，二是其声明在调用点可见，这步下来，上述例子中所有f函数都满足条件第二步考察本次调用提供的实参，然后从候选函数中选择能被这组实参调用的函数，这些函数被称为可行函数，可行函数也有两个特征，一是其形参数量与本次调用提供的实参数量相同，二是每个实参与对应形参类型相同，或者能转化成形参的类型。上述实例，调用传入的是一个double类型的参数，double可以转化为int，因此这个时候发现满足条件的是 void f(int); 和 void f(double, double=3.14);寻找最佳匹配第三步是从可行函数中寻找与本次调用最匹配的函数，它的基本思想是实参类型与形参类型越接近，它们匹配的越好。如果多个形参都与调用函数的实参较为接近且，如果有且只有一个函数同时满足下面两个条件，则匹配成功：该函数每个实参的匹配不劣与其他可行函数需要的匹配至少有一个实参的匹配优于其他可行函数提供的方案如果检查了所有实参后没有任何一个函数脱颖而出，则调用错误，编译器将报告二义性。调用重载函数尽量避免强制类型转换，如果在实际应用中需要进行强制类型转换，说明我们设计的形参集合不合理分析上面的例子，如果采用 void f(int); 在调用时会进行一次将double转化为int的类型转化，如果使用 void f(double, double=3.14); 5.6作为double的第一个参数进行传递不需要类型转化，而第二个参数使用默认形参，这里可以不传，因此相比较与第一种int的传参方式，后一种显然更加复合实参类型转化为了确定最佳匹配，编译器将实参类型到形参类型的转化划分为几个等级，具体排序如下所示：精确匹配，包括下列情况 1.1. 实参类型和形参类型相同 1.2. 实参从数组类型或者函数类型转化为对应的指针类型 1.3. 像实参添加顶层const或者从实参中删除顶层const通过const转换实现的类型匹配通过类型提升实现的类型匹配通过算术类型转换或者指针转换实现的匹配通过类类型转换实现的匹配函数指针声明函数指针时，只需要将函数声明中的函数名写为指针名即可，但是需要注意使用括号将表示指针的*与指针名称括起来void (*f)(int);当我们把函数名直接作为一个值使用时，该函数自动转化为指针；也可以使用取地址符针对函数名称取地址，二者是等价的。指向不同类型函数的指针不存在类型转化重载函数的指针必须与某个函数精确匹配，不存在形参类型转化之类的规则可以使用typedef来为函数指针类型定义一个类型别名typedef void(*f)(int); //将返回void、传入一个int参数的函数指针取类型别名为f