![\"Design](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/07\/Design_by_contract.png\")
<\/p>\nMy original plan was it to write in this post about the next rules to error handling. But I changed my plan to write about the future: contracts in C++20.<\/p>\n
<\/p>\n
<\/p>\n
By Fabuio<\/a> – Own work<\/span>, CC0<\/a>, Link<\/a><\/p>\n Here are the rules I will skip.<\/p>\n E.8: State your postconditions<\/a><\/p>\n<\/li>\n<\/ul>\n Why did I change my plan? I did it for a few reasons.<\/p>\n The consequence of these points is quite simple. Contracts seem necessary for error handling; C++20 will presumably have contracts. Therefore, I am writing this post about contracts in C++20.<\/p>\n In case you want to have more details on contracts. This post is based on proposals P0380R1 <\/a>and P0542R5<\/a>.<\/p>\n First of all.<\/p>\n A contract specifies in a precise and checkable way interfaces for software components. These software components are functions and methods that must fulfill preconditions, postconditions, and invariants. Here are the shortened definitions from the proposals.<\/p>\n The precondition and the postcondition are in C++20, placed outside the function definition, but the invariant is placed inside the function definition. A predicate is a function that returns a boolean.<\/p>\n <\/p>\n The attribute expects<\/span> is a precondition, the attribute ensures<\/span> is a postcondition, and the attribute assert <\/span>is an assertion.<\/p>\n The contracts for the function push<\/span> are that the queue is incomplete before adding an element that is not empty after adding, and the assertion q.is_ok()<\/span> holds.<\/p>\n Preconditions and postconditions are part of the function interface. This means they can’t access local members of a function or private or protected members of a class. In contrast, assertions are part of the implementation and can, therefore, access local members of a function of private or protected class members.<\/p>\n <\/p>\n <\/p>\n m<\/span> is private and can not be part of a precondition.<\/p>\n By default, a violation of a contract terminates the program. This is not the whole story; let me give you more details.<\/p>\n<\/p>\n Here is the full syntax of the contract attributes: [[contract-attribute modifier: conditional-expression ]]<\/strong><\/span><\/p>\n For the ensures<\/span> attribute, there is an additional identifier available. [[ensures modifier identifier: conditional-expression ]]<\/strong><\/span><\/p>\n The identifier<\/strong><\/span> lets you refer to the return value of the function.<\/p>\n <\/p>\n res<\/span> as the identifier is, in this case, an arbitrary name. As shown in the example, you can use more contracts of the same kind.<\/p>\n Let me dive deeper into the modifiers and the handling of the contract violations.<\/p>\n A compilation has three assertion build levels:<\/p>\n If a contract violation occurs – the predicate evaluates to false -, the violation handler is invoked. The violation handler is a function of type noexcept<\/span> which takes a const std::contract_violation<\/span> and returns a void. <\/span>Because the function is noexcept, <\/span>this means that std::terminate<\/span> is called in case of a contract violation. A user can set a violation handler.<\/p>\n The class std::contract_violation<\/span> gives information about the violation of the contract.<\/p>\n <\/p>\n There are a few rules to remember if you declare a contract.<\/p>\n A contract can be placed on the declaration of a function. This includes declarations of virtual functions or function templates.<\/p>\n <\/p>\n <\/p>\n <\/p>\n Both contract definitions of class D<\/span> are erroneous. The contract of the method f<\/span> differs from the one from B::f<\/span>. The method D::g<\/span> adds a contract to B::g<\/span>.<\/p>\n Impressed? Me too! I still can not imagine how fundamentally contracts will change how we write functions and think about interfaces and exception handling. Maybe Herb Sutter’s thoughts on Sutter’s Mill<\/a> give you an idea because, for him, “contracts is the most impactful feature of C++20 so far, and arguably the most impactful feature we have added to C++ since C++11<\/em>.”<\/p>\n With my next post, I will continue with a step back to the present time and write about the rules for exception handling.<\/p>\n Wow! Almost 200 readers participated in the vote for the next pdf bundle. Here are the winners.<\/p>\n I need at least a week to proofread and prepare the pdf bundles<\/p>\n<\/div>\n <\/p>\n <\/p><\/p>\n","protected":false},"excerpt":{"rendered":" My original plan was it to write in this post about the next rules to error handling. But I changed my plan to write about the future: contracts in C++20.<\/p>\n","protected":false},"author":21,"featured_media":5473,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[481,478,482],"class_list":["post-5475","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-contracts","tag-error-handling","tag-outdated"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5475","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=5475"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5475\/revisions"}],"predecessor-version":[{"id":6818,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5475\/revisions\/6818"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5473"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5475"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5475"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5475"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\n
What is a contract?<\/h3>\n
\n
\n <\/div>\nHere is a first example:<\/div>\n<\/div>\n <\/div>\n\nint<\/span> push(queue&<\/span> q, int val) \r\n [[ expects:<\/span> !q<\/span>.full() ]]\r\n [[ ensures !<\/span>q.empty() ]]{\r\n ...\r\n [[assert:<\/span> q.is_ok() ]]
...\r\n}\r\n<\/pre>\n<\/div>\n\nclass<\/span> X<\/span> {\r\npublic:<\/span>\r\n void<\/span> f(int<\/span> n)\r\n [[ expects:<\/span> n<<\/span>m ]] \/\/ error; m is private<\/span>\r\n {\r\n [[ assert:<\/span> n<<\/span>m ]]; \/\/ OK<\/span>\r\n \/\/ ...<\/span>\r\n }\r\nprivate:<\/span>\r\n int<\/span> m;\r\n}; \r\n<\/pre>\n<\/div>\nMore Details<\/h3>\n
\n
\n
\nint<\/span> mul(int<\/span> x, int<\/span> y)\r\n [[expects:<\/span> x ><\/span> 0<\/span>]] \/\/ implicit default\r\n [[expects default<\/span>:<\/span> y ><\/span> 0<\/span>]]\r\n [[ensures audit res:<\/span> res ><\/span> 0<\/span>]]{\r\n return<\/span> x *<\/span> y;\r\n}\r\n<\/pre>\n<\/div>\nHandling contract violations<\/h3>\n
\n
\nnamespace<\/span> std{ \r\n class<\/span> contract_violation<\/span>{\r\n public:<\/span>\r\n uint_least32_t<\/span> line_number() const<\/span> noexcept;\r\n string_view file_name() const<\/span> noexcept;\r\n string_view function_name() const<\/span> noexcept;\r\n string_view comment() const<\/span> noexcept;\r\n string_view assertion_level() const<\/span> noexcept;\r\n };\r\n}\r\n<\/pre>\n<\/div>\n\n
<\/span><\/li>\n
<\/span><\/li>\n
<\/span><\/li>\n
<\/span><\/li>\n
<\/span><\/li>\n<\/ul>\nDeclaration of contracts<\/h3>\n
\n
\nint<\/span> f(int<\/span> x) \r\n [[expects:<\/span> x><\/span>0<\/span>]]\r\n [[ensures r:<\/span> r><\/span>0<\/span>]];\r\n\r\nint<\/span> f<\/span>(int<\/span> x); \/\/ OK. No contract.<\/span>\r\n\r\nint<\/span> f(int<\/span> x)\r\n [[expects:<\/span> x>=<\/span>0<\/span>]]; \/\/ Error missing ensures and different expects condition<\/span>\r\n<\/pre>\n<\/div>\n\n
\nstruct<\/span> B{\r\n virtual<\/span> void<\/span> f(int<\/span> x)[[expects:<\/span> x ><\/span> 0<\/span>]];\r\n virtual<\/span> void<\/span> g<\/span>(int<\/span> x);\r\n}\r\n\r\nstruct<\/span> D:<\/span> B{\r\n void<\/span> f(int<\/span> x)[[expects:<\/span> x >=<\/span> 0<\/span>]]; \/\/ error<\/span>\r\n void<\/span> g(int<\/span> x)[[expects:<\/span> x !=<\/span> 0<\/span>]]; \/\/ error<\/span>\r\n};\r\n<\/pre>\n<\/div>\nClosing Thoughts<\/h3>\n
What’s next?<\/h2>\n
Further Information<\/h2>\n
\n\n
Here are the details of the vote:<\/div>\n\n\n