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