![\"cogs\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/07\/cogs.jpg\")
<\/p>\nFunctions are the “fundamental building block of programs.” and “the most critical part in most interfaces.” These statements introduce the rules to function of the C++ core guidelines. Of course, both statements are right. So, let’s dive deeper into the more than 30 rules for defining functions, passing arguments to functions, and returning values from functions.<\/p>\n
<\/p>\n
<\/p>\n
I will not write about each rule in depth because there are too many rules. I will try to make a story out of the rules. Therefore, you and I can keep them in mind. Let’s start with the rules for defining functions. Here is an overview.<\/p>\n
<\/p>\n
constexpr<\/code><\/a><\/li>\n- F.5: If a function is very small and time-critical, declare it inline<\/a><\/li>\n
- F.6: If your function may not throw, declare it
noexcept<\/code><\/a><\/li>\n- F.7: For general use, take
T*<\/code> or T&<\/code> arguments rather than smart pointers<\/a><\/li>\n- F.8: Prefer pure functions<\/a><\/li>\n
- F.9: Unused parameters should be unnamed<\/a><\/li>\n<\/ul>\n
<\/p>\n
<\/p>\n
<\/span>Function definitions<\/span><\/h2>\n<\/span>F.1: \u201cPackage\u201d meaningful operations as carefully named functions<\/a><\/span><\/h3>\n<\/span>F.2: A function should perform a single logical operation<\/a><\/span><\/h3>\n<\/span>F.3: Keep functions short and simple<\/a><\/span><\/h3>\nThe first three rules are pretty obvious and share a common idea. I will start with rule F2. If you write a function that performs a single logical operation (F2)<\/strong>, the function will become short and straightforward with a high likelihood (F3). <\/strong>The rules talk about functions that should fit on a screen. Now, you have these short and simple functions that do exactly one logical operation, and you should carefully give them names (F1). <\/strong>These carefully named functions are the basic building blocks to combine and build higher abstractions. Now, you have well-named functions and can easily reason about your program.<\/p>\n<\/span>F.4: If a function may have to be evaluated at compile-time, declare it constexpr<\/code><\/a><\/span><\/h3>\nA constexpr<\/span> function is a function that can run at compile time or run time. If you invoke a constexpr<\/span> function with constant expressions and ask for the result at compile-time, you will get it at compile-time. If you invoke the constexpr<\/span> function with arguments that can not be evaluated at compile-time, you can use it as an ordinary runtime function. <\/p>\n <\/p>\n
\nconstexpr int<\/span> min<\/span>(int<\/span> x, int<\/span> y) { return<\/span> x <<\/span> y ?<\/span> x :<\/span> y; }\r\n\r\nconstexpr auto<\/span> res=<\/span> min(3<\/span>, 4<\/span>);\r\n\r\nint<\/span> first =<\/span> 3<\/span>;\r\nauto<\/span> res2 =<\/span> min(first, 4<\/span>);\r\n<\/pre>\n<\/div>\n <\/p>\n
The function min<\/span> has the potential to run at compile time. If I invoke min<\/span> with constant expressions and ask for the result at compile-time, I will get it at compile-time: constexpr auto<\/span> res=<\/span> min(3<\/span>, 4<\/span>). <\/span>I have to use min <\/span>as an ordinary function because first <\/span>is not a constant expression: auto<\/span> res2 =<\/span> min(first, 4<\/span>).<\/span><\/p>\nThere is a lot more to constexpr<\/span> functions. Their syntax was somewhat limited with C++11, and they became pretty comfortable with C++14. They are a kind of pure function in C++. See my posts about constexpr<\/a>.<\/p>\n<\/p>\n<\/span>F.5: If a function is very small and time-critical, declare it inline<\/a><\/span><\/h3>\nI was astonished to read this rule because the optimizer will inline<\/span> functions that are not declared inline<\/span>, and the other way around: they will not inline<\/span> functions, although you declare them as inline. <\/span>In the end, inline is only a hint for the optimizer. <\/p>\nconstexpr<\/span> implies inline.<\/span> The same holds, by default, true<\/code> for member functions defined in the class or function templates.<\/p>\nWith modern compilers, the main reason for using inline<\/span> is to break the One Definition Rule (ODR). You can define an inline<\/span> function in more than one translation unit. Here is my post about inline.<\/a><\/p>\n<\/span>F.6: If your function may not throw, declare it noexcept<\/code><\/a><\/span><\/h3>\nBy declaring a function as noexcept,<\/span> you reduce the number of alternative control paths; therefore, noexecpt<\/span> is a valuable hint to the optimizer.<\/p>\nEven if your function can throw, noexcept<\/span> often makes a lot of sense. noexcept<\/span> means in such case: I don’t care. The reason may be that you cannot react to an exception. Therefore, the only way to deal with exceptions is that terminate()<\/span> will be invoked. <\/span><\/p>\nHere is an example of a<\/span>function declared as noexcept<\/span> that may throw because the program may run out of memory.<\/p>\n\nvector<<\/span>string><\/span> collect(istream&<\/span> is) noexcept\r\n{\r\n vector<<\/span>string><\/span> res;\r\n for<\/span> (string s; is >><\/span> s;)\r\n res.push_back(s);\r\n return<\/span> res;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
<\/span>F.7: For general use, take T*<\/code> or T&<\/code> arguments rather than smart pointers<\/a><\/span><\/h3>\nYou restrict the usage of your functions by using Smart Pointers. The example makes the point clear.<\/p>\n
\n\/\/ accepts any int*<\/span>\r\nvoid<\/span> f<\/span>(int<\/span>*<\/span>);\r\n\r\n\/\/ can only accept ints for which you want to transfer ownership<\/span>\r\nvoid<\/span> u<\/span>(unique_ptr<<\/span>int<\/span>><\/span>);\r\n\r\n\/\/ can only accept ints for which you are willing to share ownership<\/span>\r\nvoid<\/span> s<\/span>(shared_ptr<<\/span>int<\/span>><\/span>);<\/span><\/span><\/span><\/span><\/span><\/span>\r\n\r\n\/\/ accepts any int<\/span>\r\nvoid<\/span> h<\/span>(int<\/span>&<\/span>);\r\n<\/pre>\n<\/div>\n <\/p>\n
The functions u<\/span> and s<\/span> have unique ownership semantics. u<\/span> want to transfer ownership, s<\/span> wants to share ownership. The function s<\/code> includes a minor performance penalty. The reference counter of the std::shared_ptr<\/span> has to be increased and decreased. This atomic operation takes a little bit of time. <\/p>\n<\/span>F.8: Prefer pure functions<\/a><\/span><\/h3>\nA pure function is a function that always returns the same value when given the same arguments. This property is also often called referential transparency<\/a>.<\/p>\nPure functions have a few interesting properties:<\/p>\n
![\"PureImpureFunctionsEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/01\/PureImpureFunctionsEng.png\")
<\/p>\n
These properties have far-reaching consequences because you can think about your function in isolation:<\/p>\n
\n- The correctness of the code is easier to verify<\/li>\n
- The refactoring and testing of the code are simpler<\/li>\n
- You can memorize function results<\/li>\n
- You can reorder pure functions or perform them on other threads.<\/li>\n<\/ul>\n
Pure functions are often called mathematical functions.<\/p>\n
By default, we have no pure functions in C++, such as the purely functional language Haskell, but constexpr<\/span> functions are nearly pure. So pureness is based on discipline in C++.<\/p>\nOnly for completeness. Template metaprogramming is a purely functional language embedded in the imperative language C++. If you are curious, read here about template metaprogramming.<\/a><\/p>\n<\/span>F.9: Unused parameters should be unnamed<\/a><\/span><\/h3>\nIf you don’t provide names for the unused parameters, your program will be easier to read and will not get warnings about unused parameters.<\/p>\n
<\/span>What’s next<\/span><\/h2>\nThese were the rules about function definitions. I will write about the parameter passing to functions in the next post.<\/p>\n
<\/p>\n
<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Functions are the “fundamental building block of programs.” and “the most critical part in most interfaces.” These statements introduce the rules to function of the C++ core guidelines. Of course, both statements are right. So, let’s dive deeper into the more than 30 rules for defining functions, passing arguments to functions, and returning values from […]<\/p>\n","protected":false},"author":21,"featured_media":5288,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[503],"class_list":["post-5289","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-functions"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5289","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5289"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5289\/revisions"}],"predecessor-version":[{"id":6867,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5289\/revisions\/6867"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5288"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5289"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5289"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5289"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}