c++ - 将 lambda 函数转换为另一个编译单元中的普通函数是否会缩短编译时间？

Question

我正在从事一个 C++ 服务器项目，该项目一直受到不断增长的 main() 函数的困扰，并且代码库已经增长到编译时间约为 6 分钟的地步(在 Debug模式下) ) 即使我对 main() 函数做了最细微的更改。 (main() 函数大约有 5000 行长!)

我使用的是 Visual Studio 2017，并且(据我了解)编译器具有一些预编译 header 功能，以及不重新编译未修改函数的功能。但是这些东西目前用处不大，因为大部分逻辑都在 main() 函数中。

这是我的代码的(非常简化的)版本:

struct GrandServer{
    std::map<std::string,std::function<void(std::string)>> request;
    /* some other functions of this server */
};

int main()
{
    SQLClient sql_client;
    auto query_database=[&sql_client](auto&& callback){/*stuff*/};
    GrandServer server;
    server.request["/my_page.html"] = [](std::string&& data){
        // Do stuff
    };
    server.request["/my_page_2.html"] = [](std::string&& data){
        // Do more stuff
    };
    server.request["/my_page_3.html"] = [](std::string&& data){
        // Do even more stuff
    };
    server.request["/my_page_4.html"] = [&query_database](std::string&& data){
        // Do many many callbacks
        query_database([](std::vector<std::string>&& results){
            std::string id = std::move(results.front());
            do_something_else([id = std::move(id)](auto&& param) mutable {
                /* do more stuff, call more functions that will call back, then answer the client */
            });
        });
    };
    /* Many many more lambda functions */
}

本质上，整个应用程序的核心逻辑包含在 main() 函数中，通过定义存储在 std::map 中的 lambda 表达式。 lambda 函数在其中包含几个级别的 lambda 函数，主要定义来自数据库的(异步)回调。其他独立函数主要包括GrandServer中的函数以及各种实用函数(例如时间转换、异步回调实用程序、unicode实用程序等)，但它们都不构成应用程序的核心逻辑.这感觉就像是非常糟糕的代码蔓延:(

我正在考虑将所有顶级 lambda(即那些直接存储在 server.request 中的)转换为普通的独立成员函数，再转换为几个独立的编译单元，如下所示:

// split definitions of methods in this class over several compilation units
// header file left out for brevity
struct MyServer{
    SQLClient sql_client;
    void query_database=[this](auto&& callback){/*stuff*/};

    void do_my_page(std::string&& data){
        // Do stuff
    }

    void do_my_page_2(std::string&& data){
        // Do stuff
    }

    void do_my_page_3(std::string&& data){
        // Do stuff
    }

    void do_my_page_4(std::string&& data){
        // Do many many callbacks
        query_database([](std::vector<int>&& results){
            do_something_else([](auto&& param){
                /* do more stuff, call more functions that will call back, then answer the client */
            });
        });
    }
};

// main.cpp
struct GrandServer{
    std::map<std::string,std::function<void(std::string)>> request;
    /* some other functions of this server */
};

int main()
{
    GrandServer server;
    MyServer my_server;
    server.request["/my_page.html"] = [&my_server](auto&&... params){my_server.do_my_page(std::forward<decltype(params)>(params)...);};
    server.request["/my_page_2.html"] = [&my_server](auto&&... params){my_server.do_my_page_2(std::forward<decltype(params)>(params)...);};
    server.request["/my_page_3.html"] = [&my_server](auto&&... params){my_server.do_my_page_3(std::forward<decltype(params)>(params)...);};
    server.request["/my_page_4.html"] = [&my_server](auto&&... params){my_server.do_my_page_4(std::forward<decltype(params)>(params)...);};
    /* Lots more lambda functions */
}

虽然这会将 main() 的大小减小到可以容忍的程度，但我是否应该期望这会显着减少编译时间？模板实例化的数量不会减少(事实上，我在 main() 中引入了一些应该内联的新模板 lambda 转发器)。

另请注意，由于使用移动语义的回调和变量捕获，将每个逻辑流中的内部 lambda 函数更改为正常的独立成员或非成员函数并不容易。 (模板函数和类不能在单独的编译单元中。)但是，每个逻辑流程通常不超过 100 行，所以我认为没有必要这样做。

6 分钟来编译大约 6000-7000 行的代码库似乎太慢了，我认为这是由于我的 main() 函数太长了。我是否应该像上面描述的那样分解这个函数来显着缩短这个项目的编译时间？

Answer 1

你有没有复制每一个#include <>至 stdfafx.h ？？这对减少编译时间大有帮助。编译器可能会提示预编译 header 太大，但默认大小小得离谱。

-Zm 选项控制分配给预编译 header 的数量，以兆字节为单位。

我发现某些项目的编译速度提高了 10 倍以上。

如果您将一个网络驱动器映射到您的一个本地磁盘，有一种简单的方法可以让编译时间进一步缩短 3 倍。

这是针对这种情况的解决方案，它涉及将网络映射替换为注册表中的 DOS 驱动器。这是我自己的设置:

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\DOS Devices] 
"R:"="\DosDevices\D:\devel\build"
"S:"="\DosDevices\D:\devel\src"