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