{"id":5749,"date":"2019-07-24T19:29:58","date_gmt":"2019-07-24T19:29:58","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-when-raii-breaks\/"},"modified":"2023-06-26T10:04:31","modified_gmt":"2023-06-26T10:04:31","slug":"c-core-guidelines-when-raii-breaks","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-when-raii-breaks\/","title":{"rendered":"C++ Core Guidelines: When RAII breaks"},"content":{"rendered":"

Before I write about the very popular RAII idiom in C++, I want to present you with a trick, which is often quite handy, when you repeatedly search for a text pattern:  use negative search.<\/p>\n

<\/p>\n

 \"sports<\/p>\n

Often, the text patterns or tokens, you are looking for, are following a repetitive structure. Here, the negative search comes into play.<\/p>\n

Use Negative Search if applicable<\/h2>\n

The general idea is easy to explain. You define a complicated regular expression to search for tokens. The tokens are often separated by delimiters such as colons, commas, spaces, and so on. In this case, it is easier to search for the delimiters, and the tokens you are interested in are just the text between the delimiters. Let’s see what I mean.<\/p>\n

 <\/p>\n

\n
\/\/ regexTokenIterator.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <regex><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::<\/span>vector<<\/span>std::<\/span>string><\/span> splitAt(const<\/span> std::<\/span>string &<\/span>text,                     \/\/ (6)<\/span>\r\n                                 const<\/span> std::<\/span>regex &<\/span>reg) {\r\n  std::<\/span>sregex_token_iterator hitIt(text.begin(), text.end(), reg, -<\/span>1<\/span>);\r\n  const<\/span> std::<\/span>sregex_token_iterator hitEnd;\r\n  std::<\/span>vector<<\/span>std::<\/span>string><\/span> resVec;\r\n  for<\/span> (; hitIt !=<\/span> hitEnd; ++<\/span>hitIt)\r\n    resVec.push_back(hitIt-><\/span>str());\r\n  return<\/span> resVec;\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  const<\/span> std::<\/span>string text(\"3,-1000,4.5,-10.5,5e10,2e-5\"<\/span>);                      \/\/ (1)<\/span>\r\n\r\n  const<\/span> std::<\/span>regex regNumber(\r\n      R\"([-+]?([0-9]+\\.?[0-9]*|\\.[0-9]+)([eE][-+]?[0-9]+)?)\"<\/span>);                \/\/ (2)<\/span>\r\n  std::<\/span>sregex_iterator numberIt(text.begin(), text.end(), regNumber);         \/\/ (3)<\/span>\r\n  const<\/span> std::<\/span>sregex_iterator numberEnd;\r\n  for<\/span> (; numberIt !=<\/span> numberEnd; ++<\/span>numberIt) {                        \r\n    std::<\/span>cout <<<\/span> numberIt-><\/span>str() <<<\/span> std::<\/span>endl;                                \/\/ (4)<\/span>\r\n  }\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  const<\/span> std::<\/span>regex regComma(\",\"<\/span>);\r\n  std::<\/span>sregex_token_iterator commaIt(text.begin(), text.end(), regComma, -<\/span>1<\/span>); \/\/ (5)<\/span>\r\n  const<\/span> std::<\/span>sregex_token_iterator commaEnd;\r\n  for<\/span> (; commaIt !=<\/span> commaEnd; ++<\/span>commaIt) {\r\n    std::<\/span>cout <<<\/span> commaIt-><\/span>str() <<<\/span> std::<\/span>endl;\r\n  }\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  std::<\/span>vector<<\/span>std::<\/span>string><\/span> resVec =<\/span> splitAt(text, regComma);                  \/\/ (7)<\/span>\r\n  for<\/span> (auto<\/span> s :<\/span> resVec)\r\n    std::<\/span>cout <<<\/span> s <<<\/span> \" \"<\/span>;\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n  resVec =<\/span> splitAt(\"abc5.4def-10.5hij2e-5klm\"<\/span>, regNumber);                    \/\/ (8)<\/span>\r\n  for<\/span> (auto<\/span> s :<\/span> resVec)\r\n    std::<\/span>cout <<<\/span> s <<<\/span> \" \"<\/span>;\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n  std::<\/span>regex regSpace(R\"(\\s+)\"<\/span>);\r\n  resVec =<\/span> splitAt(\"abc  123  456<\/span>\\t<\/span>789    def hij<\/span>\\n<\/span>klm\"<\/span>, regSpace);           \/\/ (9)<\/span>\r\n  for<\/span> (auto<\/span> s :<\/span> resVec)\r\n    std::<\/span>cout <<<\/span> s <<<\/span> \" \"<\/span>;\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Line 1 contains a string of numbers separated by commas. To get all numbers, I define in line 2 a regular expression which matches each number. All numbers include natural numbers, floating-point numbers, and numbers written in scientific notation. Line 3 defines the iterator of type std::sregex_iterato<\/span>r, which gives me all tokens and displays them in line 4. The std::regex_token_iterator<\/span> in line 5 is more powerful. It searches for commas and gives me the text between them because I used the negative index -1. <\/p>\n
This pattern is so convenient that I put it in the function splitAt<\/span> (line 6). splitAt<\/span> takes a text and a regular expression, applies the regular expression to the text, and pushes the text between the regular expression onto the std::vector<std::string> res<\/span>. Now, it’s pretty easy to split a text on commas (line 7), on numbers (line 8), and spaces (line 9).<\/p>\n
As Martin Stockmayer suggested, you can write the function splitAt<\/span> more concisely, because a std::vect<\/span>or can directly deal with a begin and an end iterator.<\/p>\n
<\/p>\n
\n
std::<\/span>vector<<\/span>std::<\/span>string><\/span> splitAt(const<\/span> std::<\/span>string &<\/span>text, \r\n                                 const<\/span> std::<\/span>regex &<\/span>reg) {\r\n  return<\/span> std::<\/span>vector<<\/span>std::<\/span>string><\/span>(std::<\/span>sregex_token_iterator(text.begin(), text.end(), reg, -<\/span>1<\/span>), \r\n                                  std::<\/span>sregex_token_iterator());\r\n}\r\n<\/pre>\n<\/div>\n
The output of the program shows the expected behavior:<\/p>\n
\"regexTokenIterator\"<\/p>\n
Okay, this was my last rule for the regular expression library, and I, therefore, finished the rules for the standard library of the C++ core guidelines. But hold, there is one rule to the C standard library.<\/p>\n<\/p>\n
SL.C.1: Don\u2019t use setjmp\/longjmp<\/a><\/h2>\n
The reason for this rule is relatively concise: a longjmp<\/code> <\/span>ignores destructors, thus invalidating all resource-management strategies relying on RAII. I hope you know RAII. If not, here is the gist. <\/p>\n
RAII stands for R<\/strong>esource A<\/strong>cquisition I<\/strong>s I<\/strong>nitialization. Probably, the most crucial idiom in C++ says that a resource should be acquired in the constructor and released in the destructor of the object. The key idea is that the destructor will automatically be called if the object goes out of scope.<\/p>\n
The following example shows the deterministic behavior of RAII in C++.<\/p>\n
 <\/p>\n
\n
\/\/ raii.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <new><\/span>\r\n#include <string><\/span>\r\n\r\nclass<\/span> ResourceGuard<\/span>{\r\n  private:<\/span>\r\n    const<\/span> std::<\/span>string resource;\r\n  public:<\/span>\r\n    ResourceGuard(const<\/span> std::<\/span>string&<\/span> res):<\/span>resource(res){\r\n      std::<\/span>cout <<<\/span> \"Acquire the \"<\/span> <<<\/span> resource <<<\/span> \".\"<\/span> <<<\/span>  std::<\/span>endl;\r\n    }\r\n    ~<\/span>ResourceGuard(){\r\n      std::<\/span>cout <<<\/span> \"Release the \"<\/span><<<\/span> resource <<<\/span> \".\"<\/span> <<<\/span> std::<\/span>endl;\r\n    }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  ResourceGuard resGuard1{\"memoryBlock1\"<\/span>};            \/\/ (1)<\/span>\r\n\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before local scope\"<\/span> <<<\/span> std::<\/span>endl;\r\n  {\r\n    ResourceGuard resGuard2{\"memoryBlock2\"<\/span>};          \/\/ (3)<\/span>\r\n  }                                                   \/\/ (4)<\/span>\r\n  std::<\/span>cout <<<\/span> \"After local scope\"<\/span> <<<\/span> std::<\/span>endl;\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n  \r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before try-catch block\"<\/span> <<<\/span> std::<\/span>endl;\r\n  try{\r\n      ResourceGuard resGuard3{\"memoryBlock3\"<\/span>};\r\n      throw<\/span> std::<\/span>bad_alloc();                        \/\/ (5)<\/span>           \r\n  }   \r\n  catch<\/span> (std::<\/span>bad_alloc&<\/span> e){                         \/\/ (6)<\/span>\r\n      std::<\/span>cout <<<\/span> e.what();\r\n  }\r\n  std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>After try-catch block\"<\/span> <<<\/span> std::<\/span>endl;\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}                                                     \/\/ (2)<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
ResourceGuard<\/span> is a guard that manages its resource. In this case, the string stands for the resource. ResourceGuard<\/span> creates in its constructor the resource and releases the resource in its destructor. It does its job very decent.<\/p>\n
The destructor of resGuard1<\/span> (line 1) is called at the end of the main<\/span> function (line 2). The lifetime of resGuard2<\/span> (line 3) already ends in line 4. Therefore, the destructor is automatically executed. Even throwing an exception does not affect the reliability of resGuard3<\/span> (line 5). The destructor is called at the end of the try<\/span> block (line 6).<\/p>\n
The screenshot shows the lifetimes of the objects.<\/p>\n
 \"raii\"<\/p>\n
I want to emphasize the critical idea of RAII: A resource’s lifetime is bound to a local variable’s lifetime, and C++ automatically manages the lifetime of locals.<\/strong><\/p>\n
Okay, but how can setjmp\/longjmp<\/span> break this automatism? Here is what the macro setjmp<\/span> and std::longjmp<\/span> does:<\/p>\n
int setjmp(std::jmp_buf env):<\/span><\/strong><\/p>\n