C++ templates let you reuse code, but it comes at a cost: Each template expansion results in a different function. This is not a big deal for small functions, but the less trivial your function becomes, the larger the cost of the repeated expansions.<\/p>\n
This is particularly expensive for functions that accept lambdas because every lambda is a unique type, so each time you invoke the template function with a lambda you get a different template expansion.<\/p>\n
Sometimes I see large template functions that have very few type dependencies.<\/p>\n
template<typename Table>\r\nvoid something(Database const& db)\r\n{\r\n \/\/ extensive preparations\r\n auto statusIndicator = \u27e6 calculate status indicator \u27e7\r\n auto primaryTugboat = \u27e6 calculate primary tugboat \u27e7\r\n std::vector<Staircase> staircases;\r\n\r\n for (auto&& column : Table::Columns()) {\r\n \u27e6 operate on each column using the stuff we prepared \u27e7\r\n \u27e6 maybe add things to the staircases and update the tugboat \u27e7\r\n }\r\n\r\n \u27e6 lots more code \u27e7\r\n}\r\n<\/pre>\nIn this extreme case, the only type dependency is the Table::Columns()<\/code>. (A more common source of type dependencies would be method calls on a templated inbound parameter.)<\/p>\nThis is a large function, and it will be re-expanded for each Table<\/code>. Since each table has a different set of columns, and probably a different number of columns, there is no opportunity for COMDAT folding, so the different expansions will all be distinct.<\/p>\nOne way to mitigate the explosion is to wrap all the common pieces into a helper object.<\/p>\n
struct SomethingState {\r\n Database const& db;\r\n Indicator statusIndicator;\r\n Tugboat primaryTugboat;\r\n std::vector<Staircase> staircases;\r\n\r\n __declspec(noinline)\r\n SomethingState(Database const& db) : db(db)\r\n {\r\n statusIndicator = \u27e6 calulate status indicator \u27e7\r\n primaryTugboat = \u27e6 calulate primary tugboat \u27e7\r\n }\r\n\r\n __declspec(noinline)\r\n void ProcessColumn(Column const& column)\r\n {\r\n \u27e6 operate on each column using the stuff we prepared \u27e7\r\n \u27e6 maybe add things to the staircases and update the tugboat \u27e7\r\n }\r\n\r\n __declspec(noinline)\r\n void Finish()\r\n {\r\n \u27e6 lots more code \u27e7\r\n }\r\n};\r\n\r\ntemplate<typename Table>\r\nvoid something(Database const& db)\r\n{\r\n SomethingState state(db);<\/span>\r\n\r\n for (auto&& column : Table::Columns()) {\r\n state.ProcessColumn(column);<\/span>\r\n }\r\n\r\n state.Finish();<\/span>\r\n}\r\n<\/pre>\nNow, the different expansions of the something<\/code> function can share the SomethingState<\/code> constructor and methods, so the unique functions are fairly small.<\/p>\n