[{"data":1,"prerenderedAt":2476},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr57-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr57-cpp":1777,"sidebar-sei-cert-cpp-coding-standard":1783},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":27,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":25,"path":26},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":29,"title":30,"body":31,"description":1762,"extension":1763,"meta":1764,"navigation":7,"path":1773,"seo":1774,"stem":1775,"__hash__":1776},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F09.err57-cpp.md","ERR57-CPP. Do not leak resources when handling exceptions",{"type":32,"value":33,"toc":1747},"minimark",[34,38,58,66,72,80,83,94,99,111,373,381,390,573,579,596,600,608,733,736,769,911,917,927,1119,1123,1136,1288,1292,1299,1364,1368,1604,1608,1622,1626,1653,1657,1720,1723,1743],[35,36,30],"h1",{"id":37},"err57-cpp-do-not-leak-resources-when-handling-exceptions",[39,40,41,42,47,48,52,53,57],"p",{},"Reclaiming resources when exceptions are thrown is important. An exception being thrown may result in cleanup code being bypassed or an object being left in a partially initialized state. Such a partially initialized object would violate basic exception safety, as described in ",[43,44,46],"a",{"href":45},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr56-cpp","ERR56-CPP. Guarantee exception safety"," . It is preferable that resources be reclaimed automatically, using the ",[43,49,51],{"href":50},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-RAII","RAII"," design pattern [ ",[43,54,56],{"href":55},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Stroustrup01","Stroustrup 2001"," ], when objects go out of scope. This technique avoids the need to write complex cleanup code when allocating resources.",[39,59,60,61,65],{},"However, constructors do not offer the same protection. Because a constructor is involved in allocating resources, it does not automatically free any resources it allocates if it terminates prematurely. The C++ Standard, [except.ctor], paragraph 2 [ ",[43,62,64],{"href":63},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], states the following:",[67,68,69],"blockquote",{},[39,70,71],{},"An object of any storage duration whose initialization or destruction is terminated by an exception will have destructors executed for all of its fully constructed subobjects (excluding the variant members of a union-like class), that is, for subobjects for which the principal constructor (12.6.2) has completed execution and the destructor has not yet begun execution. Similarly, if the non-delegating constructor for an object has completed execution and a delegating constructor for that object exits with an exception, the object’s destructor will be invoked. If the object was allocated in a new-expression, the matching deallocation function (3.7.4.2, 5.3.4, 12.5), if any, is called to free the storage occupied by the object.",[39,73,74,75,79],{},"It is generally recommended that constructors that cannot complete their job should throw exceptions rather than exit normally and leave their object in an incomplete state [ ",[43,76,78],{"href":77},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Cline09","Cline 2009"," ].",[39,81,82],{},"Resources must not be leaked as a result of throwing an exception, including during the construction of an object.",[39,84,85],{},[86,87,88,89,93],"em",{},"This rule is a subset of ",[43,90,92],{"href":91},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem51-cpp","MEM51-CPP. Properly deallocate dynamically allocated resources"," , as all failures to deallocate resources violate that rule.",[95,96,98],"h2",{"id":97},"noncompliant-code-example","Noncompliant Code Example",[39,100,101,102,106,107,110],{},"In this noncompliant code example, ",[103,104,105],"code",{},"pst"," is not properly released when ",[103,108,109],{},"process_item"," throws an exception, causing a resource leak.",[112,113,115],"code-block",{"quality":114},"bad",[116,117,122],"pre",{"className":118,"code":119,"language":120,"meta":121,"style":121},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Cnew>\n \nstruct SomeType {\n  SomeType() noexcept; \u002F\u002F Performs nontrivial initialization.\n  ~SomeType(); \u002F\u002F Performs nontrivial finalization.\n  void process_item() noexcept(false);\n};\n \nvoid f() {\n  SomeType *pst = new (std::nothrow) SomeType();\n  if (!pst) {\n    \u002F\u002F Handle error\n    return;\n  }\n \n  try {\n    pst->process_item();\n  } catch (...) {\n    \u002F\u002F Process error, but do not recover from it; rethrow.\n    throw;\n  }\n  delete pst;\n}\n","cpp","",[103,123,124,137,144,158,178,190,213,219,224,236,269,283,289,298,304,309,317,327,339,345,353,358,367],{"__ignoreMap":121},[125,126,129,133],"span",{"class":127,"line":128},"line",1,[125,130,132],{"class":131},"sC2Qs","#include",[125,134,136],{"class":135},"sstjo"," \u003Cnew>\n",[125,138,140],{"class":127,"line":139},2,[125,141,143],{"class":142},"sMOD_"," \n",[125,145,147,151,155],{"class":127,"line":146},3,[125,148,150],{"class":149},"sq6CD","struct",[125,152,154],{"class":153},"sz2Vg"," SomeType",[125,156,157],{"class":142}," {\n",[125,159,161,165,168,171,174],{"class":127,"line":160},4,[125,162,164],{"class":163},"srTi1","  SomeType",[125,166,167],{"class":142},"() ",[125,169,170],{"class":131},"noexcept",[125,172,173],{"class":142},";",[125,175,177],{"class":176},"s8-w5"," \u002F\u002F Performs nontrivial initialization.\n",[125,179,181,184,187],{"class":127,"line":180},5,[125,182,183],{"class":163},"  ~SomeType",[125,185,186],{"class":142},"();",[125,188,189],{"class":176}," \u002F\u002F Performs nontrivial finalization.\n",[125,191,193,196,199,201,203,206,210],{"class":127,"line":192},6,[125,194,195],{"class":149},"  void",[125,197,198],{"class":163}," process_item",[125,200,167],{"class":142},[125,202,170],{"class":131},[125,204,205],{"class":142},"(",[125,207,209],{"class":208},"s7F3e","false",[125,211,212],{"class":142},");\n",[125,214,216],{"class":127,"line":215},7,[125,217,218],{"class":142},"};\n",[125,220,222],{"class":127,"line":221},8,[125,223,143],{"class":142},[125,225,227,230,233],{"class":127,"line":226},9,[125,228,229],{"class":149},"void",[125,231,232],{"class":163}," f",[125,234,235],{"class":142},"() {\n",[125,237,239,242,245,248,251,254,257,260,263,266],{"class":127,"line":238},10,[125,240,241],{"class":142},"  SomeType ",[125,243,244],{"class":131},"*",[125,246,247],{"class":142},"pst ",[125,249,250],{"class":131},"=",[125,252,253],{"class":131}," new",[125,255,256],{"class":142}," (",[125,258,259],{"class":153},"std",[125,261,262],{"class":142},"::nothrow) ",[125,264,265],{"class":163},"SomeType",[125,267,268],{"class":142},"();\n",[125,270,272,275,277,280],{"class":127,"line":271},11,[125,273,274],{"class":131},"  if",[125,276,256],{"class":142},[125,278,279],{"class":131},"!",[125,281,282],{"class":142},"pst) {\n",[125,284,286],{"class":127,"line":285},12,[125,287,288],{"class":176},"    \u002F\u002F Handle error\n",[125,290,292,295],{"class":127,"line":291},13,[125,293,294],{"class":131},"    return",[125,296,297],{"class":142},";\n",[125,299,301],{"class":127,"line":300},14,[125,302,303],{"class":142},"  }\n",[125,305,307],{"class":127,"line":306},15,[125,308,143],{"class":142},[125,310,312,315],{"class":127,"line":311},16,[125,313,314],{"class":131},"  try",[125,316,157],{"class":142},[125,318,320,323,325],{"class":127,"line":319},17,[125,321,322],{"class":142},"    pst->",[125,324,109],{"class":163},[125,326,268],{"class":142},[125,328,330,333,336],{"class":127,"line":329},18,[125,331,332],{"class":142},"  } ",[125,334,335],{"class":131},"catch",[125,337,338],{"class":142}," (...) {\n",[125,340,342],{"class":127,"line":341},19,[125,343,344],{"class":176},"    \u002F\u002F Process error, but do not recover from it; rethrow.\n",[125,346,348,351],{"class":127,"line":347},20,[125,349,350],{"class":131},"    throw",[125,352,297],{"class":142},[125,354,356],{"class":127,"line":355},21,[125,357,303],{"class":142},[125,359,361,364],{"class":127,"line":360},22,[125,362,363],{"class":131},"  delete",[125,365,366],{"class":142}," pst;\n",[125,368,370],{"class":127,"line":369},23,[125,371,372],{"class":142},"}\n",[95,374,376,377,380],{"id":375},"compliant-solution-delete","Compliant Solution ( ",[103,378,379],{},"delete"," )",[39,382,383,384,386,387],{},"In this compliant solution, the exception handler frees ",[103,385,105],{}," by calling ",[103,388,389],{},"delete.",[112,391,393],{"quality":392},"good",[116,394,396],{"className":118,"code":395,"language":120,"meta":121,"style":121},"#include \u003Cnew>\n\nstruct SomeType {\n  SomeType() noexcept; \u002F\u002F Performs nontrivial initialization.\n  ~SomeType(); \u002F\u002F Performs nontrivial finalization.\n\n  void process_item() noexcept(false);\n};\n\nvoid f() {\n  SomeType *pst = new (std::nothrow) SomeType();\n  if (!pst) {\n    \u002F\u002F Handle error\n    return;\n  }\n  try {\n    pst->process_item();\n  } catch (...) {\n    \u002F\u002F Process error, but do not recover from it; rethrow.\n    delete pst;\n    throw;\n  }\n  delete pst;\n}\n",[103,397,398,404,409,417,429,437,441,457,461,465,473,495,505,509,515,519,525,533,541,545,552,558,562,568],{"__ignoreMap":121},[125,399,400,402],{"class":127,"line":128},[125,401,132],{"class":131},[125,403,136],{"class":135},[125,405,406],{"class":127,"line":139},[125,407,408],{"emptyLinePlaceholder":7},"\n",[125,410,411,413,415],{"class":127,"line":146},[125,412,150],{"class":149},[125,414,154],{"class":153},[125,416,157],{"class":142},[125,418,419,421,423,425,427],{"class":127,"line":160},[125,420,164],{"class":163},[125,422,167],{"class":142},[125,424,170],{"class":131},[125,426,173],{"class":142},[125,428,177],{"class":176},[125,430,431,433,435],{"class":127,"line":180},[125,432,183],{"class":163},[125,434,186],{"class":142},[125,436,189],{"class":176},[125,438,439],{"class":127,"line":192},[125,440,408],{"emptyLinePlaceholder":7},[125,442,443,445,447,449,451,453,455],{"class":127,"line":215},[125,444,195],{"class":149},[125,446,198],{"class":163},[125,448,167],{"class":142},[125,450,170],{"class":131},[125,452,205],{"class":142},[125,454,209],{"class":208},[125,456,212],{"class":142},[125,458,459],{"class":127,"line":221},[125,460,218],{"class":142},[125,462,463],{"class":127,"line":226},[125,464,408],{"emptyLinePlaceholder":7},[125,466,467,469,471],{"class":127,"line":238},[125,468,229],{"class":149},[125,470,232],{"class":163},[125,472,235],{"class":142},[125,474,475,477,479,481,483,485,487,489,491,493],{"class":127,"line":271},[125,476,241],{"class":142},[125,478,244],{"class":131},[125,480,247],{"class":142},[125,482,250],{"class":131},[125,484,253],{"class":131},[125,486,256],{"class":142},[125,488,259],{"class":153},[125,490,262],{"class":142},[125,492,265],{"class":163},[125,494,268],{"class":142},[125,496,497,499,501,503],{"class":127,"line":285},[125,498,274],{"class":131},[125,500,256],{"class":142},[125,502,279],{"class":131},[125,504,282],{"class":142},[125,506,507],{"class":127,"line":291},[125,508,288],{"class":176},[125,510,511,513],{"class":127,"line":300},[125,512,294],{"class":131},[125,514,297],{"class":142},[125,516,517],{"class":127,"line":306},[125,518,303],{"class":142},[125,520,521,523],{"class":127,"line":311},[125,522,314],{"class":131},[125,524,157],{"class":142},[125,526,527,529,531],{"class":127,"line":319},[125,528,322],{"class":142},[125,530,109],{"class":163},[125,532,268],{"class":142},[125,534,535,537,539],{"class":127,"line":329},[125,536,332],{"class":142},[125,538,335],{"class":131},[125,540,338],{"class":142},[125,542,543],{"class":127,"line":341},[125,544,344],{"class":176},[125,546,547,550],{"class":127,"line":347},[125,548,549],{"class":131},"    delete",[125,551,366],{"class":142},[125,553,554,556],{"class":127,"line":355},[125,555,350],{"class":131},[125,557,297],{"class":142},[125,559,560],{"class":127,"line":360},[125,561,303],{"class":142},[125,563,564,566],{"class":127,"line":369},[125,565,363],{"class":131},[125,567,366],{"class":142},[125,569,571],{"class":127,"line":570},24,[125,572,372],{"class":142},[39,574,575,576,578],{},"While this compliant solution properly releases its resources using ",[103,577,335],{}," clauses, this approach can have some disadvantages:",[580,581,582,593],"ul",{},[583,584,585,586,589,590,592],"li",{},"Each distinct cleanup requires its own ",[103,587,588],{},"try"," and ",[103,591,335],{}," blocks.",[583,594,595],{},"The cleanup operation must not throw any exceptions.",[95,597,599],{"id":598},"compliant-solution-raii-design-pattern","Compliant Solution (RAII Design Pattern)",[39,601,602,603,607],{},"A better approach is to employ RAII. This pattern forces every object to clean up after itself in the face of abnormal behavior, preventing the programmer from having to do so. Another benefit of this approach is that it does not require statements to handle resource allocation errors, in conformance with ",[43,604,606],{"href":605},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem52-cpp","MEM52-CPP. Detect and handle memory allocation errors"," .",[112,609,610],{"quality":392},[116,611,613],{"className":118,"code":612,"language":120,"meta":121,"style":121},"struct SomeType {\n  SomeType() noexcept; \u002F\u002F Performs nontrivial initialization.\n  ~SomeType(); \u002F\u002F Performs nontrivial finalization.\n\n  void process_item() noexcept(false);\n};\n\nvoid f() {\n  SomeType st;\n  try {\n    st.process_item();\n  } catch (...) {\n    \u002F\u002F Process error, but do not recover from it; rethrow.\n    throw;\n  } \u002F\u002F After re-throwing the exception, the destructor is run for st.\n} \u002F\u002F If f() exits without throwing an exception, the destructor is run for st.\n",[103,614,615,623,635,643,647,663,667,671,679,684,690,699,707,711,717,725],{"__ignoreMap":121},[125,616,617,619,621],{"class":127,"line":128},[125,618,150],{"class":149},[125,620,154],{"class":153},[125,622,157],{"class":142},[125,624,625,627,629,631,633],{"class":127,"line":139},[125,626,164],{"class":163},[125,628,167],{"class":142},[125,630,170],{"class":131},[125,632,173],{"class":142},[125,634,177],{"class":176},[125,636,637,639,641],{"class":127,"line":146},[125,638,183],{"class":163},[125,640,186],{"class":142},[125,642,189],{"class":176},[125,644,645],{"class":127,"line":160},[125,646,408],{"emptyLinePlaceholder":7},[125,648,649,651,653,655,657,659,661],{"class":127,"line":180},[125,650,195],{"class":149},[125,652,198],{"class":163},[125,654,167],{"class":142},[125,656,170],{"class":131},[125,658,205],{"class":142},[125,660,209],{"class":208},[125,662,212],{"class":142},[125,664,665],{"class":127,"line":192},[125,666,218],{"class":142},[125,668,669],{"class":127,"line":215},[125,670,408],{"emptyLinePlaceholder":7},[125,672,673,675,677],{"class":127,"line":221},[125,674,229],{"class":149},[125,676,232],{"class":163},[125,678,235],{"class":142},[125,680,681],{"class":127,"line":226},[125,682,683],{"class":142},"  SomeType st;\n",[125,685,686,688],{"class":127,"line":238},[125,687,314],{"class":131},[125,689,157],{"class":142},[125,691,692,695,697],{"class":127,"line":271},[125,693,694],{"class":142},"    st.",[125,696,109],{"class":163},[125,698,268],{"class":142},[125,700,701,703,705],{"class":127,"line":285},[125,702,332],{"class":142},[125,704,335],{"class":131},[125,706,338],{"class":142},[125,708,709],{"class":127,"line":291},[125,710,344],{"class":176},[125,712,713,715],{"class":127,"line":300},[125,714,350],{"class":131},[125,716,297],{"class":142},[125,718,719,722],{"class":127,"line":306},[125,720,721],{"class":142},"  }",[125,723,724],{"class":176}," \u002F\u002F After re-throwing the exception, the destructor is run for st.\n",[125,726,727,730],{"class":127,"line":311},[125,728,729],{"class":142},"}",[125,731,732],{"class":176}," \u002F\u002F If f() exits without throwing an exception, the destructor is run for st.\n",[95,734,98],{"id":735},"noncompliant-code-example-1",[39,737,738,739,742,743,745,746,749,750,753,754,756,757,759,760,762,763,765,766,768],{},"In this noncompliant code example, the ",[103,740,741],{},"C::C()"," constructor might fail to allocate memory for ",[103,744,43],{}," , might fail to allocate memory for ",[103,747,748],{},"b"," , or might throw an exception in the ",[103,751,752],{},"init()"," method. If ",[103,755,752],{}," throws an exception, neither ",[103,758,43],{}," nor ",[103,761,748],{}," will be released. Likewise, if the allocation for ",[103,764,748],{}," fails, ",[103,767,43],{}," will not be released.",[112,770,771],{"quality":114},[116,772,774],{"className":118,"code":773,"language":120,"meta":121,"style":121},"struct A {\u002F* ... *\u002F};\nstruct B {\u002F* ... *\u002F};\n\nclass C {\n  A *a;\n  B *b;\nprotected:\n  void init() noexcept(false);\npublic:\n  C() : a(new A()), b(new B()) {\n    init();\n  }\n};\n",[103,775,776,791,804,808,818,828,838,843,860,865,896,903,907],{"__ignoreMap":121},[125,777,778,780,783,786,789],{"class":127,"line":128},[125,779,150],{"class":149},[125,781,782],{"class":153}," A",[125,784,785],{"class":142}," {",[125,787,788],{"class":176},"\u002F* ... *\u002F",[125,790,218],{"class":142},[125,792,793,795,798,800,802],{"class":127,"line":139},[125,794,150],{"class":149},[125,796,797],{"class":153}," B",[125,799,785],{"class":142},[125,801,788],{"class":176},[125,803,218],{"class":142},[125,805,806],{"class":127,"line":146},[125,807,408],{"emptyLinePlaceholder":7},[125,809,810,813,816],{"class":127,"line":160},[125,811,812],{"class":149},"class",[125,814,815],{"class":153}," C",[125,817,157],{"class":142},[125,819,820,823,825],{"class":127,"line":180},[125,821,822],{"class":142},"  A ",[125,824,244],{"class":131},[125,826,827],{"class":142},"a;\n",[125,829,830,833,835],{"class":127,"line":192},[125,831,832],{"class":142},"  B ",[125,834,244],{"class":131},[125,836,837],{"class":142},"b;\n",[125,839,840],{"class":127,"line":215},[125,841,842],{"class":149},"protected:\n",[125,844,845,847,850,852,854,856,858],{"class":127,"line":221},[125,846,195],{"class":149},[125,848,849],{"class":163}," init",[125,851,167],{"class":142},[125,853,170],{"class":131},[125,855,205],{"class":142},[125,857,209],{"class":208},[125,859,212],{"class":142},[125,861,862],{"class":127,"line":226},[125,863,864],{"class":149},"public:\n",[125,866,867,870,873,875,877,880,882,885,887,889,891,893],{"class":127,"line":238},[125,868,869],{"class":163},"  C",[125,871,872],{"class":142},"() : ",[125,874,43],{"class":163},[125,876,205],{"class":142},[125,878,879],{"class":131},"new",[125,881,782],{"class":163},[125,883,884],{"class":142},"()), ",[125,886,748],{"class":163},[125,888,205],{"class":142},[125,890,879],{"class":131},[125,892,797],{"class":163},[125,894,895],{"class":142},"()) {\n",[125,897,898,901],{"class":127,"line":271},[125,899,900],{"class":163},"    init",[125,902,268],{"class":142},[125,904,905],{"class":127,"line":285},[125,906,303],{"class":142},[125,908,909],{"class":127,"line":291},[125,910,218],{"class":142},[95,912,376,914,380],{"id":913},"compliant-solution-trycatch",[103,915,916],{},"try\u002Fcatch",[39,918,919,920,589,922,924,925,607],{},"This compliant solution mitigates the potential failures by releasing ",[103,921,43],{},[103,923,748],{}," if an exception is thrown during their allocation or during ",[103,926,752],{},[112,928,929],{"quality":392},[116,930,932],{"className":118,"code":931,"language":120,"meta":121,"style":121},"struct A {\u002F* ... *\u002F};\nstruct B {\u002F* ... *\u002F};\n \nclass C {\n  A *a;\n  B *b;\nprotected:\n  void init() noexcept(false);\npublic:\n  C() : a(nullptr), b(nullptr) {\n    try {\n      a = new A();\n      b = new B();\n      init();\n    } catch (...) {\n      delete a;\n      delete b;\n      throw;\n    }\n  }\n};\n",[103,933,934,946,958,962,970,978,986,990,1006,1010,1035,1042,1055,1068,1075,1084,1092,1099,1106,1111,1115],{"__ignoreMap":121},[125,935,936,938,940,942,944],{"class":127,"line":128},[125,937,150],{"class":149},[125,939,782],{"class":153},[125,941,785],{"class":142},[125,943,788],{"class":176},[125,945,218],{"class":142},[125,947,948,950,952,954,956],{"class":127,"line":139},[125,949,150],{"class":149},[125,951,797],{"class":153},[125,953,785],{"class":142},[125,955,788],{"class":176},[125,957,218],{"class":142},[125,959,960],{"class":127,"line":146},[125,961,143],{"class":142},[125,963,964,966,968],{"class":127,"line":160},[125,965,812],{"class":149},[125,967,815],{"class":153},[125,969,157],{"class":142},[125,971,972,974,976],{"class":127,"line":180},[125,973,822],{"class":142},[125,975,244],{"class":131},[125,977,827],{"class":142},[125,979,980,982,984],{"class":127,"line":192},[125,981,832],{"class":142},[125,983,244],{"class":131},[125,985,837],{"class":142},[125,987,988],{"class":127,"line":215},[125,989,842],{"class":149},[125,991,992,994,996,998,1000,1002,1004],{"class":127,"line":221},[125,993,195],{"class":149},[125,995,849],{"class":163},[125,997,167],{"class":142},[125,999,170],{"class":131},[125,1001,205],{"class":142},[125,1003,209],{"class":208},[125,1005,212],{"class":142},[125,1007,1008],{"class":127,"line":226},[125,1009,864],{"class":149},[125,1011,1012,1014,1016,1018,1020,1023,1026,1028,1030,1032],{"class":127,"line":238},[125,1013,869],{"class":163},[125,1015,872],{"class":142},[125,1017,43],{"class":163},[125,1019,205],{"class":142},[125,1021,1022],{"class":208},"nullptr",[125,1024,1025],{"class":142},"), ",[125,1027,748],{"class":163},[125,1029,205],{"class":142},[125,1031,1022],{"class":208},[125,1033,1034],{"class":142},") {\n",[125,1036,1037,1040],{"class":127,"line":271},[125,1038,1039],{"class":131},"    try",[125,1041,157],{"class":142},[125,1043,1044,1047,1049,1051,1053],{"class":127,"line":285},[125,1045,1046],{"class":142},"      a ",[125,1048,250],{"class":131},[125,1050,253],{"class":131},[125,1052,782],{"class":163},[125,1054,268],{"class":142},[125,1056,1057,1060,1062,1064,1066],{"class":127,"line":291},[125,1058,1059],{"class":142},"      b ",[125,1061,250],{"class":131},[125,1063,253],{"class":131},[125,1065,797],{"class":163},[125,1067,268],{"class":142},[125,1069,1070,1073],{"class":127,"line":300},[125,1071,1072],{"class":163},"      init",[125,1074,268],{"class":142},[125,1076,1077,1080,1082],{"class":127,"line":306},[125,1078,1079],{"class":142},"    } ",[125,1081,335],{"class":131},[125,1083,338],{"class":142},[125,1085,1086,1089],{"class":127,"line":311},[125,1087,1088],{"class":131},"      delete",[125,1090,1091],{"class":142}," a;\n",[125,1093,1094,1096],{"class":127,"line":319},[125,1095,1088],{"class":131},[125,1097,1098],{"class":142}," b;\n",[125,1100,1101,1104],{"class":127,"line":329},[125,1102,1103],{"class":131},"      throw",[125,1105,297],{"class":142},[125,1107,1108],{"class":127,"line":341},[125,1109,1110],{"class":142},"    }\n",[125,1112,1113],{"class":127,"line":347},[125,1114,303],{"class":142},[125,1116,1117],{"class":127,"line":355},[125,1118,218],{"class":142},[95,1120,1122],{"id":1121},"compliant-solution-stdunique_ptr","Compliant Solution ( std::unique_ptr )",[39,1124,1125,1126,1129,1130,1132,1133,1135],{},"This compliant solution uses ",[103,1127,1128],{},"std::unique_ptr"," to create objects that clean up after themselves should anything go wrong in the ",[103,1131,741],{}," constructor. The ",[103,1134,1128],{}," applies the principles of RAII to pointers.",[112,1137,1138],{"quality":392},[116,1139,1141],{"className":118,"code":1140,"language":120,"meta":121,"style":121},"#include \u003Cmemory>\n \nstruct A {\u002F* ... *\u002F};\nstruct B {\u002F* ... *\u002F};\n\nclass C {\n  std::unique_ptr\u003CA> a;\n  std::unique_ptr\u003CB> b;\nprotected:\n  void init() noexcept(false);\npublic:\n  C() : a(new A()), b(new B()) {\n    init();\n  }\n};\n",[103,1142,1143,1150,1154,1166,1178,1182,1190,1209,1224,1228,1244,1248,1274,1280,1284],{"__ignoreMap":121},[125,1144,1145,1147],{"class":127,"line":128},[125,1146,132],{"class":131},[125,1148,1149],{"class":135}," \u003Cmemory>\n",[125,1151,1152],{"class":127,"line":139},[125,1153,143],{"class":142},[125,1155,1156,1158,1160,1162,1164],{"class":127,"line":146},[125,1157,150],{"class":149},[125,1159,782],{"class":153},[125,1161,785],{"class":142},[125,1163,788],{"class":176},[125,1165,218],{"class":142},[125,1167,1168,1170,1172,1174,1176],{"class":127,"line":160},[125,1169,150],{"class":149},[125,1171,797],{"class":153},[125,1173,785],{"class":142},[125,1175,788],{"class":176},[125,1177,218],{"class":142},[125,1179,1180],{"class":127,"line":180},[125,1181,408],{"emptyLinePlaceholder":7},[125,1183,1184,1186,1188],{"class":127,"line":192},[125,1185,812],{"class":149},[125,1187,815],{"class":153},[125,1189,157],{"class":142},[125,1191,1192,1195,1198,1201,1204,1207],{"class":127,"line":215},[125,1193,1194],{"class":153},"  std",[125,1196,1197],{"class":142},"::unique_ptr",[125,1199,1200],{"class":131},"\u003C",[125,1202,1203],{"class":142},"A",[125,1205,1206],{"class":131},">",[125,1208,1091],{"class":142},[125,1210,1211,1213,1215,1217,1220,1222],{"class":127,"line":221},[125,1212,1194],{"class":153},[125,1214,1197],{"class":142},[125,1216,1200],{"class":131},[125,1218,1219],{"class":142},"B",[125,1221,1206],{"class":131},[125,1223,1098],{"class":142},[125,1225,1226],{"class":127,"line":226},[125,1227,842],{"class":149},[125,1229,1230,1232,1234,1236,1238,1240,1242],{"class":127,"line":238},[125,1231,195],{"class":149},[125,1233,849],{"class":163},[125,1235,167],{"class":142},[125,1237,170],{"class":131},[125,1239,205],{"class":142},[125,1241,209],{"class":208},[125,1243,212],{"class":142},[125,1245,1246],{"class":127,"line":271},[125,1247,864],{"class":149},[125,1249,1250,1252,1254,1256,1258,1260,1262,1264,1266,1268,1270,1272],{"class":127,"line":285},[125,1251,869],{"class":163},[125,1253,872],{"class":142},[125,1255,43],{"class":163},[125,1257,205],{"class":142},[125,1259,879],{"class":131},[125,1261,782],{"class":163},[125,1263,884],{"class":142},[125,1265,748],{"class":163},[125,1267,205],{"class":142},[125,1269,879],{"class":131},[125,1271,797],{"class":163},[125,1273,895],{"class":142},[125,1275,1276,1278],{"class":127,"line":291},[125,1277,900],{"class":163},[125,1279,268],{"class":142},[125,1281,1282],{"class":127,"line":300},[125,1283,303],{"class":142},[125,1285,1286],{"class":127,"line":306},[125,1287,218],{"class":142},[95,1289,1291],{"id":1290},"risk-assessment","Risk Assessment",[39,1293,1294,1295,607],{},"Memory and other resource leaks will eventually cause a program to crash. If an attacker can provoke repeated resource leaks by forcing an exception to be thrown through the submission of suitably crafted data, then the attacker can mount a ",[43,1296,1298],{"href":1297},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","denial-of-service attack",[1300,1301,1302,1303,1302,1333],"table",{},"\n  ",[1304,1305,1306,1307,1302],"thead",{},"\n    ",[1308,1309,1310,1311,1310,1315,1310,1318,1310,1321,1310,1324,1310,1327,1310,1330,1306],"tr",{},"\n      ",[1312,1313,1314],"th",{},"Rule",[1312,1316,1317],{},"Severity",[1312,1319,1320],{},"Likelihood",[1312,1322,1323],{},"Detectable",[1312,1325,1326],{},"Repairable",[1312,1328,1329],{},"Priority",[1312,1331,1332],{},"Level",[1334,1335,1306,1336,1302],"tbody",{},[1308,1337,1310,1338,1310,1342,1310,1345,1310,1348,1310,1351,1310,1353,1310,1359,1306],{},[1339,1340,1341],"td",{},"ERR57-CPP",[1339,1343,1344],{},"Low",[1339,1346,1347],{},"Probable",[1339,1349,1350],{},"No",[1339,1352,1350],{},[1339,1354,1356],{"style":1355},"color: #27ae60;",[748,1357,1358],{},"P2",[1339,1360,1361],{"style":1355},[748,1362,1363],{},"L3",[95,1365,1367],{"id":1366},"automated-detection","Automated Detection",[1300,1369,1372],{"className":1370},[1371],"wrapped",[1334,1373,1374,1398,1427,1457,1507,1539,1565],{},[1308,1375,1378,1383,1388,1393],{"className":1376},[1377],"header",[1312,1379,1380],{},[39,1381,1382],{},"Tool",[1312,1384,1385],{},[39,1386,1387],{},"Version",[1312,1389,1390],{},[39,1391,1392],{},"Checker",[1312,1394,1395],{},[39,1396,1397],{},"Description",[1308,1399,1402,1408,1416,1424],{"className":1400},[1401],"odd",[1339,1403,1404],{},[43,1405,1407],{"href":1406},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[1339,1409,1410],{},[1411,1412,1415],"div",{"className":1413},[1414],"content-wrapper","9.1p0",[1339,1417,1418],{},[39,1419,1420],{},[1421,1422,1423],"strong",{},"ALLOC.LEAK",[1339,1425,1426],{},"Leak",[1308,1428,1431,1437,1445,1452],{"className":1429},[1430],"even",[1339,1432,1433],{},[43,1434,1436],{"href":1435},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[1339,1438,1439],{},[1411,1440,1442],{"className":1441},[1414],[39,1443,1444],{},"2025.2",[1339,1446,1447],{},[39,1448,1449],{},[1421,1450,1451],{},"DF4756, DF4757, DF4758",[1339,1453,1454],{},[1455,1456],"br",{},[1308,1458,1460,1466,1471,1503],{"className":1459},[1401],[1339,1461,1462],{},[43,1463,1465],{"href":1464},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","Klocwork",[1339,1467,1468],{},[1411,1469,1444],{"className":1470},[1414],[1339,1472,1473],{},[39,1474,1475,1478,1480,1483,1485,1488,1490,1493,1495,1498,1500],{},[1421,1476,1477],{},"CL.MLK",[1455,1479],{},[1421,1481,1482],{},"MLK.MIGHT",[1455,1484],{},[1421,1486,1487],{},"MLK.MUST",[1455,1489],{},[1421,1491,1492],{},"MLK.RET.MIGHT",[1455,1494],{},[1421,1496,1497],{},"MLK.RET.MUST",[1455,1499],{},[1421,1501,1502],{},"RH.LEAK",[1339,1504,1505],{},[1455,1506],{},[1308,1508,1510,1516,1522,1534],{"className":1509},[1430],[1339,1511,1512],{},[43,1513,1515],{"href":1514},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","LDRA tool suite",[1339,1517,1518],{},[1411,1519,1521],{"className":1520},[1414],"9.7.1",[1339,1523,1524],{},[39,1525,1526,1529,1530],{},[1421,1527,1528],{},"50 D"," ",[1421,1531,1532],{},[1455,1533],{},[1339,1535,1536],{},[39,1537,1538],{},"Partially implemented",[1308,1540,1542,1548,1553,1560],{"className":1541},[1401],[1339,1543,1544],{},[43,1545,1547],{"href":1546},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1339,1549,1550],{},[1411,1551,1444],{"className":1552},[1414],[1339,1554,1555],{},[39,1556,1557],{},[1421,1558,1559],{},"CERT_CPP-ERR57-a",[1339,1561,1562],{},[39,1563,1564],{},"Ensure resources are freed",[1308,1566,1568,1574,1582,1588],{"className":1567},[1430],[1339,1569,1570],{},[43,1571,1573],{"href":1572},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1339,1575,1576],{},[1411,1577,1579],{"className":1578},[1414],[39,1580,1581],{},"R2025b",[1339,1583,1584],{},[43,1585,1587],{"href":1586},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcerr57cpp.html","CERT C++: ERR57-CPP",[1339,1589,1590,1593],{},[39,1591,1592],{},"Checks for:",[580,1594,1595,1598,1601],{},[583,1596,1597],{},"Resource leak caused by exception",[583,1599,1600],{},"Object left in partially initialized state",[583,1602,1603],{},"Bad allocation in constructor",[95,1605,1607],{"id":1606},"related-vulnerabilities","Related Vulnerabilities",[39,1609,1610,1611,1615,1616,607],{},"Search for ",[43,1612,1614],{"href":1613},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerabi","vulnerabilities"," resulting from the violation of this rule on the ",[43,1617,1621],{"href":1618,"rel":1619},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+ERR57-CPP",[1620],"nofollow","CERT website",[95,1623,1625],{"id":1624},"related-guidelines","Related Guidelines",[1300,1627,1629],{"className":1628},[1371],[1334,1630,1631],{},[1308,1632,1634,1639],{"className":1633},[1401],[1339,1635,1636],{},[43,1637,1638],{"href":20},"SEI CERT C++ Coding Standard",[1339,1640,1641],{},[39,1642,1643,1529,1647,1529,1651],{},[43,1644,92,1645],{"href":605},[1455,1646],{},[43,1648,606,1649],{"href":605},[1455,1650],{},[43,1652,46],{"href":45},[95,1654,1656],{"id":1655},"bibliography","Bibliography",[1300,1658,1660,1669],{"className":1659},[1371],[1661,1662,1663,1667],"colgroup",{},[1664,1665],"col",{"style":1666},"width: 50%",[1664,1668],{"style":1666},[1334,1670,1671,1688,1698,1710],{},[1308,1672,1674,1680],{"className":1673},[1401],[1339,1675,1676,1677,1679],{},"[ ",[43,1678,78],{"href":77}," ]",[1339,1681,1682],{},[39,1683,1684,1685,1687],{},"Question 17.2, I'm still not convinced: A 4-line code snippet shows that return-codes aren't any worse than exceptions;",[1455,1686],{},"\nwhy should I therefore use exceptions on an application that is orders of magnitude larger?",[1308,1689,1691,1695],{"className":1690},[1430],[1339,1692,1676,1693,1679],{},[43,1694,64],{"href":63},[1339,1696,1697],{},"Subclause 15.2, \"Constructors and Destructors\"",[1308,1699,1701,1707],{"className":1700},[1401],[1339,1702,1676,1703,1679],{},[43,1704,1706],{"href":1705},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Meyers96","Meyers 1996",[1339,1708,1709],{},"Item 9, \"Use Destructors to Prevent Resource Leaks\"",[1308,1711,1713,1717],{"className":1712},[1430],[1339,1714,1676,1715,1679],{},[43,1716,56],{"href":55},[1339,1718,1719],{},"\"Exception-Safe Implementation Techniques\"",[1721,1722],"hr",{},[39,1724,1725,1529,1731,1529,1737],{},[43,1726,1727],{"href":45},[1728,1729],"img",{"src":1730},"\u002Fattachments\u002F88046682\u002F88480621.png",[43,1732,1734],{"href":1733},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002F",[1728,1735],{"src":1736},"\u002Fattachments\u002F88046682\u002F88475556.png",[43,1738,1740],{"href":1739},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr58-cpp",[1728,1741],{"src":1742},"\u002Fattachments\u002F88046682\u002F88475555.png",[1744,1745,1746],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sz2Vg, html code.shiki .sz2Vg{--shiki-default:#6F42C1;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-text-decoration:underline}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":121,"searchDepth":139,"depth":139,"links":1748},[1749,1750,1752,1753,1754,1756,1757,1758,1759,1760,1761],{"id":97,"depth":139,"text":98},{"id":375,"depth":139,"text":1751},"Compliant Solution ( delete )",{"id":598,"depth":139,"text":599},{"id":735,"depth":139,"text":98},{"id":913,"depth":139,"text":1755},"Compliant Solution ( try\u002Fcatch )",{"id":1121,"depth":139,"text":1122},{"id":1290,"depth":139,"text":1291},{"id":1366,"depth":139,"text":1367},{"id":1606,"depth":139,"text":1607},{"id":1624,"depth":139,"text":1625},{"id":1655,"depth":139,"text":1656},"Reclaiming resources when exceptions are thrown is important. An exception being thrown may result in cleanup code being bypassed or an object being left in a partially initialized state. Such a partially initialized object would violate basic exception safety, as described in ERR56-CPP. Guarantee exception safety . It is preferable that resources be reclaimed automatically, using the RAII design pattern [ Stroustrup 2001 ], when objects go out of scope. This technique avoids the need to write complex cleanup code when allocating resources.","md",{"tags":1765},[1766,1767,1768,1769,1770,1771,1772],"review","ptc","review-dms","rule","err","notes","review-ajb","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr57-cpp",{"title":30,"description":1762},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F09.err57-cpp","r6gLJPBHR3yZXcho_U-43p1GGAOoHK-xmAKSwdesAik",[1778,1780],{"title":46,"path":45,"stem":1779,"children":-1},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F08.err56-cpp",{"title":1781,"path":1739,"stem":1782,"children":-1},"ERR58-CPP. Handle all exceptions thrown before main() begins executing","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F10.err58-cpp",[1784],{"title":1638,"path":1785,"stem":1786,"children":1787},"\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[1788,1789,1856,2247,2462,2472],{"title":1638,"path":1785,"stem":1786},{"title":1790,"path":1791,"stem":1792,"children":1793},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[1794,1795],{"title":1790,"path":1791,"stem":1792},{"title":1796,"path":1797,"stem":1798,"children":1799},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[1800,1801,1805,1809,1813,1817,1821,1825,1829,1833,1837,1841,1845,1849,1853],{"title":1796,"path":1797,"stem":1798},{"title":1802,"path":1803,"stem":1804},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":1806,"path":1807,"stem":1808},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":1810,"path":1811,"stem":1812},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":1814,"path":1815,"stem":1816},"How this Coding Standard Is Organized","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F05.how-this-coding-standard-is-organized",{"title":1818,"path":1819,"stem":1820},"Relation to the CERT C Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frelation-to-the-cert-c-coding-standard","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F06.relation-to-the-cert-c-coding-standard",{"title":1822,"path":1823,"stem":1824},"Rules Versus Recommendations","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frules-versus-recommendations","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F07.rules-versus-recommendations",{"title":1826,"path":1827,"stem":1828},"Tool Selection and Validation","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftool-selection-and-validation","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F08.tool-selection-and-validation",{"title":1830,"path":1831,"stem":1832},"Conformance Testing","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fconformance-testing","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F09.conformance-testing",{"title":1834,"path":1835,"stem":1836},"Development Process","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fdevelopment-process","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F10.development-process",{"title":1838,"path":1839,"stem":1840},"System Qualities","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fsystem-qualities","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F11.system-qualities",{"title":1842,"path":1843,"stem":1844},"Automatically Generated Code","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomatically-generated-code","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F12.automatically-generated-code",{"title":1846,"path":1847,"stem":1848},"Government Regulations","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fgovernment-regulations","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F13.government-regulations",{"title":1850,"path":1851,"stem":1852},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":1367,"path":1854,"stem":1855},"\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomated-detection","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F15.automated-detection",{"title":1857,"path":1858,"stem":1859,"children":1860},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[1861,1862,1884,1918,1960,2010,2059,2121,2135,2145,2179,2205],{"title":1857,"path":1858,"stem":1859},{"title":1863,"path":1864,"stem":1865,"children":1866},"Characters and Strings (STR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F1.index",[1867,1868,1872,1876,1880],{"title":1863,"path":1864,"stem":1865},{"title":1869,"path":1870,"stem":1871},"STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F2.str50-cpp",{"title":1873,"path":1874,"stem":1875},"STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F3.str52-cpp",{"title":1877,"path":1878,"stem":1879},"STR53-CPP. Range check element access","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F4.str53-cpp",{"title":1881,"path":1882,"stem":1883},"string from a null pointer","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstring-from-a-null-pointer","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F5.string-from-a-null-pointer",{"title":1885,"path":1886,"stem":1887,"children":1888},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[1889,1890,1894,1898,1902,1906,1910,1914],{"title":1885,"path":1886,"stem":1887},{"title":1891,"path":1892,"stem":1893},"CON50-CPP. Do not destroy a mutex while it is locked","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F2.con50-cpp",{"title":1895,"path":1896,"stem":1897},"CON51-CPP. Ensure actively held locks are released on exceptional conditions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F3.con51-cpp",{"title":1899,"path":1900,"stem":1901},"CON52-CPP. Prevent data races when accessing bit-fields from multiple threads","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F4.con52-cpp",{"title":1903,"path":1904,"stem":1905},"CON53-CPP. Avoid deadlock by locking in a predefined order","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F5.con53-cpp",{"title":1907,"path":1908,"stem":1909},"CON54-CPP. Wrap functions that can spuriously wake up in a loop","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F6.con54-cpp",{"title":1911,"path":1912,"stem":1913},"CON55-CPP. Preserve thread safety and liveness when using condition variables","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F7.con55-cpp",{"title":1915,"path":1916,"stem":1917},"CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F8.con56-cpp",{"title":1919,"path":1920,"stem":1921,"children":1922},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[1923,1924,1928,1932,1936,1940,1944,1948,1952,1956],{"title":1919,"path":1920,"stem":1921},{"title":1925,"path":1926,"stem":1927},"CTR50-CPP. Guarantee that container indices and iterators are within the valid range","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F02.ctr50-cpp",{"title":1929,"path":1930,"stem":1931},"CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F03.ctr51-cpp",{"title":1933,"path":1934,"stem":1935},"CTR52-CPP. Guarantee that library functions do not overflow","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F04.ctr52-cpp",{"title":1937,"path":1938,"stem":1939},"CTR53-CPP. Use valid iterator ranges","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F05.ctr53-cpp",{"title":1941,"path":1942,"stem":1943},"CTR54-CPP. Do not subtract iterators that do not refer to the same container","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F06.ctr54-cpp",{"title":1945,"path":1946,"stem":1947},"CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F07.ctr55-cpp",{"title":1949,"path":1950,"stem":1951},"CTR56-CPP. Do not use pointer arithmetic on polymorphic objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F08.ctr56-cpp",{"title":1953,"path":1954,"stem":1955},"CTR57-CPP. Provide a valid ordering predicate","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F09.ctr57-cpp",{"title":1957,"path":1958,"stem":1959},"CTR58-CPP. Predicate function objects should not be mutable","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F10.ctr58-cpp",{"title":1961,"path":1962,"stem":1963,"children":1964},"Declarations and Initialization (DCL)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F01.index",[1965,1966,1970,1974,1978,1982,1986,1990,1994,1998,2002,2006],{"title":1961,"path":1962,"stem":1963},{"title":1967,"path":1968,"stem":1969},"DCL50-CPP. Do not define a C-style variadic function","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F02.dcl50-cpp",{"title":1971,"path":1972,"stem":1973},"DCL51-CPP. Do not declare or define a reserved identifier","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F03.dcl51-cpp",{"title":1975,"path":1976,"stem":1977},"DCL52-CPP. Never qualify a reference type with const or volatile","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F04.dcl52-cpp",{"title":1979,"path":1980,"stem":1981},"DCL53-CPP. Do not write syntactically ambiguous declarations","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F05.dcl53-cpp",{"title":1983,"path":1984,"stem":1985},"DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F06.dcl54-cpp",{"title":1987,"path":1988,"stem":1989},"DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F07.dcl55-cpp",{"title":1991,"path":1992,"stem":1993},"DCL56-CPP. Avoid cycles during initialization of static objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F08.dcl56-cpp",{"title":1995,"path":1996,"stem":1997},"DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F09.dcl57-cpp",{"title":1999,"path":2000,"stem":2001},"DCL58-CPP. Do not modify the standard namespaces","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F10.dcl58-cpp",{"title":2003,"path":2004,"stem":2005},"DCL59-CPP. Do not define an unnamed namespace in a header file","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F11.dcl59-cpp",{"title":2007,"path":2008,"stem":2009},"DCL60-CPP. Obey the one-definition rule","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F12.dcl60-cpp",{"title":2011,"path":2012,"stem":2013,"children":2014},"Exceptions and Error Handling (ERR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F01.index",[2015,2016,2020,2024,2028,2032,2036,2040,2041,2042,2043,2047,2051,2055],{"title":2011,"path":2012,"stem":2013},{"title":2017,"path":2018,"stem":2019},"ERR50-CPP. Do not abruptly terminate the program","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F02.err50-cpp",{"title":2021,"path":2022,"stem":2023},"ERR51-CPP. Handle all exceptions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F03.err51-cpp",{"title":2025,"path":2026,"stem":2027},"ERR52-CPP. Do not use setjmp() or longjmp()","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F04.err52-cpp",{"title":2029,"path":2030,"stem":2031},"ERR53-CPP. Do not reference base classes or class data members in a constructor or destructor function-try-block handler","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F05.err53-cpp",{"title":2033,"path":2034,"stem":2035},"ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F06.err54-cpp",{"title":2037,"path":2038,"stem":2039},"ERR55-CPP. Honor exception specifications","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F07.err55-cpp",{"title":46,"path":45,"stem":1779},{"title":30,"path":1773,"stem":1775},{"title":1781,"path":1739,"stem":1782},{"title":2044,"path":2045,"stem":2046},"ERR59-CPP. Do not throw an exception across execution boundaries","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F11.err59-cpp",{"title":2048,"path":2049,"stem":2050},"ERR60-CPP. Exception objects must be nothrow copy constructible","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F12.err60-cpp",{"title":2052,"path":2053,"stem":2054},"ERR61-CPP. Catch exceptions by lvalue reference","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr61-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F13.err61-cpp",{"title":2056,"path":2057,"stem":2058},"ERR62-CPP. Detect errors when converting a string to a number","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr62-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F14.err62-cpp",{"title":2060,"path":2061,"stem":2062,"children":2063},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[2064,2065,2069,2073,2077,2081,2085,2089,2093,2097,2101,2105,2109,2113,2117],{"title":2060,"path":2061,"stem":2062},{"title":2066,"path":2067,"stem":2068},"EXP50-CPP. Do not depend on the order of evaluation for side effects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F02.exp50-cpp",{"title":2070,"path":2071,"stem":2072},"EXP51-CPP. Do not delete an array through a pointer of the incorrect type","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F03.exp51-cpp",{"title":2074,"path":2075,"stem":2076},"EXP52-CPP. Do not rely on side effects in unevaluated operands","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F04.exp52-cpp",{"title":2078,"path":2079,"stem":2080},"EXP53-CPP. Do not read uninitialized memory","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F05.exp53-cpp",{"title":2082,"path":2083,"stem":2084},"EXP54-CPP. Do not access an object outside of its lifetime","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F06.exp54-cpp",{"title":2086,"path":2087,"stem":2088},"EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F07.exp55-cpp",{"title":2090,"path":2091,"stem":2092},"EXP56-CPP. Do not call a function with a mismatched language linkage","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F08.exp56-cpp",{"title":2094,"path":2095,"stem":2096},"EXP57-CPP. Do not cast or delete pointers to incomplete classes","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F09.exp57-cpp",{"title":2098,"path":2099,"stem":2100},"EXP58-CPP. Pass an object of the correct type to va_start","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F10.exp58-cpp",{"title":2102,"path":2103,"stem":2104},"EXP59-CPP. Use offsetof() on valid types and members","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F11.exp59-cpp",{"title":2106,"path":2107,"stem":2108},"EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F12.exp60-cpp",{"title":2110,"path":2111,"stem":2112},"EXP61-CPP. A lambda object must not outlive any of its reference captured objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp61-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F13.exp61-cpp",{"title":2114,"path":2115,"stem":2116},"EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp62-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F14.exp62-cpp",{"title":2118,"path":2119,"stem":2120},"EXP63-CPP. Do not rely on the value of a moved-from object","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp63-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F15.exp63-cpp",{"title":2122,"path":2123,"stem":2124,"children":2125},"Input Output (FIO)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F1.index",[2126,2127,2131],{"title":2122,"path":2123,"stem":2124},{"title":2128,"path":2129,"stem":2130},"FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F2.fio50-cpp",{"title":2132,"path":2133,"stem":2134},"FIO51-CPP. Close files when they are no longer needed","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F3.fio51-cpp",{"title":2136,"path":2137,"stem":2138,"children":2139},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[2140,2141],{"title":2136,"path":2137,"stem":2138},{"title":2142,"path":2143,"stem":2144},"INT50-CPP. Do not cast to an out-of-range enumeration value","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int\u002Fint50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F2.int50-cpp",{"title":2146,"path":2147,"stem":2148,"children":2149},"Memory Management (MEM)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F1.index",[2150,2151,2155,2157,2159,2163,2167,2171,2175],{"title":2146,"path":2147,"stem":2148},{"title":2152,"path":2153,"stem":2154},"MEM50-CPP. Do not access freed memory","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F2.mem50-cpp",{"title":92,"path":91,"stem":2156},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F3.mem51-cpp",{"title":606,"path":605,"stem":2158},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F4.mem52-cpp",{"title":2160,"path":2161,"stem":2162},"MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F5.mem53-cpp",{"title":2164,"path":2165,"stem":2166},"MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F6.mem54-cpp",{"title":2168,"path":2169,"stem":2170},"MEM55-CPP. Honor replacement dynamic storage management requirements","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F7.mem55-cpp",{"title":2172,"path":2173,"stem":2174},"MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F8.mem56-cpp",{"title":2176,"path":2177,"stem":2178},"MEM57-CPP. Avoid using default operator new for over-aligned types","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F9.mem57-cpp",{"title":2180,"path":2181,"stem":2182,"children":2183},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[2184,2185,2189,2193,2197,2201],{"title":2180,"path":2181,"stem":2182},{"title":2186,"path":2187,"stem":2188},"MSC51-CPP. Ensure your random number generator is properly seeded","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F2.msc51-cpp",{"title":2190,"path":2191,"stem":2192},"MSC52-CPP. Value-returning functions must return a value from all exit paths","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F3.msc52-cpp",{"title":2194,"path":2195,"stem":2196},"MSC53-CPP. Do not return from a function declared [[noreturn]]","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F4.msc53-cpp",{"title":2198,"path":2199,"stem":2200},"MSC54-CPP. A signal handler must be a plain old function","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F5.msc54-cpp",{"title":2202,"path":2203,"stem":2204},"rand() for generating pseudorandom numbers","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Frand-for-generating-pseudorandom-numbers","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F6.rand-for-generating-pseudorandom-numbers",{"title":2206,"path":2207,"stem":2208,"children":2209},"Object Oriented Programming (OOP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F01.index",[2210,2211,2215,2219,2223,2227,2231,2235,2239,2243],{"title":2206,"path":2207,"stem":2208},{"title":2212,"path":2213,"stem":2214},"OOP50-CPP. Do not invoke virtual functions from constructors or destructors","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F02.oop50-cpp",{"title":2216,"path":2217,"stem":2218},"OOP51-CPP. Do not slice derived objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F03.oop51-cpp",{"title":2220,"path":2221,"stem":2222},"OOP52-CPP. Do not delete a polymorphic object without a virtual destructor","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F04.oop52-cpp",{"title":2224,"path":2225,"stem":2226},"OOP53-CPP. Write constructor member initializers in the canonical order","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F05.oop53-cpp",{"title":2228,"path":2229,"stem":2230},"OOP54-CPP. Gracefully handle self-copy assignment","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F06.oop54-cpp",{"title":2232,"path":2233,"stem":2234},"OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F07.oop55-cpp",{"title":2236,"path":2237,"stem":2238},"OOP56-CPP. Honor replacement handler requirements","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F08.oop56-cpp",{"title":2240,"path":2241,"stem":2242},"OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F09.oop57-cpp",{"title":2244,"path":2245,"stem":2246},"OOP58-CPP. Copy operations must not mutate the source object","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F10.oop58-cpp",{"title":2248,"path":2249,"stem":2250,"children":2251},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[2252,2253,2257,2260,2444,2458],{"title":2248,"path":2249,"stem":2250},{"title":2254,"path":2255,"stem":2256},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":2258,"path":1297,"stem":2259},"BB. Definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":2261,"path":2262,"stem":2263,"children":2264},"CC. Analyzers","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F01.index",[2265,2266,2270,2274,2278,2282,2286,2290,2294,2298,2302,2306,2310,2312,2316,2320,2324,2328,2332,2336,2340,2344,2348,2350,2354,2356,2360,2363,2367,2370,2374,2376,2380,2384,2388,2392,2396,2400,2404,2408,2412,2416,2420,2424,2428,2432,2436,2440],{"title":2261,"path":2262,"stem":2263},{"title":2267,"path":2268,"stem":2269},"Astrée","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":2271,"path":2272,"stem":2273},"Astrée_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F03.astree_v",{"title":2275,"path":2276,"stem":2277},"Axivion Bauhaus Suite","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Faxivion-bauhaus-suite","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F04.axivion-bauhaus-suite",{"title":2279,"path":2280,"stem":2281},"Axivion Bauhaus Suite_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Faxivion-bauhaus-suite_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F05.axivion-bauhaus-suite_v",{"title":2283,"path":2284,"stem":2285},"Clang","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":2287,"path":2288,"stem":2289},"Clang_38_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_38_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F07.clang_38_v",{"title":2291,"path":2292,"stem":2293},"Clang_39_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_39_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F08.clang_39_v",{"title":2295,"path":2296,"stem":2297},"Clang_40_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_40_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F09.clang_40_v",{"title":2299,"path":2300,"stem":2301},"Clang_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F10.clang_v",{"title":2303,"path":2304,"stem":2305},"Codee","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodee","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F11.codee",{"title":2307,"path":2308,"stem":2309},"Codee_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodee_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F12.codee_v",{"title":1407,"path":1406,"stem":2311},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":2313,"path":2314,"stem":2315},"CodeSonar_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F14.codesonar_v",{"title":2317,"path":2318,"stem":2319},"Coverity","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcoverity","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F15.coverity",{"title":2321,"path":2322,"stem":2323},"Coverity_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcoverity_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F16.coverity_v",{"title":2325,"path":2326,"stem":2327},"ECLAIR","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Feclair","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F17.eclair",{"title":2329,"path":2330,"stem":2331},"ECLAIR_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Feclair_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F18.eclair_v",{"title":2333,"path":2334,"stem":2335},"EDG","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fedg","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F19.edg",{"title":2337,"path":2338,"stem":2339},"Edg_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fedg_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F20.edg_v",{"title":2341,"path":2342,"stem":2343},"GCC","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fgcc","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F21.gcc",{"title":2345,"path":2346,"stem":2347},"Gcc_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fgcc_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F22.gcc_v",{"title":1436,"path":1435,"stem":2349},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":2351,"path":2352,"stem":2353},"Helix QAC_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F24.helix-qac_v",{"title":1465,"path":1464,"stem":2355},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":2357,"path":2358,"stem":2359},"Klocwork_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F26.klocwork_v",{"title":2361,"path":1514,"stem":2362},"LDRA","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":2364,"path":2365,"stem":2366},"Ldra_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F28.ldra_v",{"title":2368,"path":1546,"stem":2369},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":2371,"path":2372,"stem":2373},"Parasoft_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F30.parasoft_v",{"title":1573,"path":1572,"stem":2375},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":2377,"path":2378,"stem":2379},"Polyspace Bug Finder_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F32.polyspace-bug-finder_v",{"title":2381,"path":2382,"stem":2383},"PRQA QA-C++","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fprqa-qa-cpp","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F33.prqa-qa-cpp",{"title":2385,"path":2386,"stem":2387},"PRQA QA-C++_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fprqa-qa-cpp_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F34.prqa-qa-cpp_v",{"title":2389,"path":2390,"stem":2391},"PVS-Studio","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F35.pvs-studio",{"title":2393,"path":2394,"stem":2395},"PVS-Studio_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F36.pvs-studio_v",{"title":2397,"path":2398,"stem":2399},"Rose","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frose","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F37.rose",{"title":2401,"path":2402,"stem":2403},"Rose_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frose_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F38.rose_v",{"title":2405,"path":2406,"stem":2407},"RuleChecker","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F39.rulechecker",{"title":2409,"path":2410,"stem":2411},"RuleChecker_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F40.rulechecker_v",{"title":2413,"path":2414,"stem":2415},"Security Reviewer - Static Reviewer","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsecurity-reviewer-static-reviewer","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F41.security-reviewer-static-reviewer",{"title":2417,"path":2418,"stem":2419},"Security Reviewer - Static Reviewer_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsecurity-reviewer-static-reviewer_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F42.security-reviewer-static-reviewer_v",{"title":2421,"path":2422,"stem":2423},"Semgrep","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsemgrep","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F43.semgrep",{"title":2425,"path":2426,"stem":2427},"Semgrep_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsemgrep_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F44.semgrep_v",{"title":2429,"path":2430,"stem":2431},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F45.sonarqube-ccpp-plugin",{"title":2433,"path":2434,"stem":2435},"SonarQube C\u002FC++ Plugin_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F46.sonarqube-ccpp-plugin_v",{"title":2437,"path":2438,"stem":2439},"Splint","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsplint","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F47.splint",{"title":2441,"path":2442,"stem":2443},"Splint_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsplint_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F48.splint_v",{"title":2445,"path":2446,"stem":2447,"children":2448},"DD. Related Guidelines","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F1.index",[2449,2450,2454],{"title":2445,"path":2446,"stem":2447},{"title":2451,"path":2452,"stem":2453},"2008","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines\u002F2.2008","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F2.2008",{"title":2455,"path":2456,"stem":2457},"MITRE CWE","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines\u002Fmitre-cwe","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F3.mitre-cwe",{"title":2459,"path":2460,"stem":2461},"EE. Risk Assessments","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fee-risk-assessments","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F6.ee-risk-assessments",{"title":2463,"path":2464,"stem":2465,"children":2466},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[2467,2468],{"title":2463,"path":2464,"stem":2465},{"title":2469,"path":2470,"stem":2471},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":2473,"path":2474,"stem":2475},"Errata for SEI CERT C++ Coding Standard (2016 Edition)","\u002Fsei-cert-cpp-coding-standard\u002Ferrata-for-sei-cert-cpp-coding-standard-2016-edition","5.sei-cert-cpp-coding-standard\u002F6.errata-for-sei-cert-cpp-coding-standard-2016-edition",1775657781496]