[{"data":1,"prerenderedAt":2460},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp":1761,"sidebar-sei-cert-cpp-coding-standard":1768},[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":41,"extension":1748,"meta":1749,"navigation":7,"path":1757,"seo":1758,"stem":1759,"__hash__":1760},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F06.oop54-cpp.md","OOP54-CPP. Gracefully handle self-copy assignment",{"type":32,"value":33,"toc":1737},"minimark",[34,38,42,140,143,171,174,181,186,209,501,505,515,816,835,839,853,1118,1122,1130,1240,1250,1253,1256,1260,1267,1334,1338,1604,1608,1622,1626,1634,1638,1708,1711,1733],[35,36,30],"h1",{"id":37},"oop54-cpp-gracefully-handle-self-copy-assignment",[39,40,41],"p",{},"Self-copy assignment can occur in situations of varying complexity, but essentially, all self-copy assignments entail some variation of the following.",[43,44,49],"pre",{"className":45,"code":46,"language":47,"meta":48,"style":48},"language-java shiki shiki-themes github-light github-dark monokai","#include \u003Cutility>\n \nstruct S { \u002F* ... *\u002F }\n \nvoid f() {\n  S s;\n  s = s; \u002F\u002F Self-copy assignment\n}\n","java","",[50,51,52,71,77,90,95,109,119,134],"code",{"__ignoreMap":48},[53,54,57,61,65,68],"span",{"class":55,"line":56},"line",1,[53,58,60],{"class":59},"sMOD_","#include ",[53,62,64],{"class":63},"sC2Qs","\u003C",[53,66,67],{"class":59},"utility",[53,69,70],{"class":63},">\n",[53,72,74],{"class":55,"line":73},2,[53,75,76],{"class":59}," \n",[53,78,80,83,87],{"class":55,"line":79},3,[53,81,82],{"class":59},"struct S { ",[53,84,86],{"class":85},"s8-w5","\u002F* ... *\u002F",[53,88,89],{"class":59}," }\n",[53,91,93],{"class":55,"line":92},4,[53,94,76],{"class":59},[53,96,98,102,106],{"class":55,"line":97},5,[53,99,101],{"class":100},"sq6CD","void",[53,103,105],{"class":104},"srTi1"," f",[53,107,108],{"class":59},"() {\n",[53,110,112,116],{"class":55,"line":111},6,[53,113,115],{"class":114},"sk8M1","  S",[53,117,118],{"class":59}," s;\n",[53,120,122,125,128,131],{"class":55,"line":121},7,[53,123,124],{"class":59},"  s ",[53,126,127],{"class":63},"=",[53,129,130],{"class":59}," s; ",[53,132,133],{"class":85},"\u002F\u002F Self-copy assignment\n",[53,135,137],{"class":55,"line":136},8,[53,138,139],{"class":59},"}\n",[39,141,142],{},"User-provided copy operators must properly handle self-copy assignment.",[39,144,145,146,151,152,155,156,159,160,163,164,167,168,170],{},"The postconditions required for copy assignment are specified by the C++ Standard, [utility.arg.requirements], Table 23 [ ",[147,148,150],"a",{"href":149},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], which states that for ",[50,153,154],{},"  x = y "," , the value of ",[50,157,158],{},"y"," is unchanged. When ",[50,161,162],{},"  &x == &y "," , this postcondition translates into the values of both ",[50,165,166],{},"x"," and ",[50,169,158],{}," remaining unchanged. A naive implementation of copy assignment could destroy object-local resources in the process of copying resources from the given parameter. If the given parameter is the same object as the local object, the act of destroying object-local resources will invalidate them. The subsequent copy of those resources will be left in an indeterminate state, which violates the postcondition.",[39,172,173],{},"A user-provided copy assignment operator must prevent self-copy assignment from leaving the object in an indeterminate state. This can be accomplished by self-assignment tests, copy-and-swap, or other idiomatic design patterns.",[39,175,176,177,180],{},"The C++ Standard, [copyassignable], specifies that types must ensure that self-copy assignment leave the object in a consistent state when passed to Standard Template Library (STL) functions. Since objects of STL types are used in contexts where ",[50,178,179],{},"CopyAssignable"," is required, STL types are required to gracefully handle self-copy assignment.",[182,183,185],"h2",{"id":184},"noncompliant-code-example","Noncompliant Code Example",[39,187,188,189,192,193,196,197,199,200,203,204,208],{},"In this noncompliant code example, the copy assignment operator does not protect against self-copy assignment. If self-copy assignment occurs, ",[50,190,191],{},"this->s1"," is deleted, which results in ",[50,194,195],{},"rhs.s1"," also being deleted. The invalidated memory for ",[50,198,195],{}," is then passed into the copy constructor for ",[50,201,202],{},"S"," , which can result in dereferencing an ",[147,205,207],{"href":206},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-invalidpointer","invalid pointer"," .",[210,211,213],"code-block",{"quality":212},"bad",[43,214,218],{"className":215,"code":216,"language":217,"meta":48,"style":48},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Cnew>\n \nstruct S { S(const S &) noexcept; \u002F* ... *\u002F };\n \nclass T {\n  int n;\n  S *s1;\n \npublic:\n  T(const T &rhs) : n(rhs.n), s1(rhs.s1 ? new S(*rhs.s1) : nullptr) {}\n  ~T() { delete s1; }\n \n  \u002F\u002F ...\n \n  T& operator=(const T &rhs) {\n    n = rhs.n;\n    delete s1;\n    s1 = new S(*rhs.s1);\n    return *this;\n  }\n};\n","cpp",[50,219,220,229,233,274,278,289,297,308,312,318,377,392,397,403,408,434,445,454,473,489,495],{"__ignoreMap":48},[53,221,222,225],{"class":55,"line":56},[53,223,224],{"class":63},"#include",[53,226,228],{"class":227},"sstjo"," \u003Cnew>\n",[53,230,231],{"class":55,"line":73},[53,232,76],{"class":59},[53,234,235,238,242,245,247,250,253,256,259,262,265,268,271],{"class":55,"line":79},[53,236,237],{"class":100},"struct",[53,239,241],{"class":240},"sz2Vg"," S",[53,243,244],{"class":59}," { ",[53,246,202],{"class":104},[53,248,249],{"class":59},"(",[53,251,252],{"class":63},"const",[53,254,255],{"class":59}," S ",[53,257,258],{"class":63},"&",[53,260,261],{"class":59},") ",[53,263,264],{"class":63},"noexcept",[53,266,267],{"class":59},";",[53,269,270],{"class":85}," \u002F* ... *\u002F",[53,272,273],{"class":59}," };\n",[53,275,276],{"class":55,"line":92},[53,277,76],{"class":59},[53,279,280,283,286],{"class":55,"line":97},[53,281,282],{"class":100},"class",[53,284,285],{"class":240}," T",[53,287,288],{"class":59}," {\n",[53,290,291,294],{"class":55,"line":111},[53,292,293],{"class":100},"  int",[53,295,296],{"class":59}," n;\n",[53,298,299,302,305],{"class":55,"line":121},[53,300,301],{"class":59},"  S ",[53,303,304],{"class":63},"*",[53,306,307],{"class":59},"s1;\n",[53,309,310],{"class":55,"line":136},[53,311,76],{"class":59},[53,313,315],{"class":55,"line":314},9,[53,316,317],{"class":100},"public:\n",[53,319,321,324,326,328,330,333,337,340,343,346,349,352,355,358,360,362,364,367,370,374],{"class":55,"line":320},10,[53,322,323],{"class":104},"  T",[53,325,249],{"class":59},[53,327,252],{"class":63},[53,329,285],{"class":240},[53,331,332],{"class":63}," &",[53,334,336],{"class":335},"sTHNf","rhs",[53,338,339],{"class":59},") : ",[53,341,342],{"class":104},"n",[53,344,345],{"class":59},"(rhs.n), ",[53,347,348],{"class":104},"s1",[53,350,351],{"class":59},"(rhs.s1 ",[53,353,354],{"class":63},"?",[53,356,357],{"class":63}," new",[53,359,241],{"class":104},[53,361,249],{"class":59},[53,363,304],{"class":63},[53,365,366],{"class":59},"rhs.s1) ",[53,368,369],{"class":63},":",[53,371,373],{"class":372},"s7F3e"," nullptr",[53,375,376],{"class":59},") {}\n",[53,378,380,383,386,389],{"class":55,"line":379},11,[53,381,382],{"class":104},"  ~T",[53,384,385],{"class":59},"() { ",[53,387,388],{"class":63},"delete",[53,390,391],{"class":59}," s1; }\n",[53,393,395],{"class":55,"line":394},12,[53,396,76],{"class":59},[53,398,400],{"class":55,"line":399},13,[53,401,402],{"class":85},"  \u002F\u002F ...\n",[53,404,406],{"class":55,"line":405},14,[53,407,76],{"class":59},[53,409,411,413,415,418,421,423,425,427,429,431],{"class":55,"line":410},15,[53,412,323],{"class":240},[53,414,258],{"class":63},[53,416,417],{"class":63}," operator",[53,419,127],{"class":420},"s_OQ2",[53,422,249],{"class":59},[53,424,252],{"class":63},[53,426,285],{"class":240},[53,428,332],{"class":63},[53,430,336],{"class":335},[53,432,433],{"class":59},") {\n",[53,435,437,440,442],{"class":55,"line":436},16,[53,438,439],{"class":59},"    n ",[53,441,127],{"class":63},[53,443,444],{"class":59}," rhs.n;\n",[53,446,448,451],{"class":55,"line":447},17,[53,449,450],{"class":63},"    delete",[53,452,453],{"class":59}," s1;\n",[53,455,457,460,462,464,466,468,470],{"class":55,"line":456},18,[53,458,459],{"class":59},"    s1 ",[53,461,127],{"class":63},[53,463,357],{"class":63},[53,465,241],{"class":104},[53,467,249],{"class":59},[53,469,304],{"class":63},[53,471,472],{"class":59},"rhs.s1);\n",[53,474,476,479,482,486],{"class":55,"line":475},19,[53,477,478],{"class":63},"    return",[53,480,481],{"class":63}," *",[53,483,485],{"class":484},"sP7S_","this",[53,487,488],{"class":59},";\n",[53,490,492],{"class":55,"line":491},20,[53,493,494],{"class":59},"  }\n",[53,496,498],{"class":55,"line":497},21,[53,499,500],{"class":59},"};\n",[182,502,504],{"id":503},"compliant-solution-self-test","Compliant Solution (Self-Test)",[39,506,507,508,510,511,514],{},"This compliant solution guards against self-copy assignment by testing whether the given parameter is the same as ",[50,509,485],{}," . If self-copy assignment occurs, then ",[50,512,513],{},"operator="," does nothing; otherwise, the copy proceeds as in the original example.",[210,516,518],{"quality":517},"good",[43,519,521],{"className":215,"code":520,"language":217,"meta":48,"style":48},"#include \u003Cnew>\n \nstruct S { S(const S &) noexcept; \u002F* ... *\u002F };\n \nclass T {\n  int n;\n  S *s1;\n \npublic:\n  T(const T &rhs) : n(rhs.n), s1(rhs.s1 ? new S(*rhs.s1) : nullptr) {}\n  ~T() { delete s1; }\n\n  \u002F\u002F ...\n \n  T& operator=(const T &rhs) {\n    if (this != &rhs) {\n      n = rhs.n;\n      delete s1;\n      try {\n        s1 = new S(*rhs.s1);\n      } catch (std::bad_alloc &) {\n        s1 = nullptr; \u002F\u002F For basic exception guarantees\n        throw;\n      }\n    }\n    return *this;\n  }\n};\n",[50,522,523,529,534,562,566,574,580,588,592,596,638,648,653,657,661,683,701,710,717,724,741,761,775,783,789,795,806,811],{"__ignoreMap":48},[53,524,525,527],{"class":55,"line":56},[53,526,224],{"class":63},[53,528,228],{"class":227},[53,530,531],{"class":55,"line":73},[53,532,533],{"class":59}," \n",[53,535,536,538,540,542,544,546,548,550,552,554,556,558,560],{"class":55,"line":79},[53,537,237],{"class":100},[53,539,241],{"class":240},[53,541,244],{"class":59},[53,543,202],{"class":104},[53,545,249],{"class":59},[53,547,252],{"class":63},[53,549,255],{"class":59},[53,551,258],{"class":63},[53,553,261],{"class":59},[53,555,264],{"class":63},[53,557,267],{"class":59},[53,559,270],{"class":85},[53,561,273],{"class":59},[53,563,564],{"class":55,"line":92},[53,565,533],{"class":59},[53,567,568,570,572],{"class":55,"line":97},[53,569,282],{"class":100},[53,571,285],{"class":240},[53,573,288],{"class":59},[53,575,576,578],{"class":55,"line":111},[53,577,293],{"class":100},[53,579,296],{"class":59},[53,581,582,584,586],{"class":55,"line":121},[53,583,301],{"class":59},[53,585,304],{"class":63},[53,587,307],{"class":59},[53,589,590],{"class":55,"line":136},[53,591,76],{"class":59},[53,593,594],{"class":55,"line":314},[53,595,317],{"class":100},[53,597,598,600,602,604,606,608,610,612,614,616,618,620,622,624,626,628,630,632,634,636],{"class":55,"line":320},[53,599,323],{"class":104},[53,601,249],{"class":59},[53,603,252],{"class":63},[53,605,285],{"class":240},[53,607,332],{"class":63},[53,609,336],{"class":335},[53,611,339],{"class":59},[53,613,342],{"class":104},[53,615,345],{"class":59},[53,617,348],{"class":104},[53,619,351],{"class":59},[53,621,354],{"class":63},[53,623,357],{"class":63},[53,625,241],{"class":104},[53,627,249],{"class":59},[53,629,304],{"class":63},[53,631,366],{"class":59},[53,633,369],{"class":63},[53,635,373],{"class":372},[53,637,376],{"class":59},[53,639,640,642,644,646],{"class":55,"line":379},[53,641,382],{"class":104},[53,643,385],{"class":59},[53,645,388],{"class":63},[53,647,391],{"class":59},[53,649,650],{"class":55,"line":394},[53,651,652],{"emptyLinePlaceholder":7},"\n",[53,654,655],{"class":55,"line":399},[53,656,402],{"class":85},[53,658,659],{"class":55,"line":405},[53,660,533],{"class":59},[53,662,663,665,667,669,671,673,675,677,679,681],{"class":55,"line":410},[53,664,323],{"class":240},[53,666,258],{"class":63},[53,668,417],{"class":63},[53,670,127],{"class":420},[53,672,249],{"class":59},[53,674,252],{"class":63},[53,676,285],{"class":240},[53,678,332],{"class":63},[53,680,336],{"class":335},[53,682,433],{"class":59},[53,684,685,688,691,693,696,698],{"class":55,"line":436},[53,686,687],{"class":63},"    if",[53,689,690],{"class":59}," (",[53,692,485],{"class":484},[53,694,695],{"class":63}," !=",[53,697,332],{"class":63},[53,699,700],{"class":59},"rhs) {\n",[53,702,703,706,708],{"class":55,"line":447},[53,704,705],{"class":59},"      n ",[53,707,127],{"class":63},[53,709,444],{"class":59},[53,711,712,715],{"class":55,"line":456},[53,713,714],{"class":63},"      delete",[53,716,453],{"class":59},[53,718,719,722],{"class":55,"line":475},[53,720,721],{"class":63},"      try",[53,723,288],{"class":59},[53,725,726,729,731,733,735,737,739],{"class":55,"line":491},[53,727,728],{"class":59},"        s1 ",[53,730,127],{"class":63},[53,732,357],{"class":63},[53,734,241],{"class":104},[53,736,249],{"class":59},[53,738,304],{"class":63},[53,740,472],{"class":59},[53,742,743,746,749,751,754,757,759],{"class":55,"line":497},[53,744,745],{"class":59},"      } ",[53,747,748],{"class":63},"catch",[53,750,690],{"class":59},[53,752,753],{"class":240},"std",[53,755,756],{"class":59},"::bad_alloc ",[53,758,258],{"class":63},[53,760,433],{"class":59},[53,762,764,766,768,770,772],{"class":55,"line":763},22,[53,765,728],{"class":59},[53,767,127],{"class":63},[53,769,373],{"class":372},[53,771,267],{"class":59},[53,773,774],{"class":85}," \u002F\u002F For basic exception guarantees\n",[53,776,778,781],{"class":55,"line":777},23,[53,779,780],{"class":63},"        throw",[53,782,488],{"class":59},[53,784,786],{"class":55,"line":785},24,[53,787,788],{"class":59},"      }\n",[53,790,792],{"class":55,"line":791},25,[53,793,794],{"class":59},"    }\n",[53,796,798,800,802,804],{"class":55,"line":797},26,[53,799,478],{"class":63},[53,801,481],{"class":63},[53,803,485],{"class":484},[53,805,488],{"class":59},[53,807,809],{"class":55,"line":808},27,[53,810,494],{"class":59},[53,812,814],{"class":55,"line":813},28,[53,815,500],{"class":59},[39,817,818,819,823,824,827,828,830,831,208],{},"This solution does not provide a ",[147,820,822],{"href":821},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-strongexceptionsafety","strong exception"," guarantee for the copy assignment. Specifically, if an exception is called when evaluating the ",[50,825,826],{},"new"," expression, ",[50,829,485],{}," has already been modified. However, this solution does provide a basic exception guarantee because no resources are leaked and all data members contain valid values. Consequently, this code complies with ",[147,832,834],{"href":833},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr56-cpp","ERR56-CPP. Guarantee exception safety",[182,836,838],{"id":837},"compliant-solution-copy-and-swap","Compliant Solution (Copy and Swap)",[39,840,841,842,844,845,848,849,852],{},"This compliant solution avoids self-copy assignment by constructing a temporary object from ",[50,843,336],{}," that is then swapped with ",[50,846,847],{},"*this"," . This compliant solution provides a strong exception guarantee because ",[50,850,851],{},"swap()"," will never be called if resource allocation results in an exception being thrown while creating the temporary object.",[210,854,855],{"quality":517},[43,856,858],{"className":215,"code":857,"language":217,"meta":48,"style":48},"#include \u003Cnew>\n#include \u003Cutility>\n \nstruct S { S(const S &) noexcept; \u002F* ... *\u002F };\n \nclass T {\n  int n;\n  S *s1;\n \npublic:\n  T(const T &rhs) : n(rhs.n), s1(rhs.s1 ? new S(*rhs.s1) : nullptr) {}\n  ~T() { delete s1; }\n\n  \u002F\u002F ...\n \n  void swap(T &rhs) noexcept {\n    using std::swap;\n    swap(n, rhs.n);\n    swap(s1, rhs.s1);\n  }\n \n  T& operator=(T rhs) noexcept {\n    rhs.swap(*this);\n    return *this;\n  }\n};\n",[50,859,860,866,873,877,905,909,917,923,931,935,939,981,991,995,999,1003,1026,1037,1045,1052,1056,1060,1083,1100,1110,1114],{"__ignoreMap":48},[53,861,862,864],{"class":55,"line":56},[53,863,224],{"class":63},[53,865,228],{"class":227},[53,867,868,870],{"class":55,"line":73},[53,869,224],{"class":63},[53,871,872],{"class":227}," \u003Cutility>\n",[53,874,875],{"class":55,"line":79},[53,876,533],{"class":59},[53,878,879,881,883,885,887,889,891,893,895,897,899,901,903],{"class":55,"line":92},[53,880,237],{"class":100},[53,882,241],{"class":240},[53,884,244],{"class":59},[53,886,202],{"class":104},[53,888,249],{"class":59},[53,890,252],{"class":63},[53,892,255],{"class":59},[53,894,258],{"class":63},[53,896,261],{"class":59},[53,898,264],{"class":63},[53,900,267],{"class":59},[53,902,270],{"class":85},[53,904,273],{"class":59},[53,906,907],{"class":55,"line":97},[53,908,533],{"class":59},[53,910,911,913,915],{"class":55,"line":111},[53,912,282],{"class":100},[53,914,285],{"class":240},[53,916,288],{"class":59},[53,918,919,921],{"class":55,"line":121},[53,920,293],{"class":100},[53,922,296],{"class":59},[53,924,925,927,929],{"class":55,"line":136},[53,926,301],{"class":59},[53,928,304],{"class":63},[53,930,307],{"class":59},[53,932,933],{"class":55,"line":314},[53,934,533],{"class":59},[53,936,937],{"class":55,"line":320},[53,938,317],{"class":100},[53,940,941,943,945,947,949,951,953,955,957,959,961,963,965,967,969,971,973,975,977,979],{"class":55,"line":379},[53,942,323],{"class":104},[53,944,249],{"class":59},[53,946,252],{"class":63},[53,948,285],{"class":240},[53,950,332],{"class":63},[53,952,336],{"class":335},[53,954,339],{"class":59},[53,956,342],{"class":104},[53,958,345],{"class":59},[53,960,348],{"class":104},[53,962,351],{"class":59},[53,964,354],{"class":63},[53,966,357],{"class":63},[53,968,241],{"class":104},[53,970,249],{"class":59},[53,972,304],{"class":63},[53,974,366],{"class":59},[53,976,369],{"class":63},[53,978,373],{"class":372},[53,980,376],{"class":59},[53,982,983,985,987,989],{"class":55,"line":394},[53,984,382],{"class":104},[53,986,385],{"class":59},[53,988,388],{"class":63},[53,990,391],{"class":59},[53,992,993],{"class":55,"line":399},[53,994,652],{"emptyLinePlaceholder":7},[53,996,997],{"class":55,"line":405},[53,998,402],{"class":85},[53,1000,1001],{"class":55,"line":410},[53,1002,76],{"class":59},[53,1004,1005,1008,1011,1013,1016,1018,1020,1022,1024],{"class":55,"line":436},[53,1006,1007],{"class":100},"  void",[53,1009,1010],{"class":104}," swap",[53,1012,249],{"class":59},[53,1014,1015],{"class":240},"T",[53,1017,332],{"class":63},[53,1019,336],{"class":335},[53,1021,261],{"class":59},[53,1023,264],{"class":63},[53,1025,288],{"class":59},[53,1027,1028,1031,1034],{"class":55,"line":447},[53,1029,1030],{"class":63},"    using",[53,1032,1033],{"class":240}," std",[53,1035,1036],{"class":59},"::swap;\n",[53,1038,1039,1042],{"class":55,"line":456},[53,1040,1041],{"class":104},"    swap",[53,1043,1044],{"class":59},"(n, rhs.n);\n",[53,1046,1047,1049],{"class":55,"line":475},[53,1048,1041],{"class":104},[53,1050,1051],{"class":59},"(s1, rhs.s1);\n",[53,1053,1054],{"class":55,"line":491},[53,1055,494],{"class":59},[53,1057,1058],{"class":55,"line":497},[53,1059,533],{"class":59},[53,1061,1062,1064,1066,1068,1070,1072,1074,1077,1079,1081],{"class":55,"line":763},[53,1063,323],{"class":240},[53,1065,258],{"class":63},[53,1067,417],{"class":63},[53,1069,127],{"class":420},[53,1071,249],{"class":59},[53,1073,1015],{"class":240},[53,1075,1076],{"class":335}," rhs",[53,1078,261],{"class":59},[53,1080,264],{"class":63},[53,1082,288],{"class":59},[53,1084,1085,1088,1091,1093,1095,1097],{"class":55,"line":777},[53,1086,1087],{"class":59},"    rhs.",[53,1089,1090],{"class":104},"swap",[53,1092,249],{"class":59},[53,1094,304],{"class":63},[53,1096,485],{"class":484},[53,1098,1099],{"class":59},");\n",[53,1101,1102,1104,1106,1108],{"class":55,"line":785},[53,1103,478],{"class":63},[53,1105,481],{"class":63},[53,1107,485],{"class":484},[53,1109,488],{"class":59},[53,1111,1112],{"class":55,"line":791},[53,1113,494],{"class":59},[53,1115,1116],{"class":55,"line":797},[53,1117,500],{"class":59},[182,1119,1121],{"id":1120},"compliant-solution-move-and-swap","Compliant Solution (Move and Swap)",[39,1123,1124,1125,167,1127,1129],{},"This compliant solution uses the same classes ",[50,1126,202],{},[50,1128,1015],{}," from the previous compliant solution, but adds the following public constructor and methods:",[210,1131,1132],{"quality":517},[43,1133,1135],{"className":215,"code":1134,"language":217,"meta":48,"style":48},"  T(T &&rhs) { *this = std::move(rhs); }\n\n  \u002F\u002F ... everything except operator= ..\n\n  T& operator=(T &&rhs) noexcept {\n    using std::swap;\n    swap(n, rhs.n);\n    swap(s1, rhs.s1);\n    return *this;\n  }\n",[50,1136,1137,1168,1172,1177,1181,1206,1214,1220,1226,1236],{"__ignoreMap":48},[53,1138,1139,1141,1144,1147,1150,1152,1154,1157,1159,1162,1165],{"class":55,"line":56},[53,1140,323],{"class":104},[53,1142,1143],{"class":59},"(T ",[53,1145,1146],{"class":63},"&&",[53,1148,1149],{"class":59},"rhs) { ",[53,1151,304],{"class":63},[53,1153,485],{"class":484},[53,1155,1156],{"class":63}," =",[53,1158,1033],{"class":240},[53,1160,1161],{"class":59},"::",[53,1163,1164],{"class":104},"move",[53,1166,1167],{"class":59},"(rhs); }\n",[53,1169,1170],{"class":55,"line":73},[53,1171,652],{"emptyLinePlaceholder":7},[53,1173,1174],{"class":55,"line":79},[53,1175,1176],{"class":85},"  \u002F\u002F ... everything except operator= ..\n",[53,1178,1179],{"class":55,"line":92},[53,1180,652],{"emptyLinePlaceholder":7},[53,1182,1183,1185,1187,1189,1191,1193,1195,1198,1200,1202,1204],{"class":55,"line":97},[53,1184,323],{"class":240},[53,1186,258],{"class":63},[53,1188,417],{"class":63},[53,1190,127],{"class":420},[53,1192,249],{"class":59},[53,1194,1015],{"class":240},[53,1196,1197],{"class":63}," &&",[53,1199,336],{"class":335},[53,1201,261],{"class":59},[53,1203,264],{"class":63},[53,1205,288],{"class":59},[53,1207,1208,1210,1212],{"class":55,"line":111},[53,1209,1030],{"class":63},[53,1211,1033],{"class":240},[53,1213,1036],{"class":59},[53,1215,1216,1218],{"class":55,"line":121},[53,1217,1041],{"class":104},[53,1219,1044],{"class":59},[53,1221,1222,1224],{"class":55,"line":136},[53,1223,1041],{"class":104},[53,1225,1051],{"class":59},[53,1227,1228,1230,1232,1234],{"class":55,"line":314},[53,1229,478],{"class":63},[53,1231,481],{"class":63},[53,1233,485],{"class":484},[53,1235,488],{"class":59},[53,1237,1238],{"class":55,"line":320},[53,1239,494],{"class":59},[39,1241,1242,1243,1246,1247,1249],{},"The copy assignment operator uses ",[50,1244,1245],{},"std::move()"," rather than ",[50,1248,851],{}," to achieve safe self-assignment and a strong exception guarantee. The move assignment operator uses a move (via the method parameter) and swap.",[39,1251,1252],{},"The move constructor is not strictly necessary, but defining a move constructor along with a move assignment operator is conventional for classes that support move operations.",[39,1254,1255],{},"Note that unlike copy assignment operators, the signature of a move assignment operator accepts a non-const reference to its object with the expectation that the moved-from object will be left in an unspecified, but valid state. Move constructors have the same difference from copy constructors.",[182,1257,1259],{"id":1258},"risk-assessment","Risk Assessment",[39,1261,1262,1263,208],{},"Allowing a copy assignment operator to corrupt an object could lead to ",[147,1264,1266],{"href":1265},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-undefinedbehavior","undefined behavior",[1268,1269,1270,1271,1270,1301],"table",{},"\n  ",[1272,1273,1274,1275,1270],"thead",{},"\n    ",[1276,1277,1278,1279,1278,1283,1278,1286,1278,1289,1278,1292,1278,1295,1278,1298,1274],"tr",{},"\n      ",[1280,1281,1282],"th",{},"Rule",[1280,1284,1285],{},"Severity",[1280,1287,1288],{},"Likelihood",[1280,1290,1291],{},"Detectable",[1280,1293,1294],{},"Repairable",[1280,1296,1297],{},"Priority",[1280,1299,1300],{},"Level",[1302,1303,1274,1304,1270],"tbody",{},[1276,1305,1278,1306,1278,1310,1278,1313,1278,1316,1278,1319,1278,1322,1278,1329,1274],{},[1307,1308,1309],"td",{},"OOP54-CPP",[1307,1311,1312],{},"Low",[1307,1314,1315],{},"Probable",[1307,1317,1318],{},"Yes",[1307,1320,1321],{},"No",[1307,1323,1325],{"style":1324},"color: #27ae60;",[1326,1327,1328],"b",{},"P4",[1307,1330,1331],{"style":1324},[1326,1332,1333],{},"L3",[182,1335,1337],{"id":1336},"automated-detection","Automated Detection",[1268,1339,1342],{"className":1340},[1341],"wrapped",[1302,1343,1344,1368,1401,1428,1503,1531,1554,1578],{},[1276,1345,1348,1353,1358,1363],{"className":1346},[1347],"header",[1280,1349,1350],{},[39,1351,1352],{},"Tool",[1280,1354,1355],{},[39,1356,1357],{},"Version",[1280,1359,1360],{},[39,1361,1362],{},"Checker",[1280,1364,1365],{},[39,1366,1367],{},"Description",[1276,1369,1372,1378,1388,1397],{"className":1370},[1371],"odd",[1307,1373,1374],{},[147,1375,1377],{"href":1376},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","Astrée",[1307,1379,1380],{},[1381,1382,1385],"div",{"className":1383},[1384],"content-wrapper",[39,1386,1387],{},"25.10",[1307,1389,1390],{},[1391,1392,1393,1394],"strong",{},"dangling_pointer_use",[1395,1396],"br",{},[1307,1398,1399],{},[1395,1400],{},[1276,1402,1405,1411,1417,1422],{"className":1403},[1404],"even",[1307,1406,1407],{},[147,1408,1410],{"href":1409},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","Clang",[1307,1412,1413],{},[1381,1414,1416],{"className":1415},[1384],"9.0 (r361550)",[1307,1418,1419],{},[50,1420,1421],{},"      cert-oop54-cpp     ",[1307,1423,1424,1425,208],{},"Checked by ",[50,1426,1427],{},"      clang-tidy     ",[1276,1429,1431,1437,1443,1480],{"className":1430},[1371],[1307,1432,1433],{},[147,1434,1436],{"href":1435},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[1307,1438,1439],{},[1381,1440,1442],{"className":1441},[1384],"9.1p0",[1307,1444,1445],{},[39,1446,1447,1450,1452,1455,1457,1460,1462,1465,1467,1470,1472,1475,1477],{},[1391,1448,1449],{},"IO.DC",[1395,1451],{},[1391,1453,1454],{},"ALLOC.DF",[1395,1456],{},[1391,1458,1459],{},"ALLOC.LEAK",[1395,1461],{},[1391,1463,1464],{},"LANG.MEM.NPD",[1395,1466],{},[1391,1468,1469],{},"LANG.STRUCT.RC",[1395,1471],{},[1391,1473,1474],{},"IO.UAC",[1395,1476],{},[1391,1478,1479],{},"ALLOC.UAF",[1307,1481,1482],{},[39,1483,1484,1485,1487,1488,1490,1491,1493,1494,1496,1497,1499,1500,1502],{},"Double Close",[1395,1486],{},"\nDouble Free",[1395,1489],{},"\nLeak",[1395,1492],{},"\nNull Pointer Dereference",[1395,1495],{},"\nRedundant Condition",[1395,1498],{},"\nUse After Close",[1395,1501],{},"\nUse After Free",[1276,1504,1506,1512,1520,1527],{"className":1505},[1404],[1307,1507,1508],{},[147,1509,1511],{"href":1510},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[1307,1513,1514],{},[1381,1515,1517],{"className":1516},[1384],[39,1518,1519],{},"2025.2",[1307,1521,1522],{},[39,1523,1524],{},[1391,1525,1526],{},"C++4072, C++4073, C++4075, C++4076",[1307,1528,1529],{},[1395,1530],{},[1276,1532,1534,1540,1545,1550],{"className":1533},[1371],[1307,1535,1536],{},[147,1537,1539],{"href":1538},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","Klocwork",[1307,1541,1542],{},[1381,1543,1519],{"className":1544},[1384],[1307,1546,1547],{},[1391,1548,1549],{},"CL.SELF-ASSIGN",[1307,1551,1552],{},[1395,1553],{},[1276,1555,1557,1563,1568,1575],{"className":1556},[1404],[1307,1558,1559],{},[147,1560,1562],{"href":1561},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1307,1564,1565],{},[1381,1566,1519],{"className":1567},[1384],[1307,1569,1570],{},[39,1571,1572],{},[1391,1573,1574],{},"CERT_CPP-OOP54-a",[1307,1576,1577],{},"User-provided copy assignment operators shall handle self-assignment",[1276,1579,1581,1587,1595,1601],{"className":1580},[1371],[1307,1582,1583],{},[147,1584,1586],{"href":1585},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1307,1588,1589],{},[1381,1590,1592],{"className":1591},[1384],[39,1593,1594],{},"R2025b",[1307,1596,1597],{},[147,1598,1600],{"href":1599},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcoop54cpp.html","CERT C++: OOP54-CPP",[1307,1602,1603],{},"Checks for copy assignment operators where self-assignment is not tested (rule partially covered)",[182,1605,1607],{"id":1606},"related-vulnerabilities","Related Vulnerabilities",[39,1609,1610,1611,1615,1616,208],{},"Search for other ",[147,1612,1614],{"href":1613},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[147,1617,1621],{"href":1618,"rel":1619},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+OOP38-CPP",[1620],"nofollow","CERT website",[182,1623,1625],{"id":1624},"related-guidelines","Related Guidelines",[39,1627,1628,1629,1633],{},"This rule is a partial subset of ",[147,1630,1632],{"href":1631},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop58-cpp","OOP58-CPP. Copy operations must not mutate the source object"," when copy operations do not gracefully handle self-copy assignment, because the copy operation may mutate both the source and destination objects (due to them being the same object).",[182,1635,1637],{"id":1636},"bibliography","Bibliography",[1268,1639,1641,1650],{"className":1640},[1341],[1642,1643,1644,1648],"colgroup",{},[1645,1646],"col",{"style":1647},"width: 50%",[1645,1649],{"style":1647},[1302,1651,1652,1666,1679,1695],{},[1276,1653,1655,1663],{"className":1654},[1371],[1307,1656,1657,1658,1662],{},"[ ",[147,1659,1661],{"href":1660},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Henricson97","Henricson 1997"," ]",[1307,1664,1665],{},"Rule 5.12, Copy assignment operators should be protected from doing destructive actions if an object is assigned to itself",[1276,1667,1669,1673],{"className":1668},[1404],[1307,1670,1657,1671,1662],{},[147,1672,150],{"href":149},[1307,1674,1675,1676,1678],{},"Subclause 17.6.3.1, \"Template Argument Requirements\"",[1395,1677],{},"\nSubclause 17.6.4.9, \"Function Arguments\"",[1276,1680,1682,1688],{"className":1681},[1371],[1307,1683,1657,1684,1662],{},[147,1685,1687],{"href":1686},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Meyers05","Meyers 2005",[1307,1689,1690,1691,1694],{},"Item 11, \"Handle Assignment to Self in ",[50,1692,1693],{},"      operator=     "," \"",[1276,1696,1698,1704],{"className":1697},[1404],[1307,1699,1657,1700,1662],{},[147,1701,1703],{"href":1702},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Meyers14","Meyers 2014",[1307,1705,1706],{},[1395,1707],{},[1709,1710],"hr",{},[39,1712,1713,1720,1721,1720,1727],{},[147,1714,1716],{"href":1715},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop53-cpp",[1717,1718],"img",{"src":1719},"\u002Fattachments\u002F88046682\u002F88480621.png"," ",[147,1722,1724],{"href":1723},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002F",[1717,1725],{"src":1726},"\u002Fattachments\u002F88046682\u002F88475556.png",[147,1728,1730],{"href":1729},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop55-cpp",[1717,1731],{"src":1732},"\u002Fattachments\u002F88046682\u002F88475555.png",[1734,1735,1736],"style",{},"html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}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 .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sk8M1, html code.shiki .sk8M1{--shiki-default:#24292E;--shiki-default-font-style:inherit;--shiki-dark:#E1E4E8;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}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);}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}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 .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .s_OQ2, html code.shiki .s_OQ2{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#F8F8F2}html pre.shiki code .sP7S_, html code.shiki .sP7S_{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#FD971F}",{"title":48,"searchDepth":73,"depth":73,"links":1738},[1739,1740,1741,1742,1743,1744,1745,1746,1747],{"id":184,"depth":73,"text":185},{"id":503,"depth":73,"text":504},{"id":837,"depth":73,"text":838},{"id":1120,"depth":73,"text":1121},{"id":1258,"depth":73,"text":1259},{"id":1336,"depth":73,"text":1337},{"id":1606,"depth":73,"text":1607},{"id":1624,"depth":73,"text":1625},{"id":1636,"depth":73,"text":1637},"md",{"tags":1750},[1751,1752,1753,1754,1755,1756],"review","oop","ptc","review-dms","rule","review-ajb","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp",{"title":30,"description":41},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F06.oop54-cpp","E1npCyE4M7aOXwzsAT5ZmD9PnluWFUF3euAqqoOGnN4",[1762,1765],{"title":1763,"path":1715,"stem":1764,"children":-1},"OOP53-CPP. Write constructor member initializers in the canonical order","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F05.oop53-cpp",{"title":1766,"path":1729,"stem":1767,"children":-1},"OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F07.oop55-cpp",[1769],{"title":1770,"path":1771,"stem":1772,"children":1773},"SEI CERT C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[1774,1775,1842,2233,2446,2456],{"title":1770,"path":1771,"stem":1772},{"title":1776,"path":1777,"stem":1778,"children":1779},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[1780,1781],{"title":1776,"path":1777,"stem":1778},{"title":1782,"path":1783,"stem":1784,"children":1785},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[1786,1787,1791,1795,1799,1803,1807,1811,1815,1819,1823,1827,1831,1835,1839],{"title":1782,"path":1783,"stem":1784},{"title":1788,"path":1789,"stem":1790},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":1792,"path":1793,"stem":1794},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":1796,"path":1797,"stem":1798},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":1800,"path":1801,"stem":1802},"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":1804,"path":1805,"stem":1806},"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":1808,"path":1809,"stem":1810},"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":1812,"path":1813,"stem":1814},"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":1816,"path":1817,"stem":1818},"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":1820,"path":1821,"stem":1822},"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":1824,"path":1825,"stem":1826},"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":1828,"path":1829,"stem":1830},"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":1832,"path":1833,"stem":1834},"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":1836,"path":1837,"stem":1838},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":1337,"path":1840,"stem":1841},"\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":1843,"path":1844,"stem":1845,"children":1846},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[1847,1848,1870,1904,1946,1996,2052,2114,2128,2138,2176,2202],{"title":1843,"path":1844,"stem":1845},{"title":1849,"path":1850,"stem":1851,"children":1852},"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",[1853,1854,1858,1862,1866],{"title":1849,"path":1850,"stem":1851},{"title":1855,"path":1856,"stem":1857},"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":1859,"path":1860,"stem":1861},"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":1863,"path":1864,"stem":1865},"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":1867,"path":1868,"stem":1869},"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":1871,"path":1872,"stem":1873,"children":1874},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[1875,1876,1880,1884,1888,1892,1896,1900],{"title":1871,"path":1872,"stem":1873},{"title":1877,"path":1878,"stem":1879},"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":1881,"path":1882,"stem":1883},"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":1885,"path":1886,"stem":1887},"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":1889,"path":1890,"stem":1891},"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":1893,"path":1894,"stem":1895},"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":1897,"path":1898,"stem":1899},"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":1901,"path":1902,"stem":1903},"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":1905,"path":1906,"stem":1907,"children":1908},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[1909,1910,1914,1918,1922,1926,1930,1934,1938,1942],{"title":1905,"path":1906,"stem":1907},{"title":1911,"path":1912,"stem":1913},"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":1915,"path":1916,"stem":1917},"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":1919,"path":1920,"stem":1921},"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":1923,"path":1924,"stem":1925},"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":1927,"path":1928,"stem":1929},"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":1931,"path":1932,"stem":1933},"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":1935,"path":1936,"stem":1937},"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":1939,"path":1940,"stem":1941},"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":1943,"path":1944,"stem":1945},"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":1947,"path":1948,"stem":1949,"children":1950},"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",[1951,1952,1956,1960,1964,1968,1972,1976,1980,1984,1988,1992],{"title":1947,"path":1948,"stem":1949},{"title":1953,"path":1954,"stem":1955},"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":1957,"path":1958,"stem":1959},"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":1961,"path":1962,"stem":1963},"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":1965,"path":1966,"stem":1967},"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":1969,"path":1970,"stem":1971},"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":1973,"path":1974,"stem":1975},"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":1977,"path":1978,"stem":1979},"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":1981,"path":1982,"stem":1983},"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":1985,"path":1986,"stem":1987},"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":1989,"path":1990,"stem":1991},"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":1993,"path":1994,"stem":1995},"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":1997,"path":1998,"stem":1999,"children":2000},"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",[2001,2002,2006,2010,2014,2018,2022,2026,2028,2032,2036,2040,2044,2048],{"title":1997,"path":1998,"stem":1999},{"title":2003,"path":2004,"stem":2005},"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":2007,"path":2008,"stem":2009},"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":2011,"path":2012,"stem":2013},"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":2015,"path":2016,"stem":2017},"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":2019,"path":2020,"stem":2021},"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":2023,"path":2024,"stem":2025},"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":834,"path":833,"stem":2027},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F08.err56-cpp",{"title":2029,"path":2030,"stem":2031},"ERR57-CPP. Do not leak resources when handling exceptions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F09.err57-cpp",{"title":2033,"path":2034,"stem":2035},"ERR58-CPP. Handle all exceptions thrown before main() begins executing","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F10.err58-cpp",{"title":2037,"path":2038,"stem":2039},"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":2041,"path":2042,"stem":2043},"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":2045,"path":2046,"stem":2047},"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":2049,"path":2050,"stem":2051},"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":2053,"path":2054,"stem":2055,"children":2056},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[2057,2058,2062,2066,2070,2074,2078,2082,2086,2090,2094,2098,2102,2106,2110],{"title":2053,"path":2054,"stem":2055},{"title":2059,"path":2060,"stem":2061},"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":2063,"path":2064,"stem":2065},"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":2067,"path":2068,"stem":2069},"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":2071,"path":2072,"stem":2073},"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":2075,"path":2076,"stem":2077},"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":2079,"path":2080,"stem":2081},"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":2083,"path":2084,"stem":2085},"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":2087,"path":2088,"stem":2089},"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":2091,"path":2092,"stem":2093},"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":2095,"path":2096,"stem":2097},"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":2099,"path":2100,"stem":2101},"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":2103,"path":2104,"stem":2105},"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":2107,"path":2108,"stem":2109},"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":2111,"path":2112,"stem":2113},"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":2115,"path":2116,"stem":2117,"children":2118},"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",[2119,2120,2124],{"title":2115,"path":2116,"stem":2117},{"title":2121,"path":2122,"stem":2123},"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":2125,"path":2126,"stem":2127},"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":2129,"path":2130,"stem":2131,"children":2132},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[2133,2134],{"title":2129,"path":2130,"stem":2131},{"title":2135,"path":2136,"stem":2137},"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":2139,"path":2140,"stem":2141,"children":2142},"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",[2143,2144,2148,2152,2156,2160,2164,2168,2172],{"title":2139,"path":2140,"stem":2141},{"title":2145,"path":2146,"stem":2147},"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":2149,"path":2150,"stem":2151},"MEM51-CPP. Properly deallocate dynamically allocated resources","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F3.mem51-cpp",{"title":2153,"path":2154,"stem":2155},"MEM52-CPP. Detect and handle memory allocation errors","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F4.mem52-cpp",{"title":2157,"path":2158,"stem":2159},"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":2161,"path":2162,"stem":2163},"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":2165,"path":2166,"stem":2167},"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":2169,"path":2170,"stem":2171},"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":2173,"path":2174,"stem":2175},"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":2177,"path":2178,"stem":2179,"children":2180},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[2181,2182,2186,2190,2194,2198],{"title":2177,"path":2178,"stem":2179},{"title":2183,"path":2184,"stem":2185},"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":2187,"path":2188,"stem":2189},"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":2191,"path":2192,"stem":2193},"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":2195,"path":2196,"stem":2197},"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":2199,"path":2200,"stem":2201},"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":2203,"path":2204,"stem":2205,"children":2206},"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",[2207,2208,2212,2216,2220,2221,2222,2223,2227,2231],{"title":2203,"path":2204,"stem":2205},{"title":2209,"path":2210,"stem":2211},"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":2213,"path":2214,"stem":2215},"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":2217,"path":2218,"stem":2219},"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":1763,"path":1715,"stem":1764},{"title":30,"path":1757,"stem":1759},{"title":1766,"path":1729,"stem":1767},{"title":2224,"path":2225,"stem":2226},"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":2228,"path":2229,"stem":2230},"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":1632,"path":1631,"stem":2232},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F10.oop58-cpp",{"title":2234,"path":2235,"stem":2236,"children":2237},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[2238,2239,2243,2247,2428,2442],{"title":2234,"path":2235,"stem":2236},{"title":2240,"path":2241,"stem":2242},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":2244,"path":2245,"stem":2246},"BB. Definitions","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":2248,"path":2249,"stem":2250,"children":2251},"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",[2252,2253,2255,2259,2263,2267,2269,2273,2277,2281,2285,2289,2293,2295,2299,2303,2307,2311,2315,2319,2323,2327,2331,2333,2337,2339,2343,2347,2351,2354,2358,2360,2364,2368,2372,2376,2380,2384,2388,2392,2396,2400,2404,2408,2412,2416,2420,2424],{"title":2248,"path":2249,"stem":2250},{"title":1377,"path":1376,"stem":2254},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":2256,"path":2257,"stem":2258},"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":2260,"path":2261,"stem":2262},"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":2264,"path":2265,"stem":2266},"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":1410,"path":1409,"stem":2268},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":2270,"path":2271,"stem":2272},"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":2274,"path":2275,"stem":2276},"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":2278,"path":2279,"stem":2280},"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":2282,"path":2283,"stem":2284},"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":2286,"path":2287,"stem":2288},"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":2290,"path":2291,"stem":2292},"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":1436,"path":1435,"stem":2294},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":2296,"path":2297,"stem":2298},"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":2300,"path":2301,"stem":2302},"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":2304,"path":2305,"stem":2306},"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":2308,"path":2309,"stem":2310},"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":2312,"path":2313,"stem":2314},"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":2316,"path":2317,"stem":2318},"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":2320,"path":2321,"stem":2322},"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":2324,"path":2325,"stem":2326},"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":2328,"path":2329,"stem":2330},"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":1511,"path":1510,"stem":2332},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":2334,"path":2335,"stem":2336},"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":1539,"path":1538,"stem":2338},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":2340,"path":2341,"stem":2342},"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":2344,"path":2345,"stem":2346},"LDRA","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":2348,"path":2349,"stem":2350},"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":2352,"path":1561,"stem":2353},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":2355,"path":2356,"stem":2357},"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":1586,"path":1585,"stem":2359},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":2361,"path":2362,"stem":2363},"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":2365,"path":2366,"stem":2367},"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":2369,"path":2370,"stem":2371},"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":2373,"path":2374,"stem":2375},"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":2377,"path":2378,"stem":2379},"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":2381,"path":2382,"stem":2383},"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":2385,"path":2386,"stem":2387},"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":2389,"path":2390,"stem":2391},"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":2393,"path":2394,"stem":2395},"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":2397,"path":2398,"stem":2399},"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":2401,"path":2402,"stem":2403},"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":2405,"path":2406,"stem":2407},"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":2409,"path":2410,"stem":2411},"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":2413,"path":2414,"stem":2415},"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":2417,"path":2418,"stem":2419},"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":2421,"path":2422,"stem":2423},"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":2425,"path":2426,"stem":2427},"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":2429,"path":2430,"stem":2431,"children":2432},"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",[2433,2434,2438],{"title":2429,"path":2430,"stem":2431},{"title":2435,"path":2436,"stem":2437},"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":2439,"path":2440,"stem":2441},"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":2443,"path":2444,"stem":2445},"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":2447,"path":2448,"stem":2449,"children":2450},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[2451,2452],{"title":2447,"path":2448,"stem":2449},{"title":2453,"path":2454,"stem":2455},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":2457,"path":2458,"stem":2459},"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",1775657784226]