This article continues the series of posts about the new features included in C++26 (as they are accepted). This time I will focus on a single language feature: concepts. This has been under the radar of the standard committee for quite some time and it’s finally being added to the standard.<\/p>\n\n\n\n
Contracts define language level assertions for checking preconditions, postconditions, and invariants for functions. Let’s see how they work (however, at the time of writing this article no major compiler has support for them).<\/p>\n\n\n\n
Asserting is possible with a macro called The check We can turn off this checks by defining another macro called These asserts are checked at runtime. But it’s also possible to define assertions at compile time with the use of If we compile this code, we get a compiler error with the message “T must be copyable”, because C++26 defines asserts as a language feature with the help of three new keywords:<\/p>\n\n\n\n The argument for all these asserts is an expression that evaluates to a On the other hand, Here is how we can re-write the previous However, for this particular case, the index being smaller than the size of the container is a precondition. Threfore, the best way to perform the assert is using the Similarly, we can define post asserts in the same manner:<\/p>\n\n\n\n As previously mentioned, we can specify both pre- and post-conditions on the same function:<\/p>\n\n\n\n In the case of the Just like the Note that whether termination happens with a call to When an assertion check fails a function called A default implementation is provided but a user-defined replacement could be supplied. Note, however, that the standard does not guarantee this; it’s implementation-defined whether this handler can be replaced with a user-defined one or not.<\/p>\n\n\n\n Having a user-defined implementation is helpful in order to define your own strategy for handling the assertion failure. The When the handler returns normally, the behavior of the program depends on the evaluation semantic:<\/p>\n\n\n\n To learn more about these topic see:<\/p>\n\n\n\n This article continues the series of discussing the C++26 features with the topic of concepts, which are language level asserts for checking function preconditions, postconditions, and invariants.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,647,648],"class_list":["post-4755","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-c26","tag-contracts"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\tassert<\/code>, available in the <cassert><\/code> header. Here is how we can use it to check some conditions:<\/p>\n\n\n\ntemplate <typename T>\nclass sequence\n{\npublic:\n sequence(size_t capacity) : \n capacity_(capacity), \n size_(0)\n {\n data_ = new T[capacity_];\n }\n\n ~sequence()\n {\n delete[] data_;\n }\n\n T& operator[](size_t index)\n {\n assert(index < size_);\n return data_[index];\n }\n\n const T& operator[](size_t index) const\n {\n assert(index < size_);\n return data_[index];\n }\n\n size_t size() const\n {\n return size_;\n }\n\n void resize(size_t new_capacity)\n {\n assert(new_capacity > 0);\n if(new_capacity <= 0) return;\n\n T* new_data = new T[new_capacity];\n size_t min_size = std::min(size_, new_capacity);\n for (size_t i = 0; i < min_size; ++i)\n {\n new_data[i] = data_[i];\n }\n\n delete[] data_;\n data_ = new_data;\n capacity_ = new_capacity;\n size_ = min_size;\n }\n\n void clear()\n {\n size_ = 0;\n }\n\n void push_back(const T& value)\n {\n if(capacity_ == size_)\n resize(capacity_ * 2);\n\n data_[size_] = value;\n size_++;\n }\n\n void pop_back()\n {\n if (size_ > 0)\n size_--;\n }\n\nprivate:\n T* data_;\n size_t size_;\n size_t capacity_;\n};<\/pre>\n\n\n\nassert(index < size_)<\/code> in operator[]<\/code> verifies that we don’t call with an index that is beyond the bounds of the sequence. Similarly, assert(new_capacity > 0)<\/code> in resize()<\/code> verifies we don’t resize to a zero capacity. However, just the assert is not enough, the program should ensure it does the right thing (such as throwing an exception) if the condition does not hold.<\/p>\n\n\n\nNDEBUG<\/code> (keep in mind that although assert<\/code> is a standard macro, NDEBUG<\/code> is not).<\/p>\n\n\n\nstatic_assert<\/code> (which is a keyword). Here is an example:<\/p>\n\n\n\ntemplate <typename T>\nclass sequence\n{\n static_assert(std::is_copy_constructible_v<T>, \"T must be copyable\");\n};\n\nint main()\n{\n sequence<int> si(3); \/\/ OK\n sequence<std::unique_ptr<int>> su(3); \/\/ error: T must be copyable\n}<\/pre>\n\n\n\nstd::unique_ptr<\/code> is not copyable, and therefore cannot be used with our sequence<\/code> class.<\/p>\n\n\n\nEnter contracts<\/h2>\n\n\n\n
contract_assert<\/code>: is the equivalent of the assert<\/code> macro, and is intended for performing checks at run-time. (As a side note, it could not be named assert<\/code> because that would have conflicted with the assert<\/code> macro.)<\/li>pre<\/code>: defines asserts for functions that specify preconditions<\/li>post<\/code>: defines asserts for functions that specify postconditions<\/li><\/ul>\n\n\n\nbool<\/code>.<\/p>\n\n\n\ncontract_assert<\/code> can be used in function bodies, while pre<\/code> and post<\/code> apply to function declarators. A function can have any number of pre<\/code> and post<\/code> asserts and they can be specified in any order. These two can be applied to:<\/p>\n\n\n\npre<\/code> and post<\/code> cannot be applied to:<\/p>\n\n\n\n=default<\/code>)<\/li>=delete<\/code>)<\/li>operator[]<\/code> to use contract_assert<\/code>:<\/p>\n\n\n\nT& operator[](size_t index)\n{\n contract_assert(index < size_);\n return data_[index];\n}<\/pre>\n\n\n\npre<\/code> keyword:<\/p>\n\n\n\nT& operator[](size_t index)\n pre (index < size_)\n{\n return data_[index];\n}<\/pre>\n\n\n\nvoid clear()\n post (size_ == 0)\n{\n size_ = 0;\n}<\/pre>\n\n\n\nvoid resize(size_t new_capacity)\n pre (new_capacity > 0)\n post (size_ <= capacity_)\n{\n \/\/ ...\n}<\/pre>\n\n\n\npost<\/code> assert, you can refer directly the object returned by the function, using the syntax shown below (notice that the name of the variable in the post assert can be anything that is a valid identifier):<\/p>\n\n\n\nsequence<int> make_range(int const from, int const to)\n pre (from < to)\n post(r: r.size() == to - from + 1))\n post(r: r[0] == from)\n post(r: r[r.size() - 1] == to)\n{\n sequence<int> s(to - from + 1);\n for (int i = from; i <= to; ++i)\n {\n s.push_back(i);\n }\n return s;\n}<\/pre>\n\n\n\nEvaluation of asserts<\/h2>\n\n\n\n
assert<\/code> macro can be undefined with another macro, so do contracts provide several possible evaluation semantics. These could be specified with a compiler flag. For instance, Clang and GCC provide one called -fcontract-semantic<\/code>. The possible semantics are:<\/p>\n\n\n\nignore<\/code>: no check is performed<\/li>enforce<\/code>: the checks are performed and if one fails then a message is printed and the program terminates<\/li>observe<\/code>: the checks are performed and if one fails then a message is printed but the program continues its execution<\/li>quick-enforce<\/code>: the checks are performed and if one fails the program terminates immediately without printing a message and without doing anything else<\/li><\/ul>\n\n\n\nstd::terminate<\/code> or std::abort<\/code> is implementation defined.<\/p>\n\n\n\nAssertion violation handler<\/h2>\n\n\n\n
handle_contract_violation<\/code> is called. This has the following signature:<\/p>\n\n\n\nvoid handle_contract_violation( std::contracts::contract_violation );<\/pre>\n\n\n\n
std::contracts::contract_violation<\/code> parameter of this function provides information about the failure (including location and evaluation semantic).<\/p>\n\n\n\nobserve<\/code>, the program continues normally<\/li>enforce<\/code>, the program terminates<\/li><\/ul>\n\n\n\nFurther readings<\/h3>\n\n\n\n