![\"GeneralIdioms\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/12\/GeneralIdioms.png\")
<\/p>\nAn idiom is an architectural or design pattern implementation in a concrete programming language. Applying them is idiomatic for a programming language. Today. I write about the Copy-and-Swap Idiom in C++. This idiom gives you the strong exception safety guarantee.<\/p>\n
<\/p>\n
<\/p>\n
Before I write about the Copy-and-Swap Idiom, I should first clarify the strong exception safety guarantee. Here are a few general thoughts about error handling:<\/p>\n
When you handle an error, the following aspects should be considered:<\/p>\n
You should use exceptions for error handling. In the document “Exception-Safety in Generic Components<\/a>” David Abrahams<\/a> formalized what exception-safety means.<\/p>\n Abrahams Guarantees describe a contract that is fundamental if you think about exception safety. Here are the four levels of the contract:<\/p>\n In general, you should at least aim for the basic exception safety guarantee. This means that you don’t have resource leaks in case of an error, and your program is always in a well-defined state. If your program is not in a well-defined state after an error, there is only one option left: shut down your program.<\/p>\n I stated that the Copy-and-Swap Idiom provides a strong exception safety guarantee. This is a stronger guarantee such as the basic exception safety guarantee.<\/p>\n<\/p>\n Okay, I know what copy means. Therefore, let me write about swap:<\/p>\n For a type to be a regular type, it has to support a The following data type Foo has a <\/p>\n <\/p>\n For convenience reasons, you should consider supporting a non-member swap function based on the already implemented swap member function. <\/p>\n If you do not provide a non-member <\/p>\nAbrahams Guarantees<\/h3>\n
\n
The Copy-and-Swap Idiom<\/h2>\n
The
swap<\/code> function<\/h3>\nswap<\/code> function. A more informal definition of regular type is a value-like type that behaves like an int<\/code>. I will write about regular types in an upcoming post. According to the rules “C.83: For value-like types, consider providing a noexcept swap function<\/a>” and “C.85: Make swap noexcept<\/a>” of the C++ Core Guidelines, a swap<\/code> function should not fail and be noexcept<\/code>.<\/p>\nswap<\/code> function.<\/p>\n\nclass<\/span> Foo<\/span> {\r\n public:<\/span>\r\n void<\/span> swap(Foo&<\/span> rhs) noexcept {\r\n m1.swap(rhs.m1);\r\n std::<\/span>swap(m2, rhs.m2);\r\n }\r\n private:<\/span>\r\n Bar m1;\r\n int<\/span> m2;\r\n};\r\n<\/pre>\n<\/div>\n
<\/p>\n\nvoid<\/span> swap<\/span>(Foo&<\/span> a, Foo&<\/span> b) noexcept {\r\n a.swap(b);\r\n}\r\n<\/pre>\n<\/div>\nswap<\/code> function, then the standard library algorithms that require swapping (such as std::sort<\/code> and std::rotate<\/code>) will fall back to the std::swap<\/code> template, which is defined in terms of move construction and move assignment.
<\/p>\n\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> std::<\/span>swap(T&<\/span> a, T&<\/span> b) noexcept {\r\n T tmp(std::<\/span>move(a));\r\n a =<\/span> std::<\/span>move(b);\r\n b =<\/span> std::<\/span>move(tmp);\r\n}\r\n<\/pre>\n<\/div>\n
![\"RainerGrimmDunkelBlauSmall\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/07\/RainerGrimmDunkelBlauSmall.jpg\")
<\/p>\n