[{"data":1,"prerenderedAt":2932},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop57-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop57-cpp":2236,"sidebar-sei-cert-cpp-coding-standard":2243},[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":2222,"extension":2223,"meta":2224,"navigation":7,"path":2232,"seo":2233,"stem":2234,"__hash__":2235},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F09.oop57-cpp.md","OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions",{"type":32,"value":33,"toc":2208},"minimark",[34,38,51,60,94,97,122,135,214,219,225,527,539,543,553,833,836,861,1055,1058,1066,1368,1371,1388,1526,1534,1537,1545,1695,1699,1709,1770,1775,2100,2104,2117,2121,2144,2148,2180,2183,2204],[35,36,30],"h1",{"id":37},"oop57-cpp-prefer-special-member-functions-and-overloaded-operators-to-c-standard-library-functions",[39,40,41,42,46,47,50],"p",{},"Several C standard library functions perform bytewise operations on objects. For instance, ",[43,44,45],"code",{},"std::memcmp()"," compares the bytes comprising the object representation of two objects, and ",[43,48,49],{},"std::memcpy()"," copies the bytes comprising an object representation into a destination buffer. However, for some object types, it results in undefined or abnormal program behavior.",[39,52,53,54,59],{},"The C++ Standard, [class], paragraph 6 [ ",[55,56,58],"a",{"href":57},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], states the following:",[61,62,63],"blockquote",{},[39,64,65,66,70,71,74,75,77,78,80,81,83,84,86,87,89,90,93],{},"A ",[67,68,69],"em",{},"trivially copyable class"," is a class that:",[72,73],"br",{},"\n— has no non-trivial copy constructors,",[72,76],{},"\n— has no non-trivial move constructors,",[72,79],{},"\n— has no non-trivial copy assignment operators,",[72,82],{},"\n— has no non-trivial move assignment operators, and",[72,85],{},"\n— has a trivial destructor.",[72,88],{},"\nA ",[67,91,92],{},"trivial class"," is a class that has a default constructor, has no non-trivial default constructors, and is trivially copyable. [ Note: In particular, a trivially copyable or trivial class does not have virtual functions or virtual base classes. — end note ]",[39,95,96],{},"Additionally, the C++ Standard, [class], paragraph 7, states the following:",[61,98,99],{},[39,100,65,101,70,104,106,107,109,110,112,113,115,116,118,119,121],{},[67,102,103],{},"standard-layout class",[72,105],{},"\n— has no non-static data members of type non-standard-layout class (or array of such types) or reference,",[72,108],{},"\n— has no virtual functions and no virtual base classes,",[72,111],{},"\n— has the same access control for all non-static data members,",[72,114],{},"\n— has no non-standard-layout base classes,",[72,117],{},"\n— either has no non-static data members in the most derived class and at most one base class with non-static data members, or has no base classes with non-static data members, and",[72,120],{},"\n— has no base classes of the same type as the first non-static data member.",[39,123,124,125,128,129,131,132,134],{},"Do not use ",[43,126,127],{},"std::memset()"," to initialize an object of nontrivial class type as it may not properly initialize the value representation of the object. Do not use ",[43,130,49],{}," (or related bytewise copy functions) to initialize a copy of an object of nontrivial class type, as it may not properly initialize the value representation of the copy. Do not use ",[43,133,45],{}," (or related bytewise comparison functions) to compare objects of nonstandard-layout class type, as it may not properly compare the value representations of the objects. In all cases, it is best to prefer the alternatives.",[136,137,138,149],"table",{},[139,140,141],"thead",{},[142,143,144,147],"tr",{},[145,146],"th",{},[145,148],{},[150,151,152,161,170,189],"tbody",{},[142,153,154,158],{},[155,156,157],"td",{},"C Standard Library Function",[155,159,160],{},"C++ Equivalent Functionality",[142,162,163,167],{},[155,164,165],{},[43,166,127],{},[155,168,169],{},"Class constructor",[142,171,172,183],{},[155,173,174,176,177,176,180],{},[43,175,49],{}," ",[43,178,179],{},"std::memmove()",[43,181,182],{},"std::strcpy()",[155,184,185,186],{},"Class copy constructor or ",[43,187,188],{},"operator=()",[142,190,191,198],{},[155,192,193,176,195],{},[43,194,45],{},[43,196,197],{},"std::strcmp()",[155,199,200,203,204,203,207,210,211],{},[43,201,202],{},"operator\u003C()"," , ",[43,205,206],{},"operator>()",[43,208,209],{},"operator==()"," , or ",[43,212,213],{},"operator!=()",[215,216,218],"h2",{"id":217},"noncompliant-code-example","Noncompliant Code Example",[39,220,221,222,224],{},"In this noncompliant code example, a nontrivial class object is initialized by calling its default constructor but is later reinitialized to its default state using ",[43,223,127],{}," , which does not properly reinitialize the object. Improper reinitialization leads to class invariants not holding in later uses of the object.",[226,227,229],"code-block",{"quality":228},"bad",[230,231,236],"pre",{"className":232,"code":233,"language":234,"meta":235,"style":235},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Ccstring>\n#include \u003Ciostream>\n \nclass C {\n  int scalingFactor;\n  int otherData;\n \npublic:\n  C() : scalingFactor(1) {}\n  \n  void set_other_data(int i);\n  int f(int i) {\n    return i \u002F scalingFactor;\n  }\n  \u002F\u002F ...\n};\n \nvoid f() {\n  C c;\n  \n  \u002F\u002F ... Code that mutates c ... \n  \n  \u002F\u002F Reinitialize c to its default state\n  std::memset(&c, 0, sizeof(C));\n  \n  std::cout \u003C\u003C c.f(100) \u003C\u003C std::endl;\n}\n","cpp","",[43,237,238,251,259,266,280,289,297,302,308,331,337,358,375,388,394,401,407,412,423,429,434,440,445,451,483,488,521],{"__ignoreMap":235},[239,240,243,247],"span",{"class":241,"line":242},"line",1,[239,244,246],{"class":245},"sC2Qs","#include",[239,248,250],{"class":249},"sstjo"," \u003Ccstring>\n",[239,252,254,256],{"class":241,"line":253},2,[239,255,246],{"class":245},[239,257,258],{"class":249}," \u003Ciostream>\n",[239,260,262],{"class":241,"line":261},3,[239,263,265],{"class":264},"sMOD_"," \n",[239,267,269,273,277],{"class":241,"line":268},4,[239,270,272],{"class":271},"sq6CD","class",[239,274,276],{"class":275},"sz2Vg"," C",[239,278,279],{"class":264}," {\n",[239,281,283,286],{"class":241,"line":282},5,[239,284,285],{"class":271},"  int",[239,287,288],{"class":264}," scalingFactor;\n",[239,290,292,294],{"class":241,"line":291},6,[239,293,285],{"class":271},[239,295,296],{"class":264}," otherData;\n",[239,298,300],{"class":241,"line":299},7,[239,301,265],{"class":264},[239,303,305],{"class":241,"line":304},8,[239,306,307],{"class":271},"public:\n",[239,309,311,315,318,321,324,328],{"class":241,"line":310},9,[239,312,314],{"class":313},"srTi1","  C",[239,316,317],{"class":264},"() : ",[239,319,320],{"class":313},"scalingFactor",[239,322,323],{"class":264},"(",[239,325,327],{"class":326},"s7F3e","1",[239,329,330],{"class":264},") {}\n",[239,332,334],{"class":241,"line":333},10,[239,335,336],{"class":264},"  \n",[239,338,340,343,346,348,351,355],{"class":241,"line":339},11,[239,341,342],{"class":271},"  void",[239,344,345],{"class":313}," set_other_data",[239,347,323],{"class":264},[239,349,350],{"class":271},"int",[239,352,354],{"class":353},"sTHNf"," i",[239,356,357],{"class":264},");\n",[239,359,361,363,366,368,370,372],{"class":241,"line":360},12,[239,362,285],{"class":271},[239,364,365],{"class":313}," f",[239,367,323],{"class":264},[239,369,350],{"class":271},[239,371,354],{"class":353},[239,373,374],{"class":264},") {\n",[239,376,378,381,384,386],{"class":241,"line":377},13,[239,379,380],{"class":245},"    return",[239,382,383],{"class":264}," i ",[239,385,6],{"class":245},[239,387,288],{"class":264},[239,389,391],{"class":241,"line":390},14,[239,392,393],{"class":264},"  }\n",[239,395,397],{"class":241,"line":396},15,[239,398,400],{"class":399},"s8-w5","  \u002F\u002F ...\n",[239,402,404],{"class":241,"line":403},16,[239,405,406],{"class":264},"};\n",[239,408,410],{"class":241,"line":409},17,[239,411,265],{"class":264},[239,413,415,418,420],{"class":241,"line":414},18,[239,416,417],{"class":271},"void",[239,419,365],{"class":313},[239,421,422],{"class":264},"() {\n",[239,424,426],{"class":241,"line":425},19,[239,427,428],{"class":264},"  C c;\n",[239,430,432],{"class":241,"line":431},20,[239,433,336],{"class":264},[239,435,437],{"class":241,"line":436},21,[239,438,439],{"class":399},"  \u002F\u002F ... Code that mutates c ... \n",[239,441,443],{"class":241,"line":442},22,[239,444,336],{"class":264},[239,446,448],{"class":241,"line":447},23,[239,449,450],{"class":399},"  \u002F\u002F Reinitialize c to its default state\n",[239,452,454,457,460,463,465,468,471,474,477,480],{"class":241,"line":453},24,[239,455,456],{"class":275},"  std",[239,458,459],{"class":264},"::",[239,461,462],{"class":313},"memset",[239,464,323],{"class":264},[239,466,467],{"class":245},"&",[239,469,470],{"class":264},"c, ",[239,472,473],{"class":326},"0",[239,475,476],{"class":264},", ",[239,478,479],{"class":245},"sizeof",[239,481,482],{"class":264},"(C));\n",[239,484,486],{"class":241,"line":485},25,[239,487,336],{"class":264},[239,489,491,493,496,499,502,505,507,510,513,515,518],{"class":241,"line":490},26,[239,492,456],{"class":275},[239,494,495],{"class":264},"::cout ",[239,497,498],{"class":245},"\u003C\u003C",[239,500,501],{"class":264}," c.",[239,503,504],{"class":313},"f",[239,506,323],{"class":264},[239,508,509],{"class":326},"100",[239,511,512],{"class":264},") ",[239,514,498],{"class":245},[239,516,517],{"class":275}," std",[239,519,520],{"class":264},"::endl;\n",[239,522,524],{"class":241,"line":523},27,[239,525,526],{"class":264},"}\n",[39,528,529,530,534,535,538],{},"The above noncompliant code example is compliant with ",[55,531,533],{"href":532},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp62-cpp","EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation"," because all of the bits in the value representation are also used in the object representation of ",[43,536,537],{},"C"," .",[215,540,542],{"id":541},"compliant-solution","Compliant Solution",[39,544,545,546,548,549,552],{},"In this compliant solution, the call to ",[43,547,127],{}," is replaced with a default-initialized copy-and-swap operation called ",[43,550,551],{},"clear()"," . This operation ensures that the object is initialized to its default state properly, and it behaves properly for object types that have optimized assignment operators that fail to clear all data members of the object being assigned into.",[226,554,556],{"quality":555},"good",[230,557,559],{"className":232,"code":558,"language":234,"meta":235,"style":235},"#include \u003Ciostream>\n#include \u003Cutility>\n \nclass C {\n  int scalingFactor;\n  int otherData;\n \npublic:\n  C() : scalingFactor(1) {}\n  \n  void set_other_data(int i);\n  int f(int i) {\n    return i \u002F scalingFactor;\n  }\n  \u002F\u002F ...\n};\n \ntemplate \u003Ctypename T>\nT& clear(T &o) {\n  using std::swap;\n  T empty;\n  swap(o, empty);\n  return o;\n}\n\nvoid f() {\n  C c;\n  \n  \u002F\u002F ... Code that mutates c ... \n  \n  \u002F\u002F Reinitialize c to its default state\n  clear(c);\n  \n  std::cout \u003C\u003C c.f(100) \u003C\u003C std::endl;\n}\n",[43,560,561,567,574,578,586,592,598,602,606,620,624,638,652,662,666,670,674,678,695,717,727,732,740,748,752,757,765,769,774,779,784,789,798,803,828],{"__ignoreMap":235},[239,562,563,565],{"class":241,"line":242},[239,564,246],{"class":245},[239,566,258],{"class":249},[239,568,569,571],{"class":241,"line":253},[239,570,246],{"class":245},[239,572,573],{"class":249}," \u003Cutility>\n",[239,575,576],{"class":241,"line":261},[239,577,265],{"class":264},[239,579,580,582,584],{"class":241,"line":268},[239,581,272],{"class":271},[239,583,276],{"class":275},[239,585,279],{"class":264},[239,587,588,590],{"class":241,"line":282},[239,589,285],{"class":271},[239,591,288],{"class":264},[239,593,594,596],{"class":241,"line":291},[239,595,285],{"class":271},[239,597,296],{"class":264},[239,599,600],{"class":241,"line":299},[239,601,265],{"class":264},[239,603,604],{"class":241,"line":304},[239,605,307],{"class":271},[239,607,608,610,612,614,616,618],{"class":241,"line":310},[239,609,314],{"class":313},[239,611,317],{"class":264},[239,613,320],{"class":313},[239,615,323],{"class":264},[239,617,327],{"class":326},[239,619,330],{"class":264},[239,621,622],{"class":241,"line":333},[239,623,336],{"class":264},[239,625,626,628,630,632,634,636],{"class":241,"line":339},[239,627,342],{"class":271},[239,629,345],{"class":313},[239,631,323],{"class":264},[239,633,350],{"class":271},[239,635,354],{"class":353},[239,637,357],{"class":264},[239,639,640,642,644,646,648,650],{"class":241,"line":360},[239,641,285],{"class":271},[239,643,365],{"class":313},[239,645,323],{"class":264},[239,647,350],{"class":271},[239,649,354],{"class":353},[239,651,374],{"class":264},[239,653,654,656,658,660],{"class":241,"line":377},[239,655,380],{"class":245},[239,657,383],{"class":264},[239,659,6],{"class":245},[239,661,288],{"class":264},[239,663,664],{"class":241,"line":390},[239,665,393],{"class":264},[239,667,668],{"class":241,"line":396},[239,669,400],{"class":399},[239,671,672],{"class":241,"line":403},[239,673,406],{"class":264},[239,675,676],{"class":241,"line":409},[239,677,265],{"class":264},[239,679,680,683,686,689,692],{"class":241,"line":414},[239,681,682],{"class":271},"template",[239,684,685],{"class":264}," \u003C",[239,687,688],{"class":271},"typename",[239,690,691],{"class":275}," T",[239,693,694],{"class":264},">\n",[239,696,697,700,702,705,707,709,712,715],{"class":241,"line":425},[239,698,699],{"class":275},"T",[239,701,467],{"class":245},[239,703,704],{"class":313}," clear",[239,706,323],{"class":264},[239,708,699],{"class":275},[239,710,711],{"class":245}," &",[239,713,714],{"class":353},"o",[239,716,374],{"class":264},[239,718,719,722,724],{"class":241,"line":431},[239,720,721],{"class":245},"  using",[239,723,517],{"class":275},[239,725,726],{"class":264},"::swap;\n",[239,728,729],{"class":241,"line":436},[239,730,731],{"class":264},"  T empty;\n",[239,733,734,737],{"class":241,"line":442},[239,735,736],{"class":313},"  swap",[239,738,739],{"class":264},"(o, empty);\n",[239,741,742,745],{"class":241,"line":447},[239,743,744],{"class":245},"  return",[239,746,747],{"class":264}," o;\n",[239,749,750],{"class":241,"line":453},[239,751,526],{"class":264},[239,753,754],{"class":241,"line":485},[239,755,756],{"emptyLinePlaceholder":7},"\n",[239,758,759,761,763],{"class":241,"line":490},[239,760,417],{"class":271},[239,762,365],{"class":313},[239,764,422],{"class":264},[239,766,767],{"class":241,"line":523},[239,768,428],{"class":264},[239,770,772],{"class":241,"line":771},28,[239,773,336],{"class":264},[239,775,777],{"class":241,"line":776},29,[239,778,439],{"class":399},[239,780,782],{"class":241,"line":781},30,[239,783,336],{"class":264},[239,785,787],{"class":241,"line":786},31,[239,788,450],{"class":399},[239,790,792,795],{"class":241,"line":791},32,[239,793,794],{"class":313},"  clear",[239,796,797],{"class":264},"(c);\n",[239,799,801],{"class":241,"line":800},33,[239,802,336],{"class":264},[239,804,806,808,810,812,814,816,818,820,822,824,826],{"class":241,"line":805},34,[239,807,456],{"class":275},[239,809,495],{"class":264},[239,811,498],{"class":245},[239,813,501],{"class":264},[239,815,504],{"class":313},[239,817,323],{"class":264},[239,819,509],{"class":326},[239,821,512],{"class":264},[239,823,498],{"class":245},[239,825,517],{"class":275},[239,827,520],{"class":264},[239,829,831],{"class":241,"line":830},35,[239,832,526],{"class":264},[215,834,218],{"id":835},"noncompliant-code-example-1",[39,837,838,839,841,842,844,845,848,849,852,853,857,858,538],{},"In this noncompliant code example, ",[43,840,49],{}," is used to create a copy of an object of nontrivial type ",[43,843,537],{}," . However, because each object instance attempts to delete the ",[43,846,847],{},"  int * ","in",[43,850,851],{},"  C::~C() "," , double-free ",[55,854,856],{"href":855},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," may occur because the same pointer value will be copied into ",[43,859,860],{},"c2",[226,862,863],{"quality":228},[230,864,866],{"className":232,"code":865,"language":234,"meta":235,"style":235},"#include \u003Ccstring>\n \nclass C {\n  int *i;\n \npublic:\n  C() : i(nullptr) {}\n  ~C() { delete i; }\n \n  void set(int val) {\n    if (i) { delete i; }\n    i = new int{val};\n  }\n \n  \u002F\u002F ...\n};\n \nvoid f(C &c1) {\n  C c2;\n  std::memcpy(&c2, &c1, sizeof(C));  \n}\n",[43,867,868,874,878,886,896,900,904,920,934,938,954,966,983,987,991,995,999,1003,1020,1025,1051],{"__ignoreMap":235},[239,869,870,872],{"class":241,"line":242},[239,871,246],{"class":245},[239,873,250],{"class":249},[239,875,876],{"class":241,"line":253},[239,877,265],{"class":264},[239,879,880,882,884],{"class":241,"line":261},[239,881,272],{"class":271},[239,883,276],{"class":275},[239,885,279],{"class":264},[239,887,888,890,893],{"class":241,"line":268},[239,889,285],{"class":271},[239,891,892],{"class":245}," *",[239,894,895],{"class":264},"i;\n",[239,897,898],{"class":241,"line":282},[239,899,265],{"class":264},[239,901,902],{"class":241,"line":291},[239,903,307],{"class":271},[239,905,906,908,910,913,915,918],{"class":241,"line":299},[239,907,314],{"class":313},[239,909,317],{"class":264},[239,911,912],{"class":313},"i",[239,914,323],{"class":264},[239,916,917],{"class":326},"nullptr",[239,919,330],{"class":264},[239,921,922,925,928,931],{"class":241,"line":304},[239,923,924],{"class":313},"  ~C",[239,926,927],{"class":264},"() { ",[239,929,930],{"class":245},"delete",[239,932,933],{"class":264}," i; }\n",[239,935,936],{"class":241,"line":310},[239,937,265],{"class":264},[239,939,940,942,945,947,949,952],{"class":241,"line":333},[239,941,342],{"class":271},[239,943,944],{"class":313}," set",[239,946,323],{"class":264},[239,948,350],{"class":271},[239,950,951],{"class":353}," val",[239,953,374],{"class":264},[239,955,956,959,962,964],{"class":241,"line":339},[239,957,958],{"class":245},"    if",[239,960,961],{"class":264}," (i) { ",[239,963,930],{"class":245},[239,965,933],{"class":264},[239,967,968,971,974,977,980],{"class":241,"line":360},[239,969,970],{"class":264},"    i ",[239,972,973],{"class":245},"=",[239,975,976],{"class":245}," new",[239,978,979],{"class":271}," int",[239,981,982],{"class":264},"{val};\n",[239,984,985],{"class":241,"line":377},[239,986,393],{"class":264},[239,988,989],{"class":241,"line":390},[239,990,265],{"class":264},[239,992,993],{"class":241,"line":396},[239,994,400],{"class":399},[239,996,997],{"class":241,"line":403},[239,998,406],{"class":264},[239,1000,1001],{"class":241,"line":409},[239,1002,265],{"class":264},[239,1004,1005,1007,1009,1011,1013,1015,1018],{"class":241,"line":414},[239,1006,417],{"class":271},[239,1008,365],{"class":313},[239,1010,323],{"class":264},[239,1012,537],{"class":275},[239,1014,711],{"class":245},[239,1016,1017],{"class":353},"c1",[239,1019,374],{"class":264},[239,1021,1022],{"class":241,"line":425},[239,1023,1024],{"class":264},"  C c2;\n",[239,1026,1027,1029,1031,1034,1036,1038,1041,1043,1046,1048],{"class":241,"line":431},[239,1028,456],{"class":275},[239,1030,459],{"class":264},[239,1032,1033],{"class":313},"memcpy",[239,1035,323],{"class":264},[239,1037,467],{"class":245},[239,1039,1040],{"class":264},"c2, ",[239,1042,467],{"class":245},[239,1044,1045],{"class":264},"c1, ",[239,1047,479],{"class":245},[239,1049,1050],{"class":264},"(C));  \n",[239,1052,1053],{"class":241,"line":436},[239,1054,526],{"class":264},[215,1056,542],{"id":1057},"compliant-solution-1",[39,1059,1060,1061,1063,1064,538],{},"In this compliant solution, ",[43,1062,537],{}," defines an assignment operator that is used instead of calling ",[43,1065,49],{},[226,1067,1068],{"quality":555},[230,1069,1071],{"className":232,"code":1070,"language":234,"meta":235,"style":235},"class C {\n  int *i;\n \npublic:\n  C() : i(nullptr) {}\n  ~C() { delete i; }\n \n  void set(int val) {\n    if (i) { delete i; }\n    i = new int{val};\n  }\n\n  C &operator=(const C &rhs) noexcept(false) {\n    if (this != &rhs) {\n      int *o = nullptr;\n      if (rhs.i) {\n        o = new int;\n        *o = *rhs.i;\n      }\n      \u002F\u002F Does not modify this unless allocation succeeds.\n      delete i;\n      i = o;\n    }\n    return *this;\n  }\n \n  \u002F\u002F ...\n};\n \nvoid f(C &c1) {\n  C c2 = c1;\n}\n",[43,1072,1073,1081,1089,1094,1098,1112,1122,1126,1140,1150,1162,1166,1170,1204,1223,1241,1249,1262,1276,1281,1286,1294,1303,1308,1318,1322,1326,1330,1334,1338,1354,1364],{"__ignoreMap":235},[239,1074,1075,1077,1079],{"class":241,"line":242},[239,1076,272],{"class":271},[239,1078,276],{"class":275},[239,1080,279],{"class":264},[239,1082,1083,1085,1087],{"class":241,"line":253},[239,1084,285],{"class":271},[239,1086,892],{"class":245},[239,1088,895],{"class":264},[239,1090,1091],{"class":241,"line":261},[239,1092,1093],{"class":264}," \n",[239,1095,1096],{"class":241,"line":268},[239,1097,307],{"class":271},[239,1099,1100,1102,1104,1106,1108,1110],{"class":241,"line":282},[239,1101,314],{"class":313},[239,1103,317],{"class":264},[239,1105,912],{"class":313},[239,1107,323],{"class":264},[239,1109,917],{"class":326},[239,1111,330],{"class":264},[239,1113,1114,1116,1118,1120],{"class":241,"line":291},[239,1115,924],{"class":313},[239,1117,927],{"class":264},[239,1119,930],{"class":245},[239,1121,933],{"class":264},[239,1123,1124],{"class":241,"line":299},[239,1125,1093],{"class":264},[239,1127,1128,1130,1132,1134,1136,1138],{"class":241,"line":304},[239,1129,342],{"class":271},[239,1131,944],{"class":313},[239,1133,323],{"class":264},[239,1135,350],{"class":271},[239,1137,951],{"class":353},[239,1139,374],{"class":264},[239,1141,1142,1144,1146,1148],{"class":241,"line":310},[239,1143,958],{"class":245},[239,1145,961],{"class":264},[239,1147,930],{"class":245},[239,1149,933],{"class":264},[239,1151,1152,1154,1156,1158,1160],{"class":241,"line":333},[239,1153,970],{"class":264},[239,1155,973],{"class":245},[239,1157,976],{"class":245},[239,1159,979],{"class":271},[239,1161,982],{"class":264},[239,1163,1164],{"class":241,"line":339},[239,1165,393],{"class":264},[239,1167,1168],{"class":241,"line":360},[239,1169,756],{"emptyLinePlaceholder":7},[239,1171,1172,1174,1177,1180,1182,1185,1187,1189,1192,1194,1197,1199,1202],{"class":241,"line":377},[239,1173,314],{"class":275},[239,1175,1176],{"class":245}," &operator",[239,1178,973],{"class":1179},"s_OQ2",[239,1181,323],{"class":264},[239,1183,1184],{"class":245},"const",[239,1186,276],{"class":275},[239,1188,711],{"class":245},[239,1190,1191],{"class":353},"rhs",[239,1193,512],{"class":264},[239,1195,1196],{"class":245},"noexcept",[239,1198,323],{"class":264},[239,1200,1201],{"class":326},"false",[239,1203,374],{"class":264},[239,1205,1206,1208,1211,1215,1218,1220],{"class":241,"line":390},[239,1207,958],{"class":245},[239,1209,1210],{"class":264}," (",[239,1212,1214],{"class":1213},"sP7S_","this",[239,1216,1217],{"class":245}," !=",[239,1219,711],{"class":245},[239,1221,1222],{"class":264},"rhs) {\n",[239,1224,1225,1228,1230,1233,1235,1238],{"class":241,"line":396},[239,1226,1227],{"class":271},"      int",[239,1229,892],{"class":245},[239,1231,1232],{"class":264},"o ",[239,1234,973],{"class":245},[239,1236,1237],{"class":326}," nullptr",[239,1239,1240],{"class":264},";\n",[239,1242,1243,1246],{"class":241,"line":403},[239,1244,1245],{"class":245},"      if",[239,1247,1248],{"class":264}," (rhs.i) {\n",[239,1250,1251,1254,1256,1258,1260],{"class":241,"line":409},[239,1252,1253],{"class":264},"        o ",[239,1255,973],{"class":245},[239,1257,976],{"class":245},[239,1259,979],{"class":271},[239,1261,1240],{"class":264},[239,1263,1264,1267,1269,1271,1273],{"class":241,"line":414},[239,1265,1266],{"class":245},"        *",[239,1268,1232],{"class":264},[239,1270,973],{"class":245},[239,1272,892],{"class":245},[239,1274,1275],{"class":264},"rhs.i;\n",[239,1277,1278],{"class":241,"line":425},[239,1279,1280],{"class":264},"      }\n",[239,1282,1283],{"class":241,"line":431},[239,1284,1285],{"class":399},"      \u002F\u002F Does not modify this unless allocation succeeds.\n",[239,1287,1288,1291],{"class":241,"line":436},[239,1289,1290],{"class":245},"      delete",[239,1292,1293],{"class":264}," i;\n",[239,1295,1296,1299,1301],{"class":241,"line":442},[239,1297,1298],{"class":264},"      i ",[239,1300,973],{"class":245},[239,1302,747],{"class":264},[239,1304,1305],{"class":241,"line":447},[239,1306,1307],{"class":264},"    }\n",[239,1309,1310,1312,1314,1316],{"class":241,"line":453},[239,1311,380],{"class":245},[239,1313,892],{"class":245},[239,1315,1214],{"class":1213},[239,1317,1240],{"class":264},[239,1319,1320],{"class":241,"line":485},[239,1321,393],{"class":264},[239,1323,1324],{"class":241,"line":490},[239,1325,1093],{"class":264},[239,1327,1328],{"class":241,"line":523},[239,1329,400],{"class":399},[239,1331,1332],{"class":241,"line":771},[239,1333,406],{"class":264},[239,1335,1336],{"class":241,"line":776},[239,1337,1093],{"class":264},[239,1339,1340,1342,1344,1346,1348,1350,1352],{"class":241,"line":781},[239,1341,417],{"class":271},[239,1343,365],{"class":313},[239,1345,323],{"class":264},[239,1347,537],{"class":275},[239,1349,711],{"class":245},[239,1351,1017],{"class":353},[239,1353,374],{"class":264},[239,1355,1356,1359,1361],{"class":241,"line":786},[239,1357,1358],{"class":264},"  C c2 ",[239,1360,973],{"class":245},[239,1362,1363],{"class":264}," c1;\n",[239,1365,1366],{"class":241,"line":791},[239,1367,526],{"class":264},[215,1369,218],{"id":1370},"noncompliant-code-example-2",[39,1372,838,1373,1375,1376,1378,1379,1381,1382,1384,1385,1387],{},[43,1374,45],{}," is used to compared two objects of nonstandard-layout type. Because ",[43,1377,45],{}," performs a bytewise comparison of the object representations, if the implementation uses a vtable pointer as part of the object representation, it will compare vtable pointers. If the dynamic type of either ",[43,1380,1017],{}," or ",[43,1383,860],{}," is a derived class of type ",[43,1386,537],{}," , the comparison may fail despite the value representation of either object.",[226,1389,1390],{"quality":228},[230,1391,1393],{"className":232,"code":1392,"language":234,"meta":235,"style":235},"#include \u003Ccstring>\n \nclass C {\n  int i;\n \npublic:\n  virtual void f();\n  \n  \u002F\u002F ...\n};\n \nvoid f(C &c1, C &c2) {\n  if (!std::memcmp(&c1, &c2, sizeof(C))) {\n    \u002F\u002F ...\n  }\n}\n",[43,1394,1395,1401,1405,1413,1419,1423,1427,1440,1444,1448,1452,1456,1480,1513,1518,1522],{"__ignoreMap":235},[239,1396,1397,1399],{"class":241,"line":242},[239,1398,246],{"class":245},[239,1400,250],{"class":249},[239,1402,1403],{"class":241,"line":253},[239,1404,265],{"class":264},[239,1406,1407,1409,1411],{"class":241,"line":261},[239,1408,272],{"class":271},[239,1410,276],{"class":275},[239,1412,279],{"class":264},[239,1414,1415,1417],{"class":241,"line":268},[239,1416,285],{"class":271},[239,1418,1293],{"class":264},[239,1420,1421],{"class":241,"line":282},[239,1422,1093],{"class":264},[239,1424,1425],{"class":241,"line":291},[239,1426,307],{"class":271},[239,1428,1429,1432,1435,1437],{"class":241,"line":299},[239,1430,1431],{"class":245},"  virtual",[239,1433,1434],{"class":271}," void",[239,1436,365],{"class":313},[239,1438,1439],{"class":264},"();\n",[239,1441,1442],{"class":241,"line":304},[239,1443,336],{"class":264},[239,1445,1446],{"class":241,"line":310},[239,1447,400],{"class":399},[239,1449,1450],{"class":241,"line":333},[239,1451,406],{"class":264},[239,1453,1454],{"class":241,"line":339},[239,1455,1093],{"class":264},[239,1457,1458,1460,1462,1464,1466,1468,1470,1472,1474,1476,1478],{"class":241,"line":360},[239,1459,417],{"class":271},[239,1461,365],{"class":313},[239,1463,323],{"class":264},[239,1465,537],{"class":275},[239,1467,711],{"class":245},[239,1469,1017],{"class":353},[239,1471,476],{"class":264},[239,1473,537],{"class":275},[239,1475,711],{"class":245},[239,1477,860],{"class":353},[239,1479,374],{"class":264},[239,1481,1482,1485,1487,1490,1493,1495,1498,1500,1502,1504,1506,1508,1510],{"class":241,"line":377},[239,1483,1484],{"class":245},"  if",[239,1486,1210],{"class":264},[239,1488,1489],{"class":245},"!",[239,1491,1492],{"class":275},"std",[239,1494,459],{"class":264},[239,1496,1497],{"class":313},"memcmp",[239,1499,323],{"class":264},[239,1501,467],{"class":245},[239,1503,1045],{"class":264},[239,1505,467],{"class":245},[239,1507,1040],{"class":264},[239,1509,479],{"class":245},[239,1511,1512],{"class":264},"(C))) {\n",[239,1514,1515],{"class":241,"line":390},[239,1516,1517],{"class":399},"    \u002F\u002F ...\n",[239,1519,1520],{"class":241,"line":396},[239,1521,393],{"class":264},[239,1523,1524],{"class":241,"line":403},[239,1525,526],{"class":264},[39,1527,1528,1529,1531,1532,538],{},"Because a vtable is not part of an object's value representation, comparing it with ",[43,1530,45],{}," also violates ",[55,1533,533],{"href":532},[215,1535,542],{"id":1536},"compliant-solution-2",[39,1538,1060,1539,1541,1542,1544],{},[43,1540,537],{}," defines an equality operator that is used instead of calling ",[43,1543,45],{}," . This solution ensures that only the value representation of the objects is considered when performing the comparison.",[226,1546,1547],{"quality":555},[230,1548,1550],{"className":232,"code":1549,"language":234,"meta":235,"style":235},"class C {\n  int i;\n \npublic:\n  virtual void f();\n  \n  bool operator==(const C &rhs) const {\n    return rhs.i == i;\n  }\n\n  \u002F\u002F ...\n};\n \nvoid f(C &c1, C &c2) {\n  if (c1 == c2) {\n    \u002F\u002F ...\n  }\n}\n",[43,1551,1552,1560,1566,1570,1574,1584,1589,1616,1627,1631,1635,1639,1643,1647,1671,1683,1687,1691],{"__ignoreMap":235},[239,1553,1554,1556,1558],{"class":241,"line":242},[239,1555,272],{"class":271},[239,1557,276],{"class":275},[239,1559,279],{"class":264},[239,1561,1562,1564],{"class":241,"line":253},[239,1563,285],{"class":271},[239,1565,1293],{"class":264},[239,1567,1568],{"class":241,"line":261},[239,1569,1093],{"class":264},[239,1571,1572],{"class":241,"line":268},[239,1573,307],{"class":271},[239,1575,1576,1578,1580,1582],{"class":241,"line":282},[239,1577,1431],{"class":245},[239,1579,1434],{"class":271},[239,1581,365],{"class":313},[239,1583,1439],{"class":264},[239,1585,1586],{"class":241,"line":291},[239,1587,1588],{"class":264},"  \n",[239,1590,1591,1594,1597,1600,1602,1604,1606,1608,1610,1612,1614],{"class":241,"line":299},[239,1592,1593],{"class":271},"  bool",[239,1595,1596],{"class":245}," operator",[239,1598,1599],{"class":1179},"==",[239,1601,323],{"class":264},[239,1603,1184],{"class":245},[239,1605,276],{"class":275},[239,1607,711],{"class":245},[239,1609,1191],{"class":353},[239,1611,512],{"class":264},[239,1613,1184],{"class":245},[239,1615,279],{"class":264},[239,1617,1618,1620,1623,1625],{"class":241,"line":304},[239,1619,380],{"class":245},[239,1621,1622],{"class":264}," rhs.i ",[239,1624,1599],{"class":245},[239,1626,1293],{"class":264},[239,1628,1629],{"class":241,"line":310},[239,1630,393],{"class":264},[239,1632,1633],{"class":241,"line":333},[239,1634,756],{"emptyLinePlaceholder":7},[239,1636,1637],{"class":241,"line":339},[239,1638,400],{"class":399},[239,1640,1641],{"class":241,"line":360},[239,1642,406],{"class":264},[239,1644,1645],{"class":241,"line":377},[239,1646,1093],{"class":264},[239,1648,1649,1651,1653,1655,1657,1659,1661,1663,1665,1667,1669],{"class":241,"line":390},[239,1650,417],{"class":271},[239,1652,365],{"class":313},[239,1654,323],{"class":264},[239,1656,537],{"class":275},[239,1658,711],{"class":245},[239,1660,1017],{"class":353},[239,1662,476],{"class":264},[239,1664,537],{"class":275},[239,1666,711],{"class":245},[239,1668,860],{"class":353},[239,1670,374],{"class":264},[239,1672,1673,1675,1678,1680],{"class":241,"line":396},[239,1674,1484],{"class":245},[239,1676,1677],{"class":264}," (c1 ",[239,1679,1599],{"class":245},[239,1681,1682],{"class":264}," c2) {\n",[239,1684,1685],{"class":241,"line":403},[239,1686,1517],{"class":399},[239,1688,1689],{"class":241,"line":409},[239,1690,393],{"class":264},[239,1692,1693],{"class":241,"line":414},[239,1694,526],{"class":264},[215,1696,1698],{"id":1697},"risk-assessment","Risk Assessment",[39,1700,1701,1702,1706,1707,538],{},"Most violations of this rule will result in abnormal program behavior. However, overwriting ",[55,1703,1705],{"href":1704},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","implementation"," details of the object representation can lead to code execution ",[55,1708,856],{"href":855},[136,1710,1711,1712,1711,1739],{},"\n  ",[139,1713,1714,1715,1711],{},"\n    ",[142,1716,1717,1718,1717,1721,1717,1724,1717,1727,1717,1730,1717,1733,1717,1736,1714],{},"\n      ",[145,1719,1720],{},"Rule",[145,1722,1723],{},"Severity",[145,1725,1726],{},"Likelihood",[145,1728,1729],{},"Detectable",[145,1731,1732],{},"Repairable",[145,1734,1735],{},"Priority",[145,1737,1738],{},"Level",[150,1740,1714,1741,1711],{},[142,1742,1717,1743,1717,1746,1717,1749,1717,1752,1717,1755,1717,1758,1717,1765,1714],{},[155,1744,1745],{},"OOP57-CPP",[155,1747,1748],{},"High",[155,1750,1751],{},"Probable",[155,1753,1754],{},"Yes",[155,1756,1757],{},"No",[155,1759,1761],{"style":1760},"color: #e74c3c;",[1762,1763,1764],"b",{},"P12",[155,1766,1767],{"style":1760},[1762,1768,1769],{},"L1",[1771,1772,1774],"h3",{"id":1773},"automated-detection","Automated Detection",[136,1776,1779],{"className":1777},[1778],"wrapped",[150,1780,1781,1805,1851,1887,1913,1938,1969,2005,2031,2066],{},[142,1782,1785,1790,1795,1800],{"className":1783},[1784],"header",[145,1786,1787],{},[39,1788,1789],{},"Tool",[145,1791,1792],{},[39,1793,1794],{},"Version",[145,1796,1797],{},[39,1798,1799],{},"Checker",[145,1801,1802],{},[39,1803,1804],{},"Description",[142,1806,1809,1815,1825,1848],{"className":1807},[1808],"odd",[155,1810,1811],{},[55,1812,1814],{"href":1813},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","Astrée",[155,1816,1817],{},[1818,1819,1822],"div",{"className":1820},[1821],"content-wrapper",[39,1823,1824],{},"25.10",[155,1826,1827],{},[1828,1829,1830,1831,1833,1834,1836,1837,1839,1840,1842,1843,1845,1846],"strong",{},"stdlib-use-ato",[72,1832],{},"\nstdlib-use",[72,1835],{},"\nstdlib-use-getenv",[72,1838],{},"\nstdlib-use-system",[72,1841],{},"\ninclude-time",[72,1844],{},"\nstdlib-use-string-unbounded",[72,1847],{},[155,1849,1850],{},"Partially checked",[142,1852,1855,1861,1867,1879],{"className":1853},[1854],"even",[155,1856,1857],{},[55,1858,1860],{"href":1859},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[155,1862,1863],{},[1818,1864,1866],{"className":1865},[1821],"9.1p0",[155,1868,1869,1874],{},[39,1870,1871],{},[1828,1872,1873],{},"BADFUNC.MEMCMP",[39,1875,1876],{},[1828,1877,1878],{},"BADFUNC.MEMSET",[155,1880,1881,1884],{},[39,1882,1883],{},"Use of memcmp",[39,1885,1886],{},"Use of memset",[142,1888,1890,1896,1904,1909],{"className":1889},[1808],[155,1891,1892],{},[55,1893,1895],{"href":1894},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[155,1897,1898],{},[1818,1899,1901],{"className":1900},[1821],[39,1902,1903],{},"2025.2",[155,1905,1906],{},[1828,1907,1908],{},"C++5017, C++5038",[155,1910,1911],{},[72,1912],{},[142,1914,1916,1922,1927,1934],{"className":1915},[1854],[155,1917,1918],{},[55,1919,1921],{"href":1920},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","Klocwork",[155,1923,1924],{},[1818,1925,1903],{"className":1926},[1821],[155,1928,1929],{},[39,1930,1931],{},[1828,1932,1933],{},"CERT.OOP.CSTD_FUNC_USE",[155,1935,1936],{},[72,1937],{},[142,1939,1941,1947,1953,1964],{"className":1940},[1808],[155,1942,1943],{},[55,1944,1946],{"href":1945},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","LDRA tool suite",[155,1948,1949],{},[1818,1950,1952],{"className":1951},[1821],"9.7.1",[155,1954,1955],{},[39,1956,1957,176,1960],{},[1828,1958,1959],{},"44 S",[1828,1961,1962],{},[72,1963],{},[155,1965,1966],{},[39,1967,1968],{},"Enhanced Enforcement",[142,1970,1972,1978,1985,1997],{"className":1971},[1854],[155,1973,1974],{},[55,1975,1977],{"href":1976},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[155,1979,1980],{},[1818,1981,1983],{"className":1982},[1821],[39,1984,1903],{},[155,1986,1987],{},[39,1988,1989,1992,1994],{},[1828,1990,1991],{},"CERT_CPP-OOP57-a",[72,1993],{},[1828,1995,1996],{},"CERT_CPP-OOP57-b",[155,1998,1999],{},[39,2000,2001,2002,2004],{},"Do not initialize objects with a non-trivial class type using C standard library functions",[72,2003],{},"\nDo not compare objects of nonstandard-layout class type with C standard library functions",[142,2006,2008,2014,2022,2028],{"className":2007},[1808],[155,2009,2010],{},[55,2011,2013],{"href":2012},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[155,2015,2016],{},[1818,2017,2019],{"className":2018},[1821],[39,2020,2021],{},"R2025b",[155,2023,2024],{},[55,2025,2027],{"href":2026},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcoop57cpp.html","CERT C++: OOP57-CPP",[155,2029,2030],{},"Checks for bytewise operations on nontrivial class object (rule fully covered)",[142,2032,2034,2040,2048,2062],{"className":2033},[1854],[155,2035,2036],{},[55,2037,2039],{"href":2038},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio","PVS-Studio",[155,2041,2042],{},[1818,2043,2045],{"className":2044},[1821],[39,2046,2047],{},"7.42",[155,2049,2050,203,2056],{},[55,2051,2053],{"href":2052},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv598\u002F",[1828,2054,2055],{},"V598",[1828,2057,2058],{},[55,2059,2061],{"href":2060},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv780\u002F","V780",[155,2063,2064],{},[72,2065],{},[142,2067,2069,2075,2080,2098],{"className":2068},[1808],[155,2070,2071],{},[55,2072,2074],{"href":2073},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker","RuleChecker",[155,2076,2077],{},[1818,2078,1824],{"className":2079},[1821],[155,2081,2082],{},[1828,2083,2084,2096],{},[1828,2085,1830,2086,1833,2088,1836,2090,1839,2092,1842,2094,1845],{},[72,2087],{},[72,2089],{},[72,2091],{},[72,2093],{},[72,2095],{},[72,2097],{},[155,2099,1850],{},[1771,2101,2103],{"id":2102},"related-vulnerabilities","Related Vulnerabilities",[39,2105,2106,2107,2110,2111,538],{},"Search for ",[55,2108,856],{"href":2109},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerabil"," resulting from the violation of this rule on the ",[55,2112,2116],{"href":2113,"rel":2114},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+OOP57-CPP",[2115],"nofollow","CERT website",[215,2118,2120],{"id":2119},"related-guidelines","Related Guidelines",[136,2122,2123,2131],{},[139,2124,2125],{},[142,2126,2127,2129],{},[145,2128],{},[145,2130],{},[150,2132,2133],{},[142,2134,2135,2140],{},[155,2136,2137],{},[55,2138,2139],{"href":20},"SEI CERT C++ Coding Standard",[155,2141,2142],{},[55,2143,533],{"href":532},[215,2145,2147],{"id":2146},"bibliography","Bibliography",[136,2149,2151,2160],{"className":2150},[1778],[2152,2153,2154,2158],"colgroup",{},[2155,2156],"col",{"style":2157},"width: 50%",[2155,2159],{"style":2157},[150,2161,2162],{},[142,2163,2165,2171],{"className":2164},[1808],[155,2166,2167,2168,2170],{},"[ ",[55,2169,58],{"href":57}," ]",[155,2172,2173,2174,2176,2177,2179],{},"Subclause 3.9, \"Types\"",[72,2175],{},"\nSubclause 3.10, \"Lvalues and Rvalues\"",[72,2178],{},"\nClause 9, \"Classes\"",[2181,2182],"hr",{},[39,2184,2185,176,2192,176,2198],{},[55,2186,2188],{"href":2187},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop56-cpp",[2189,2190],"img",{"src":2191},"\u002Fattachments\u002F88046682\u002F88480621.png",[55,2193,2195],{"href":2194},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002F",[2189,2196],{"src":2197},"\u002Fattachments\u002F88046682\u002F88475556.png",[55,2199,2201],{"href":2200},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop58-cpp",[2189,2202],{"src":2203},"\u002Fattachments\u002F88046682\u002F88475555.png",[2205,2206,2207],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sz2Vg, html code.shiki .sz2Vg{--shiki-default:#6F42C1;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-text-decoration:underline}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}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 .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}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 .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":235,"searchDepth":253,"depth":253,"links":2209},[2210,2211,2212,2213,2214,2215,2216,2220,2221],{"id":217,"depth":253,"text":218},{"id":541,"depth":253,"text":542},{"id":835,"depth":253,"text":218},{"id":1057,"depth":253,"text":542},{"id":1370,"depth":253,"text":218},{"id":1536,"depth":253,"text":542},{"id":1697,"depth":253,"text":1698,"children":2217},[2218,2219],{"id":1773,"depth":261,"text":1774},{"id":2102,"depth":261,"text":2103},{"id":2119,"depth":253,"text":2120},{"id":2146,"depth":253,"text":2147},"Several C standard library functions perform bytewise operations on objects. For instance, std::memcmp() compares the bytes comprising the object representation of two objects, and std::memcpy() copies the bytes comprising an object representation into a destination buffer. However, for some object types, it results in undefined or abnormal program behavior.","md",{"tags":2225},[2226,2227,2228,2229,2230,2231],"review","oop","ptc","review-dms","rule","review-ajb","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop57-cpp",{"title":30,"description":2222},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F09.oop57-cpp","4daXjK31-RzUlmF32RGAjaAFahQE_5h4BJSxfSNsQ3U",[2237,2240],{"title":2238,"path":2187,"stem":2239,"children":-1},"OOP56-CPP. Honor replacement handler requirements","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F08.oop56-cpp",{"title":2241,"path":2200,"stem":2242,"children":-1},"OOP58-CPP. Copy operations must not mutate the source object","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F10.oop58-cpp",[2244],{"title":2139,"path":2245,"stem":2246,"children":2247},"\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[2248,2249,2316,2709,2918,2928],{"title":2139,"path":2245,"stem":2246},{"title":2250,"path":2251,"stem":2252,"children":2253},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[2254,2255],{"title":2250,"path":2251,"stem":2252},{"title":2256,"path":2257,"stem":2258,"children":2259},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[2260,2261,2265,2269,2273,2277,2281,2285,2289,2293,2297,2301,2305,2309,2313],{"title":2256,"path":2257,"stem":2258},{"title":2262,"path":2263,"stem":2264},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":2266,"path":2267,"stem":2268},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":2270,"path":2271,"stem":2272},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":2274,"path":2275,"stem":2276},"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":2278,"path":2279,"stem":2280},"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":2282,"path":2283,"stem":2284},"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":2286,"path":2287,"stem":2288},"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":2290,"path":2291,"stem":2292},"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":2294,"path":2295,"stem":2296},"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":2298,"path":2299,"stem":2300},"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":2302,"path":2303,"stem":2304},"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":2306,"path":2307,"stem":2308},"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":2310,"path":2311,"stem":2312},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":1774,"path":2314,"stem":2315},"\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":2317,"path":2318,"stem":2319,"children":2320},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[2321,2322,2344,2378,2420,2470,2528,2588,2602,2612,2650,2676],{"title":2317,"path":2318,"stem":2319},{"title":2323,"path":2324,"stem":2325,"children":2326},"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",[2327,2328,2332,2336,2340],{"title":2323,"path":2324,"stem":2325},{"title":2329,"path":2330,"stem":2331},"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":2333,"path":2334,"stem":2335},"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":2337,"path":2338,"stem":2339},"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":2341,"path":2342,"stem":2343},"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":2345,"path":2346,"stem":2347,"children":2348},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[2349,2350,2354,2358,2362,2366,2370,2374],{"title":2345,"path":2346,"stem":2347},{"title":2351,"path":2352,"stem":2353},"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":2355,"path":2356,"stem":2357},"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":2359,"path":2360,"stem":2361},"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":2363,"path":2364,"stem":2365},"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":2367,"path":2368,"stem":2369},"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":2371,"path":2372,"stem":2373},"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":2375,"path":2376,"stem":2377},"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":2379,"path":2380,"stem":2381,"children":2382},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[2383,2384,2388,2392,2396,2400,2404,2408,2412,2416],{"title":2379,"path":2380,"stem":2381},{"title":2385,"path":2386,"stem":2387},"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":2389,"path":2390,"stem":2391},"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":2393,"path":2394,"stem":2395},"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":2397,"path":2398,"stem":2399},"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":2401,"path":2402,"stem":2403},"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":2405,"path":2406,"stem":2407},"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":2409,"path":2410,"stem":2411},"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":2413,"path":2414,"stem":2415},"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":2417,"path":2418,"stem":2419},"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":2421,"path":2422,"stem":2423,"children":2424},"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",[2425,2426,2430,2434,2438,2442,2446,2450,2454,2458,2462,2466],{"title":2421,"path":2422,"stem":2423},{"title":2427,"path":2428,"stem":2429},"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":2431,"path":2432,"stem":2433},"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":2435,"path":2436,"stem":2437},"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":2439,"path":2440,"stem":2441},"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":2443,"path":2444,"stem":2445},"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":2447,"path":2448,"stem":2449},"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":2451,"path":2452,"stem":2453},"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":2455,"path":2456,"stem":2457},"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":2459,"path":2460,"stem":2461},"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":2463,"path":2464,"stem":2465},"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":2467,"path":2468,"stem":2469},"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":2471,"path":2472,"stem":2473,"children":2474},"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",[2475,2476,2480,2484,2488,2492,2496,2500,2504,2508,2512,2516,2520,2524],{"title":2471,"path":2472,"stem":2473},{"title":2477,"path":2478,"stem":2479},"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":2481,"path":2482,"stem":2483},"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":2485,"path":2486,"stem":2487},"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":2489,"path":2490,"stem":2491},"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":2493,"path":2494,"stem":2495},"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":2497,"path":2498,"stem":2499},"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":2501,"path":2502,"stem":2503},"ERR56-CPP. Guarantee exception safety","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F08.err56-cpp",{"title":2505,"path":2506,"stem":2507},"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":2509,"path":2510,"stem":2511},"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":2513,"path":2514,"stem":2515},"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":2517,"path":2518,"stem":2519},"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":2521,"path":2522,"stem":2523},"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":2525,"path":2526,"stem":2527},"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":2529,"path":2530,"stem":2531,"children":2532},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[2533,2534,2538,2542,2546,2550,2554,2558,2562,2566,2570,2574,2578,2582,2584],{"title":2529,"path":2530,"stem":2531},{"title":2535,"path":2536,"stem":2537},"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":2539,"path":2540,"stem":2541},"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":2543,"path":2544,"stem":2545},"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":2547,"path":2548,"stem":2549},"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":2551,"path":2552,"stem":2553},"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":2555,"path":2556,"stem":2557},"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":2559,"path":2560,"stem":2561},"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":2563,"path":2564,"stem":2565},"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":2567,"path":2568,"stem":2569},"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":2571,"path":2572,"stem":2573},"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":2575,"path":2576,"stem":2577},"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":2579,"path":2580,"stem":2581},"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":533,"path":532,"stem":2583},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F14.exp62-cpp",{"title":2585,"path":2586,"stem":2587},"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":2589,"path":2590,"stem":2591,"children":2592},"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",[2593,2594,2598],{"title":2589,"path":2590,"stem":2591},{"title":2595,"path":2596,"stem":2597},"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":2599,"path":2600,"stem":2601},"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":2603,"path":2604,"stem":2605,"children":2606},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[2607,2608],{"title":2603,"path":2604,"stem":2605},{"title":2609,"path":2610,"stem":2611},"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":2613,"path":2614,"stem":2615,"children":2616},"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",[2617,2618,2622,2626,2630,2634,2638,2642,2646],{"title":2613,"path":2614,"stem":2615},{"title":2619,"path":2620,"stem":2621},"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":2623,"path":2624,"stem":2625},"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":2627,"path":2628,"stem":2629},"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":2631,"path":2632,"stem":2633},"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":2635,"path":2636,"stem":2637},"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":2639,"path":2640,"stem":2641},"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":2643,"path":2644,"stem":2645},"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":2647,"path":2648,"stem":2649},"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":2651,"path":2652,"stem":2653,"children":2654},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[2655,2656,2660,2664,2668,2672],{"title":2651,"path":2652,"stem":2653},{"title":2657,"path":2658,"stem":2659},"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":2661,"path":2662,"stem":2663},"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":2665,"path":2666,"stem":2667},"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":2669,"path":2670,"stem":2671},"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":2673,"path":2674,"stem":2675},"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":2677,"path":2678,"stem":2679,"children":2680},"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",[2681,2682,2686,2690,2694,2698,2702,2706,2707,2708],{"title":2677,"path":2678,"stem":2679},{"title":2683,"path":2684,"stem":2685},"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":2687,"path":2688,"stem":2689},"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":2691,"path":2692,"stem":2693},"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":2695,"path":2696,"stem":2697},"OOP53-CPP. Write constructor member initializers in the canonical order","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F05.oop53-cpp",{"title":2699,"path":2700,"stem":2701},"OOP54-CPP. Gracefully handle self-copy assignment","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F06.oop54-cpp",{"title":2703,"path":2704,"stem":2705},"OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F07.oop55-cpp",{"title":2238,"path":2187,"stem":2239},{"title":30,"path":2232,"stem":2234},{"title":2241,"path":2200,"stem":2242},{"title":2710,"path":2711,"stem":2712,"children":2713},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[2714,2715,2719,2722,2900,2914],{"title":2710,"path":2711,"stem":2712},{"title":2716,"path":2717,"stem":2718},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":2720,"path":1704,"stem":2721},"BB. Definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":2723,"path":2724,"stem":2725,"children":2726},"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",[2727,2728,2730,2734,2738,2742,2746,2750,2754,2758,2762,2766,2770,2772,2776,2780,2784,2788,2792,2796,2800,2804,2808,2810,2814,2816,2820,2823,2827,2830,2834,2836,2840,2844,2848,2850,2854,2858,2862,2864,2868,2872,2876,2880,2884,2888,2892,2896],{"title":2723,"path":2724,"stem":2725},{"title":1814,"path":1813,"stem":2729},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":2731,"path":2732,"stem":2733},"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":2735,"path":2736,"stem":2737},"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":2739,"path":2740,"stem":2741},"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":2743,"path":2744,"stem":2745},"Clang","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":2747,"path":2748,"stem":2749},"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":2751,"path":2752,"stem":2753},"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":2755,"path":2756,"stem":2757},"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":2759,"path":2760,"stem":2761},"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":2763,"path":2764,"stem":2765},"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":2767,"path":2768,"stem":2769},"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":1860,"path":1859,"stem":2771},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":2773,"path":2774,"stem":2775},"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":2777,"path":2778,"stem":2779},"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":2781,"path":2782,"stem":2783},"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":2785,"path":2786,"stem":2787},"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":2789,"path":2790,"stem":2791},"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":2793,"path":2794,"stem":2795},"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":2797,"path":2798,"stem":2799},"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":2801,"path":2802,"stem":2803},"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":2805,"path":2806,"stem":2807},"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":1895,"path":1894,"stem":2809},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":2811,"path":2812,"stem":2813},"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":1921,"path":1920,"stem":2815},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":2817,"path":2818,"stem":2819},"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":2821,"path":1945,"stem":2822},"LDRA","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":2824,"path":2825,"stem":2826},"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":2828,"path":1976,"stem":2829},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":2831,"path":2832,"stem":2833},"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":2013,"path":2012,"stem":2835},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":2837,"path":2838,"stem":2839},"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":2841,"path":2842,"stem":2843},"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":2845,"path":2846,"stem":2847},"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":2039,"path":2038,"stem":2849},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F35.pvs-studio",{"title":2851,"path":2852,"stem":2853},"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":2855,"path":2856,"stem":2857},"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":2859,"path":2860,"stem":2861},"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":2074,"path":2073,"stem":2863},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F39.rulechecker",{"title":2865,"path":2866,"stem":2867},"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":2869,"path":2870,"stem":2871},"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":2873,"path":2874,"stem":2875},"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":2877,"path":2878,"stem":2879},"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":2881,"path":2882,"stem":2883},"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":2885,"path":2886,"stem":2887},"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":2889,"path":2890,"stem":2891},"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":2893,"path":2894,"stem":2895},"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":2897,"path":2898,"stem":2899},"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":2901,"path":2902,"stem":2903,"children":2904},"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",[2905,2906,2910],{"title":2901,"path":2902,"stem":2903},{"title":2907,"path":2908,"stem":2909},"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":2911,"path":2912,"stem":2913},"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":2915,"path":2916,"stem":2917},"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":2919,"path":2920,"stem":2921,"children":2922},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[2923,2924],{"title":2919,"path":2920,"stem":2921},{"title":2925,"path":2926,"stem":2927},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":2929,"path":2930,"stem":2931},"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",1775657784229]