[{"data":1,"prerenderedAt":2178},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-cpp":1476,"sidebar-sei-cert-cpp-coding-standard":1483},[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":1462,"extension":1463,"meta":1464,"navigation":7,"path":1472,"seo":1473,"stem":1474,"__hash__":1475},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F05.dcl53-cpp.md","DCL53-CPP. Do not write syntactically ambiguous declarations",{"type":32,"value":33,"toc":1449},"minimark",[34,38,53,74,77,82,85,90,109,233,237,243,327,330,347,435,438,441,448,532,547,550,561,740,743,766,779,782,799,974,977,1006,1010,1013,1080,1085,1367,1371,1385,1389,1421,1424,1445],[35,36,30],"h1",{"id":37},"dcl53-cpp-do-not-write-syntactically-ambiguous-declarations",[39,40,41,42,46,47,52],"p",{},"It is possible to devise syntax that can ambiguously be interpreted as either an expression statement or a declaration. Syntax of this sort is called a ",[43,44,45],"em",{},"vexing parse"," because the compiler must use disambiguation rules to determine the semantic results. The C++ Standard, [stmt.ambig], paragraph 1 [ ",[48,49,51],"a",{"href":50},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], in part, states the following:",[54,55,56],"blockquote",{},[39,57,58,59,62,63,65,66,70,71,73],{},"There is an ambiguity in the grammar involving ",[43,60,61],{},"expression-statement"," s and declarations: An ",[43,64,61],{}," with a function-style explicit type conversion as its leftmost subexpression can be indistinguishable from a declaration where the first declarator starts with a ",[67,68,69],"code",{},"("," . In those cases the statement is a declaration. [Note: To disambiguate, the whole statement might have to be examined to determine if it is an ",[43,72,61],{}," or a declaration. ...",[39,75,76],{},"A similarly vexing parse exists within the context of a declaration where syntax can be ambiguously interpreted as either a function declaration or a declaration with a function-style cast as the initializer. The C++ Standard, [dcl.ambig.res], paragraph 1, in part, states the following:",[54,78,79],{},[39,80,81],{},"The ambiguity arising from the similarity between a function-style cast and a declaration mentioned in 6.8 can also occur in the context of a declaration. In that context, the choice is between a function declaration with a redundant set of parentheses around a parameter name and an object declaration with a function-style cast as the initializer. Just as for the ambiguities mentioned in 6.8, the resolution is to consider any construct that could possibly be a declaration a declaration.",[39,83,84],{},"Do not write a syntactically ambiguous declaration. With the advent of uniform initialization syntax using a braced-init-list, there is now syntax that unambiguously specifies a declaration instead of an expression statement. Declarations can also be disambiguated by using nonfunction-style casts, by initializing using =, or by removing extraneous parenthesis around the parameter name.",[86,87,89],"h2",{"id":88},"noncompliant-code-example","Noncompliant Code Example",[39,91,92,93,96,97,100,101,105,106,108],{},"In this noncompliant code example, an anonymous local variable of type ",[67,94,95],{},"std::unique_lock"," is expected to lock and unlock the mutex ",[67,98,99],{},"m"," by virtue of ",[48,102,104],{"href":103},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-RAII","RAII."," However, the declaration is syntactically ambiguous as it can be interpreted as declaring an anonymous object and calling its single-argument converting constructor or interpreted as declaring an object named ",[67,107,99],{}," and default constructing it. The syntax used in this example defines the latter instead of the former, and so the mutex object is never locked.",[110,111,113],"code-block",{"quality":112},"bad",[114,115,120],"pre",{"className":116,"code":117,"language":118,"meta":119,"style":119},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Cmutex>\n\nstatic std::mutex m;\nstatic int shared_resource;\n\nvoid increment_by_42() {\n  std::unique_lock\u003Cstd::mutex>(m);\n  shared_resource += 42;\n}\n","cpp","",[67,121,122,135,141,155,167,172,185,211,227],{"__ignoreMap":119},[123,124,127,131],"span",{"class":125,"line":126},"line",1,[123,128,130],{"class":129},"sC2Qs","#include",[123,132,134],{"class":133},"sstjo"," \u003Cmutex>\n",[123,136,138],{"class":125,"line":137},2,[123,139,140],{"emptyLinePlaceholder":7},"\n",[123,142,144,147,151],{"class":125,"line":143},3,[123,145,146],{"class":129},"static",[123,148,150],{"class":149},"sz2Vg"," std",[123,152,154],{"class":153},"sMOD_","::mutex m;\n",[123,156,158,160,164],{"class":125,"line":157},4,[123,159,146],{"class":129},[123,161,163],{"class":162},"sq6CD"," int",[123,165,166],{"class":153}," shared_resource;\n",[123,168,170],{"class":125,"line":169},5,[123,171,140],{"emptyLinePlaceholder":7},[123,173,175,178,182],{"class":125,"line":174},6,[123,176,177],{"class":162},"void",[123,179,181],{"class":180},"srTi1"," increment_by_42",[123,183,184],{"class":153},"() {\n",[123,186,188,191,194,197,200,203,205,208],{"class":125,"line":187},7,[123,189,190],{"class":149},"  std",[123,192,193],{"class":153},"::",[123,195,196],{"class":180},"unique_lock",[123,198,199],{"class":153},"\u003C",[123,201,202],{"class":149},"std",[123,204,193],{"class":153},[123,206,207],{"class":149},"mutex",[123,209,210],{"class":153},">(m);\n",[123,212,214,217,220,224],{"class":125,"line":213},8,[123,215,216],{"class":153},"  shared_resource ",[123,218,219],{"class":129},"+=",[123,221,223],{"class":222},"s7F3e"," 42",[123,225,226],{"class":153},";\n",[123,228,230],{"class":125,"line":229},9,[123,231,232],{"class":153},"}\n",[86,234,236],{"id":235},"compliant-solution","Compliant Solution",[39,238,239,240,242],{},"In this compliant solution, the lock object is given an identifier (other than ",[67,241,99],{}," ) and the proper converting constructor is called.",[110,244,246],{"quality":245},"good",[114,247,249],{"className":116,"code":248,"language":118,"meta":119,"style":119},"#include \u003Cmutex>\n \nstatic std::mutex m;\nstatic int shared_resource;\n\nvoid increment_by_42() {\n  std::unique_lock\u003Cstd::mutex> lock(m);\n  shared_resource += 42;\n}\n",[67,250,251,257,262,270,278,282,290,313,323],{"__ignoreMap":119},[123,252,253,255],{"class":125,"line":126},[123,254,130],{"class":129},[123,256,134],{"class":133},[123,258,259],{"class":125,"line":137},[123,260,261],{"class":153}," \n",[123,263,264,266,268],{"class":125,"line":143},[123,265,146],{"class":129},[123,267,150],{"class":149},[123,269,154],{"class":153},[123,271,272,274,276],{"class":125,"line":157},[123,273,146],{"class":129},[123,275,163],{"class":162},[123,277,166],{"class":153},[123,279,280],{"class":125,"line":169},[123,281,140],{"emptyLinePlaceholder":7},[123,283,284,286,288],{"class":125,"line":174},[123,285,177],{"class":162},[123,287,181],{"class":180},[123,289,184],{"class":153},[123,291,292,294,297,299,301,304,307,310],{"class":125,"line":187},[123,293,190],{"class":149},[123,295,296],{"class":153},"::unique_lock",[123,298,199],{"class":129},[123,300,202],{"class":149},[123,302,303],{"class":153},"::mutex",[123,305,306],{"class":129},">",[123,308,309],{"class":180}," lock",[123,311,312],{"class":153},"(m);\n",[123,314,315,317,319,321],{"class":125,"line":213},[123,316,216],{"class":153},[123,318,219],{"class":129},[123,320,223],{"class":222},[123,322,226],{"class":153},[123,324,325],{"class":125,"line":229},[123,326,232],{"class":153},[86,328,89],{"id":329},"noncompliant-code-example-1",[39,331,332,333,336,337,340,341,343,344,346],{},"In this noncompliant code example, an attempt is made to declare a local variable, ",[67,334,335],{},"w"," , of type ",[67,338,339],{},"Widget"," while executing the default constructor. However, this declaration is syntactically ambiguous where the code could be either a declaration of a function pointer accepting no arguments and returning a ",[67,342,339],{}," or a declaration of a local variable of type ",[67,345,339],{}," . The syntax used in this example defines the former instead of the latter.",[110,348,349],{"quality":112},[114,350,352],{"className":116,"code":351,"language":118,"meta":119,"style":119},"#include \u003Ciostream>\n \nstruct Widget {\n  Widget() { std::cout \u003C\u003C \"Constructed\" \u003C\u003C std::endl; }\n};\n\nvoid f() {\n  Widget w();\n}\n",[67,353,354,361,365,376,403,408,412,421,431],{"__ignoreMap":119},[123,355,356,358],{"class":125,"line":126},[123,357,130],{"class":129},[123,359,360],{"class":133}," \u003Ciostream>\n",[123,362,363],{"class":125,"line":137},[123,364,261],{"class":153},[123,366,367,370,373],{"class":125,"line":143},[123,368,369],{"class":162},"struct",[123,371,372],{"class":149}," Widget",[123,374,375],{"class":153}," {\n",[123,377,378,381,384,386,389,392,395,398,400],{"class":125,"line":157},[123,379,380],{"class":180},"  Widget",[123,382,383],{"class":153},"() { ",[123,385,202],{"class":149},[123,387,388],{"class":153},"::cout ",[123,390,391],{"class":129},"\u003C\u003C",[123,393,394],{"class":133}," \"Constructed\"",[123,396,397],{"class":129}," \u003C\u003C",[123,399,150],{"class":149},[123,401,402],{"class":153},"::endl; }\n",[123,404,405],{"class":125,"line":169},[123,406,407],{"class":153},"};\n",[123,409,410],{"class":125,"line":174},[123,411,140],{"emptyLinePlaceholder":7},[123,413,414,416,419],{"class":125,"line":187},[123,415,177],{"class":162},[123,417,418],{"class":180}," f",[123,420,184],{"class":153},[123,422,423,426,428],{"class":125,"line":213},[123,424,425],{"class":153},"  Widget ",[123,427,335],{"class":180},[123,429,430],{"class":153},"();\n",[123,432,433],{"class":125,"line":229},[123,434,232],{"class":153},[39,436,437],{},"As a result, this program compiles and prints no output because the default constructor is never actually invoked.",[86,439,236],{"id":440},"compliant-solution-1",[39,442,443,444,447],{},"This compliant solution shows two equally compliant ways to write the declaration. The first way is to elide the parentheses after the variable declaration, which ensures the syntax is that of a variable declaration instead of a function declaration. The second way is to use a ",[43,445,446],{},"braced-init-list"," to direct-initialize the local variable.",[110,449,450],{"quality":245},[114,451,453],{"className":116,"code":452,"language":118,"meta":119,"style":119},"#include \u003Ciostream>\n \nstruct Widget {\n  Widget() { std::cout \u003C\u003C \"Constructed\" \u003C\u003C std::endl; }\n};\n\nvoid f() {\n  Widget w1; \u002F\u002F Elide the parentheses\n  Widget w2{}; \u002F\u002F Use direct initialization\n}\n",[67,454,455,461,466,474,494,498,502,510,519,527],{"__ignoreMap":119},[123,456,457,459],{"class":125,"line":126},[123,458,130],{"class":129},[123,460,360],{"class":133},[123,462,463],{"class":125,"line":137},[123,464,465],{"class":153}," \n",[123,467,468,470,472],{"class":125,"line":143},[123,469,369],{"class":162},[123,471,372],{"class":149},[123,473,375],{"class":153},[123,475,476,478,480,482,484,486,488,490,492],{"class":125,"line":157},[123,477,380],{"class":180},[123,479,383],{"class":153},[123,481,202],{"class":149},[123,483,388],{"class":153},[123,485,391],{"class":129},[123,487,394],{"class":133},[123,489,397],{"class":129},[123,491,150],{"class":149},[123,493,402],{"class":153},[123,495,496],{"class":125,"line":169},[123,497,407],{"class":153},[123,499,500],{"class":125,"line":174},[123,501,140],{"emptyLinePlaceholder":7},[123,503,504,506,508],{"class":125,"line":187},[123,505,177],{"class":162},[123,507,418],{"class":180},[123,509,184],{"class":153},[123,511,512,515],{"class":125,"line":213},[123,513,514],{"class":153},"  Widget w1;",[123,516,518],{"class":517},"s8-w5"," \u002F\u002F Elide the parentheses\n",[123,520,521,524],{"class":125,"line":229},[123,522,523],{"class":153},"  Widget w2{};",[123,525,526],{"class":517}," \u002F\u002F Use direct initialization\n",[123,528,530],{"class":125,"line":529},10,[123,531,232],{"class":153},[39,533,534,535,538,539,542,543,546],{},"Running this program produces the output ",[67,536,537],{},"Constructed"," twice, once for ",[67,540,541],{},"w1"," and once for ",[67,544,545],{},"w2"," .",[86,548,89],{"id":549},"noncompliant-code-example-2",[39,551,552,553,556,557,560],{},"This noncompliant code example demonstrates a vexing parse. The declaration ",[67,554,555],{},"  Gadget g(Widget(i)); "," is not parsed as declaring a ",[67,558,559],{},"Gadget"," object with a single argument. It is instead parsed as a function declaration with a redundant set of parentheses around a parameter.",[110,562,563],{"quality":112},[114,564,566],{"className":116,"code":565,"language":118,"meta":119,"style":119},"#include \u003Ciostream>\n\nstruct Widget {\n  explicit Widget(int i) { std::cout \u003C\u003C \"Widget constructed\" \u003C\u003C std::endl; }\n};\n\nstruct Gadget {\n  explicit Gadget(Widget wid) { std::cout \u003C\u003C \"Gadget constructed\" \u003C\u003C std::endl; }\n};\n\nvoid f() {\n  int i = 3;\n  Gadget g(Widget(i));\n  std::cout \u003C\u003C i \u003C\u003C std::endl;\n}\n",[67,567,568,574,578,586,620,624,628,637,667,671,675,684,701,717,735],{"__ignoreMap":119},[123,569,570,572],{"class":125,"line":126},[123,571,130],{"class":129},[123,573,360],{"class":133},[123,575,576],{"class":125,"line":137},[123,577,140],{"emptyLinePlaceholder":7},[123,579,580,582,584],{"class":125,"line":143},[123,581,369],{"class":162},[123,583,372],{"class":149},[123,585,375],{"class":153},[123,587,588,591,593,595,598,602,605,607,609,611,614,616,618],{"class":125,"line":157},[123,589,590],{"class":129},"  explicit",[123,592,372],{"class":180},[123,594,69],{"class":153},[123,596,597],{"class":162},"int",[123,599,601],{"class":600},"sTHNf"," i",[123,603,604],{"class":153},") { ",[123,606,202],{"class":149},[123,608,388],{"class":153},[123,610,391],{"class":129},[123,612,613],{"class":133}," \"Widget constructed\"",[123,615,397],{"class":129},[123,617,150],{"class":149},[123,619,402],{"class":153},[123,621,622],{"class":125,"line":169},[123,623,407],{"class":153},[123,625,626],{"class":125,"line":174},[123,627,140],{"emptyLinePlaceholder":7},[123,629,630,632,635],{"class":125,"line":187},[123,631,369],{"class":162},[123,633,634],{"class":149}," Gadget",[123,636,375],{"class":153},[123,638,639,641,643,645,647,650,652,654,656,658,661,663,665],{"class":125,"line":213},[123,640,590],{"class":129},[123,642,634],{"class":180},[123,644,69],{"class":153},[123,646,339],{"class":149},[123,648,649],{"class":600}," wid",[123,651,604],{"class":153},[123,653,202],{"class":149},[123,655,388],{"class":153},[123,657,391],{"class":129},[123,659,660],{"class":133}," \"Gadget constructed\"",[123,662,397],{"class":129},[123,664,150],{"class":149},[123,666,402],{"class":153},[123,668,669],{"class":125,"line":229},[123,670,407],{"class":153},[123,672,673],{"class":125,"line":529},[123,674,140],{"emptyLinePlaceholder":7},[123,676,678,680,682],{"class":125,"line":677},11,[123,679,177],{"class":162},[123,681,418],{"class":180},[123,683,184],{"class":153},[123,685,687,690,693,696,699],{"class":125,"line":686},12,[123,688,689],{"class":162},"  int",[123,691,692],{"class":153}," i ",[123,694,695],{"class":129},"=",[123,697,698],{"class":222}," 3",[123,700,226],{"class":153},[123,702,704,707,710,712,714],{"class":125,"line":703},13,[123,705,706],{"class":153},"  Gadget ",[123,708,709],{"class":180},"g",[123,711,69],{"class":153},[123,713,339],{"class":180},[123,715,716],{"class":153},"(i));\n",[123,718,720,722,724,726,728,730,732],{"class":125,"line":719},14,[123,721,190],{"class":149},[123,723,388],{"class":153},[123,725,391],{"class":129},[123,727,692],{"class":153},[123,729,391],{"class":129},[123,731,150],{"class":149},[123,733,734],{"class":153},"::endl;\n",[123,736,738],{"class":125,"line":737},15,[123,739,232],{"class":153},[39,741,742],{},"Parentheses around parameter names are optional, so the following is a semantically identical spelling of the declaration.",[110,744,745],{"quality":245},[114,746,748],{"className":116,"code":747,"language":118,"meta":119,"style":119},"Gadget g(Widget i);\n",[67,749,750],{"__ignoreMap":119},[123,751,752,754,757,759,761,763],{"class":125,"line":126},[123,753,559],{"class":149},[123,755,756],{"class":180}," g",[123,758,69],{"class":153},[123,760,339],{"class":149},[123,762,601],{"class":600},[123,764,765],{"class":153},");\n",[39,767,768,769,772,773,775,776,778],{},"As a result, this program is well-formed and prints only ",[67,770,771],{},"3"," as output because no ",[67,774,559],{}," or ",[67,777,339],{}," objects are constructed.",[86,780,236],{"id":781},"compliant-solution-2",[39,783,784,785,787,788,791,792,794,795,798],{},"This compliant solution demonstrates two equally compliant ways to write the declaration of ",[67,786,709],{}," . The first declaration, ",[67,789,790],{},"g1"," , uses an extra set of parentheses around the argument to the constructor call, forcing the compiler to parse it as a local variable declaration of type ",[67,793,559],{}," instead of as a function declaration. The second declaration, ",[67,796,797],{},"g2"," , uses direct initialization to similar effect.",[110,800,801],{"quality":245},[114,802,804],{"className":116,"code":803,"language":118,"meta":119,"style":119},"#include \u003Ciostream>\n\nstruct Widget {\n  explicit Widget(int i) { std::cout \u003C\u003C \"Widget constructed\" \u003C\u003C std::endl; }\n};\n\nstruct Gadget {\n  explicit Gadget(Widget wid) { std::cout \u003C\u003C \"Gadget constructed\" \u003C\u003C std::endl; }\n};\n\nvoid f() {\n  int i = 3;\n  Gadget g1((Widget(i))); \u002F\u002F Use extra parentheses\n  Gadget g2{Widget(i)}; \u002F\u002F Use direct initialization\n  std::cout \u003C\u003C i \u003C\u003C std::endl;\n}\n",[67,805,806,812,816,824,852,856,860,868,896,900,904,912,924,941,953,969],{"__ignoreMap":119},[123,807,808,810],{"class":125,"line":126},[123,809,130],{"class":129},[123,811,360],{"class":133},[123,813,814],{"class":125,"line":137},[123,815,140],{"emptyLinePlaceholder":7},[123,817,818,820,822],{"class":125,"line":143},[123,819,369],{"class":162},[123,821,372],{"class":149},[123,823,375],{"class":153},[123,825,826,828,830,832,834,836,838,840,842,844,846,848,850],{"class":125,"line":157},[123,827,590],{"class":129},[123,829,372],{"class":180},[123,831,69],{"class":153},[123,833,597],{"class":162},[123,835,601],{"class":600},[123,837,604],{"class":153},[123,839,202],{"class":149},[123,841,388],{"class":153},[123,843,391],{"class":129},[123,845,613],{"class":133},[123,847,397],{"class":129},[123,849,150],{"class":149},[123,851,402],{"class":153},[123,853,854],{"class":125,"line":169},[123,855,407],{"class":153},[123,857,858],{"class":125,"line":174},[123,859,140],{"emptyLinePlaceholder":7},[123,861,862,864,866],{"class":125,"line":187},[123,863,369],{"class":162},[123,865,634],{"class":149},[123,867,375],{"class":153},[123,869,870,872,874,876,878,880,882,884,886,888,890,892,894],{"class":125,"line":213},[123,871,590],{"class":129},[123,873,634],{"class":180},[123,875,69],{"class":153},[123,877,339],{"class":149},[123,879,649],{"class":600},[123,881,604],{"class":153},[123,883,202],{"class":149},[123,885,388],{"class":153},[123,887,391],{"class":129},[123,889,660],{"class":133},[123,891,397],{"class":129},[123,893,150],{"class":149},[123,895,402],{"class":153},[123,897,898],{"class":125,"line":229},[123,899,407],{"class":153},[123,901,902],{"class":125,"line":529},[123,903,140],{"emptyLinePlaceholder":7},[123,905,906,908,910],{"class":125,"line":677},[123,907,177],{"class":162},[123,909,418],{"class":180},[123,911,184],{"class":153},[123,913,914,916,918,920,922],{"class":125,"line":686},[123,915,689],{"class":162},[123,917,692],{"class":153},[123,919,695],{"class":129},[123,921,698],{"class":222},[123,923,226],{"class":153},[123,925,926,928,930,933,935,938],{"class":125,"line":703},[123,927,706],{"class":153},[123,929,790],{"class":180},[123,931,932],{"class":153},"((",[123,934,339],{"class":180},[123,936,937],{"class":153},"(i)));",[123,939,940],{"class":517}," \u002F\u002F Use extra parentheses\n",[123,942,943,946,948,951],{"class":125,"line":719},[123,944,945],{"class":153},"  Gadget g2{",[123,947,339],{"class":180},[123,949,950],{"class":153},"(i)};",[123,952,526],{"class":517},[123,954,955,957,959,961,963,965,967],{"class":125,"line":737},[123,956,190],{"class":149},[123,958,388],{"class":153},[123,960,391],{"class":129},[123,962,692],{"class":153},[123,964,391],{"class":129},[123,966,150],{"class":149},[123,968,734],{"class":153},[123,970,972],{"class":125,"line":971},16,[123,973,232],{"class":153},[39,975,976],{},"Running this program produces the expected output.",[114,978,980],{"className":116,"code":979,"language":118,"meta":119,"style":119},"Widget constructed\nGadget constructed\nWidget constructed \nGadget constructed\n3\n",[67,981,982,987,992,997,1001],{"__ignoreMap":119},[123,983,984],{"class":125,"line":126},[123,985,986],{"class":153},"Widget constructed\n",[123,988,989],{"class":125,"line":137},[123,990,991],{"class":153},"Gadget constructed\n",[123,993,994],{"class":125,"line":143},[123,995,996],{"class":153},"Widget constructed \n",[123,998,999],{"class":125,"line":157},[123,1000,991],{"class":153},[123,1002,1003],{"class":125,"line":169},[123,1004,1005],{"class":222},"3\n",[86,1007,1009],{"id":1008},"risk-assessment","Risk Assessment",[39,1011,1012],{},"Syntactically ambiguous declarations can lead to unexpected program execution. However, it is likely that rudimentary testing would uncover violations of this rule.",[1014,1015,1016,1017,1016,1047],"table",{},"\n  ",[1018,1019,1020,1021,1016],"thead",{},"\n    ",[1022,1023,1024,1025,1024,1029,1024,1032,1024,1035,1024,1038,1024,1041,1024,1044,1020],"tr",{},"\n      ",[1026,1027,1028],"th",{},"Rule",[1026,1030,1031],{},"Severity",[1026,1033,1034],{},"Likelihood",[1026,1036,1037],{},"Detectable",[1026,1039,1040],{},"Repairable",[1026,1042,1043],{},"Priority",[1026,1045,1046],{},"Level",[1048,1049,1020,1050,1016],"tbody",{},[1022,1051,1024,1052,1024,1056,1024,1059,1024,1062,1024,1065,1024,1068,1024,1075,1020],{},[1053,1054,1055],"td",{},"DCL53-CPP",[1053,1057,1058],{},"Low",[1053,1060,1061],{},"Unlikely",[1053,1063,1064],{},"Yes",[1053,1066,1067],{},"No",[1053,1069,1071],{"style":1070},"color: #27ae60;",[1072,1073,1074],"b",{},"P2",[1053,1076,1077],{"style":1070},[1072,1078,1079],{},"L3",[1081,1082,1084],"h3",{"id":1083},"automated-detection","Automated Detection",[1014,1086,1089,1115],{"className":1087},[1088],"wrapped",[1018,1090,1091],{},[1022,1092,1095,1100,1105,1110],{"className":1093},[1094],"header",[1026,1096,1097],{},[39,1098,1099],{},"Tool",[1026,1101,1102],{},[39,1103,1104],{},"Version",[1026,1106,1107],{},[39,1108,1109],{},"Checker",[1026,1111,1112],{},[39,1113,1114],{},"Description",[1048,1116,1117,1148,1176,1199,1231,1275,1316,1340],{},[1022,1118,1121,1127,1135,1143],{"className":1119},[1120],"odd",[1053,1122,1123],{},[48,1124,1126],{"href":1125},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[1053,1128,1129],{},[1130,1131,1134],"div",{"className":1132},[1133],"content-wrapper","9.1p0",[1053,1136,1137],{},[39,1138,1139],{},[1140,1141,1142],"strong",{},"LANG.STRUCT.DECL.FNEST",[1053,1144,1145],{},[39,1146,1147],{},"Nested Function Declaration",[1022,1149,1152,1158,1166,1171],{"className":1150},[1151],"even",[1053,1153,1154],{},[48,1155,1157],{"href":1156},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[1053,1159,1160],{},[1130,1161,1163],{"className":1162},[1133],[39,1164,1165],{},"2025.2",[1053,1167,1168],{},[1140,1169,1170],{},"C++1109, C++2510",[1053,1172,1173],{},[1174,1175],"br",{},[1022,1177,1179,1185,1190,1195],{"className":1178},[1120],[1053,1180,1181],{},[48,1182,1184],{"href":1183},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","Klocwork",[1053,1186,1187],{},[1130,1188,1165],{"className":1189},[1133],[1053,1191,1192],{},[1140,1193,1194],{},"CERT.DCL.AMBIGUOUS_DECL",[1053,1196,1197],{},[1174,1198],{},[1022,1200,1202,1208,1214,1226],{"className":1201},[1151],[1053,1203,1204],{},[48,1205,1207],{"href":1206},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","LDRA tool suite",[1053,1209,1210],{},[1130,1211,1213],{"className":1212},[1133],"9.7.1",[1053,1215,1216],{},[39,1217,1218,1221,1222],{},[1140,1219,1220],{},"296 S"," ",[1140,1223,1224],{},[1174,1225],{},[1053,1227,1228],{},[39,1229,1230],{},"Partially implemented",[1022,1232,1234,1240,1247,1264],{"className":1233},[1120],[1053,1235,1236],{},[48,1237,1239],{"href":1238},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1053,1241,1242],{},[1130,1243,1245],{"className":1244},[1133],[39,1246,1165],{},[1053,1248,1249],{},[39,1250,1251,1254,1256],{},[1140,1252,1253],{},"CERT_CPP-DCL53-a",[1174,1255],{},[1140,1257,1258,1259,1261,1262],{},"CERT_CPP-DCL53-b",[1174,1260],{},"\nCERT_CPP-DCL53-c",[1174,1263],{},[1053,1265,1266],{},[39,1267,1268,1269,1271,1272,1274],{},"Parameter names in function declarations should not be enclosed in parentheses",[1174,1270],{},"\nLocal variable names in variable declarations should not be enclosed in parentheses",[1174,1273],{},"\nAvoid function declarations that are syntactically ambiguous",[1022,1276,1278,1284,1292,1298],{"className":1277},[1151],[1053,1279,1280],{},[48,1281,1283],{"href":1282},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1053,1285,1286],{},[1130,1287,1289],{"className":1288},[1133],[39,1290,1291],{},"R2025b",[1053,1293,1294],{},[48,1295,1297],{"href":1296},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcdcl53cpp.html","CERT C++: DCL53-CPP",[1053,1299,1300,1303,1313],{},[39,1301,1302],{},"Checks for declarations that can be confused between:",[1304,1305,1306,1310],"ul",{},[1307,1308,1309],"li",{},"Function and object declaration",[1307,1311,1312],{},"Unnamed object or function parameter declaration",[39,1314,1315],{},"Rule fully covered.",[1022,1317,1319,1325,1331,1336],{"className":1318},[1120],[1053,1320,1321],{},[48,1322,1324],{"href":1323},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","Clang",[1053,1326,1327],{},[1130,1328,1330],{"className":1329},[1133],"3.9",[1053,1332,1333],{},[67,1334,1335],{},"      -Wvexing-parse     ",[1053,1337,1338],{},[1174,1339],{},[1022,1341,1343,1349,1355,1363],{"className":1342},[1151],[1053,1344,1345],{},[48,1346,1348],{"href":1347},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin","SonarQube C\u002FC++ Plugin",[1053,1350,1351],{},[1130,1352,1354],{"className":1353},[1133],"4.10",[1053,1356,1357],{},[1140,1358,1359],{},[48,1360,1362],{"href":1361},"https:\u002F\u002Fwww.sonarsource.com\u002Fproducts\u002Fcodeanalyzers\u002Fsonarcfamilyforcpp\u002Frules-cpp.html#RSPEC-3468","S3468",[1053,1364,1365],{},[1174,1366],{},[1081,1368,1370],{"id":1369},"related-vulnerabilities","Related Vulnerabilities",[39,1372,1373,1374,1378,1379,546],{},"Search for other ",[48,1375,1377],{"href":1376},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[48,1380,1384],{"href":1381,"rel":1382},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+DCL34-CPP",[1383],"nofollow","CERT website",[86,1386,1388],{"id":1387},"bibliography","Bibliography",[1014,1390,1392],{"className":1391},[1088],[1048,1393,1394,1409],{},[1022,1395,1397,1403],{"className":1396},[1120],[1053,1398,1399,1400,1402],{},"[ ",[48,1401,51],{"href":50}," ]",[1053,1404,1405,1406,1408],{},"Subclause 6.8, \"Ambiguity Resolution\"",[1174,1407],{},"\nSubclause 8.2, \"Ambiguity Resolution\"",[1022,1410,1412,1418],{"className":1411},[1151],[1053,1413,1399,1414,1402],{},[48,1415,1417],{"href":1416},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Meyers01","Meyers 2001",[1053,1419,1420],{},"Item 6, \"Be Alert for C++'s Most Vexing Parse\"",[1422,1423],"hr",{},[39,1425,1426,1221,1433,1221,1439],{},[48,1427,1429],{"href":1428},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl52-cpp",[1430,1431],"img",{"src":1432},"\u002Fattachments\u002F88046682\u002F88480621.png",[48,1434,1436],{"href":1435},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002F",[1430,1437],{"src":1438},"\u002Fattachments\u002F88046682\u002F88475556.png",[48,1440,1442],{"href":1441},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl54-cpp",[1430,1443],{"src":1444},"\u002Fattachments\u002F88046682\u002F88475555.png",[1446,1447,1448],"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 .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 .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}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":119,"searchDepth":137,"depth":137,"links":1450},[1451,1452,1453,1454,1455,1456,1457,1461],{"id":88,"depth":137,"text":89},{"id":235,"depth":137,"text":236},{"id":329,"depth":137,"text":89},{"id":440,"depth":137,"text":236},{"id":549,"depth":137,"text":89},{"id":781,"depth":137,"text":236},{"id":1008,"depth":137,"text":1009,"children":1458},[1459,1460],{"id":1083,"depth":143,"text":1084},{"id":1369,"depth":143,"text":1370},{"id":1387,"depth":137,"text":1388},"It is possible to devise syntax that can ambiguously be interpreted as either an expression statement or a declaration. Syntax of this sort is called a vexing parse because the compiler must use disambiguation rules to determine the semantic results. The C++ Standard, [stmt.ambig], paragraph 1 [ ISO\u002FIEC 14882-2014 ], in part, states the following:","md",{"tags":1465},[1466,1467,1468,1469,1470,1471],"review","dcl","ptc","review-dms","rule","review-ajb","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-cpp",{"title":30,"description":1462},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F05.dcl53-cpp","8WYHGJCeLNR3RSI-ydBVhGQMg73DoWNCzongNfuKqIY",[1477,1480],{"title":1478,"path":1428,"stem":1479,"children":-1},"DCL52-CPP. Never qualify a reference type with const or volatile","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F04.dcl52-cpp",{"title":1481,"path":1441,"stem":1482,"children":-1},"DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F06.dcl54-cpp",[1484],{"title":1485,"path":1486,"stem":1487,"children":1488},"SEI CERT C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[1489,1490,1557,1952,2164,2174],{"title":1485,"path":1486,"stem":1487},{"title":1491,"path":1492,"stem":1493,"children":1494},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[1495,1496],{"title":1491,"path":1492,"stem":1493},{"title":1497,"path":1498,"stem":1499,"children":1500},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[1501,1502,1506,1510,1514,1518,1522,1526,1530,1534,1538,1542,1546,1550,1554],{"title":1497,"path":1498,"stem":1499},{"title":1503,"path":1504,"stem":1505},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":1507,"path":1508,"stem":1509},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":1511,"path":1512,"stem":1513},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":1515,"path":1516,"stem":1517},"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":1519,"path":1520,"stem":1521},"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":1523,"path":1524,"stem":1525},"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":1527,"path":1528,"stem":1529},"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":1531,"path":1532,"stem":1533},"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":1535,"path":1536,"stem":1537},"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":1539,"path":1540,"stem":1541},"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":1543,"path":1544,"stem":1545},"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":1547,"path":1548,"stem":1549},"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":1551,"path":1552,"stem":1553},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":1084,"path":1555,"stem":1556},"\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":1558,"path":1559,"stem":1560,"children":1561},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[1562,1563,1585,1619,1661,1702,1760,1822,1836,1846,1884,1910],{"title":1558,"path":1559,"stem":1560},{"title":1564,"path":1565,"stem":1566,"children":1567},"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",[1568,1569,1573,1577,1581],{"title":1564,"path":1565,"stem":1566},{"title":1570,"path":1571,"stem":1572},"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":1574,"path":1575,"stem":1576},"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":1578,"path":1579,"stem":1580},"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":1582,"path":1583,"stem":1584},"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":1586,"path":1587,"stem":1588,"children":1589},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[1590,1591,1595,1599,1603,1607,1611,1615],{"title":1586,"path":1587,"stem":1588},{"title":1592,"path":1593,"stem":1594},"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":1596,"path":1597,"stem":1598},"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":1600,"path":1601,"stem":1602},"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":1604,"path":1605,"stem":1606},"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":1608,"path":1609,"stem":1610},"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":1612,"path":1613,"stem":1614},"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":1616,"path":1617,"stem":1618},"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":1620,"path":1621,"stem":1622,"children":1623},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[1624,1625,1629,1633,1637,1641,1645,1649,1653,1657],{"title":1620,"path":1621,"stem":1622},{"title":1626,"path":1627,"stem":1628},"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":1630,"path":1631,"stem":1632},"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":1634,"path":1635,"stem":1636},"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":1638,"path":1639,"stem":1640},"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":1642,"path":1643,"stem":1644},"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":1646,"path":1647,"stem":1648},"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":1650,"path":1651,"stem":1652},"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":1654,"path":1655,"stem":1656},"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":1658,"path":1659,"stem":1660},"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":1662,"path":1663,"stem":1664,"children":1665},"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",[1666,1667,1671,1675,1676,1677,1678,1682,1686,1690,1694,1698],{"title":1662,"path":1663,"stem":1664},{"title":1668,"path":1669,"stem":1670},"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":1672,"path":1673,"stem":1674},"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":1478,"path":1428,"stem":1479},{"title":30,"path":1472,"stem":1474},{"title":1481,"path":1441,"stem":1482},{"title":1679,"path":1680,"stem":1681},"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":1683,"path":1684,"stem":1685},"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":1687,"path":1688,"stem":1689},"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":1691,"path":1692,"stem":1693},"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":1695,"path":1696,"stem":1697},"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":1699,"path":1700,"stem":1701},"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":1703,"path":1704,"stem":1705,"children":1706},"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",[1707,1708,1712,1716,1720,1724,1728,1732,1736,1740,1744,1748,1752,1756],{"title":1703,"path":1704,"stem":1705},{"title":1709,"path":1710,"stem":1711},"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":1713,"path":1714,"stem":1715},"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":1717,"path":1718,"stem":1719},"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":1721,"path":1722,"stem":1723},"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":1725,"path":1726,"stem":1727},"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":1729,"path":1730,"stem":1731},"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":1733,"path":1734,"stem":1735},"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":1737,"path":1738,"stem":1739},"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":1741,"path":1742,"stem":1743},"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":1745,"path":1746,"stem":1747},"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":1749,"path":1750,"stem":1751},"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":1753,"path":1754,"stem":1755},"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":1757,"path":1758,"stem":1759},"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":1761,"path":1762,"stem":1763,"children":1764},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[1765,1766,1770,1774,1778,1782,1786,1790,1794,1798,1802,1806,1810,1814,1818],{"title":1761,"path":1762,"stem":1763},{"title":1767,"path":1768,"stem":1769},"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":1771,"path":1772,"stem":1773},"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":1775,"path":1776,"stem":1777},"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":1779,"path":1780,"stem":1781},"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":1783,"path":1784,"stem":1785},"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":1787,"path":1788,"stem":1789},"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":1791,"path":1792,"stem":1793},"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":1795,"path":1796,"stem":1797},"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":1799,"path":1800,"stem":1801},"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":1803,"path":1804,"stem":1805},"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":1807,"path":1808,"stem":1809},"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":1811,"path":1812,"stem":1813},"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":1815,"path":1816,"stem":1817},"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":1819,"path":1820,"stem":1821},"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":1823,"path":1824,"stem":1825,"children":1826},"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",[1827,1828,1832],{"title":1823,"path":1824,"stem":1825},{"title":1829,"path":1830,"stem":1831},"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":1833,"path":1834,"stem":1835},"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":1837,"path":1838,"stem":1839,"children":1840},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[1841,1842],{"title":1837,"path":1838,"stem":1839},{"title":1843,"path":1844,"stem":1845},"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":1847,"path":1848,"stem":1849,"children":1850},"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",[1851,1852,1856,1860,1864,1868,1872,1876,1880],{"title":1847,"path":1848,"stem":1849},{"title":1853,"path":1854,"stem":1855},"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":1857,"path":1858,"stem":1859},"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":1861,"path":1862,"stem":1863},"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":1865,"path":1866,"stem":1867},"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":1869,"path":1870,"stem":1871},"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":1873,"path":1874,"stem":1875},"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":1877,"path":1878,"stem":1879},"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":1881,"path":1882,"stem":1883},"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":1885,"path":1886,"stem":1887,"children":1888},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[1889,1890,1894,1898,1902,1906],{"title":1885,"path":1886,"stem":1887},{"title":1891,"path":1892,"stem":1893},"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":1895,"path":1896,"stem":1897},"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":1899,"path":1900,"stem":1901},"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":1903,"path":1904,"stem":1905},"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":1907,"path":1908,"stem":1909},"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":1911,"path":1912,"stem":1913,"children":1914},"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",[1915,1916,1920,1924,1928,1932,1936,1940,1944,1948],{"title":1911,"path":1912,"stem":1913},{"title":1917,"path":1918,"stem":1919},"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":1921,"path":1922,"stem":1923},"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":1925,"path":1926,"stem":1927},"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":1929,"path":1930,"stem":1931},"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":1933,"path":1934,"stem":1935},"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":1937,"path":1938,"stem":1939},"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":1941,"path":1942,"stem":1943},"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":1945,"path":1946,"stem":1947},"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":1949,"path":1950,"stem":1951},"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":1953,"path":1954,"stem":1955,"children":1956},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[1957,1958,1962,1966,2146,2160],{"title":1953,"path":1954,"stem":1955},{"title":1959,"path":1960,"stem":1961},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":1963,"path":1964,"stem":1965},"BB. Definitions","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":1967,"path":1968,"stem":1969,"children":1970},"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",[1971,1972,1976,1980,1984,1988,1990,1994,1998,2002,2006,2010,2014,2016,2020,2024,2028,2032,2036,2040,2044,2048,2052,2054,2058,2060,2064,2067,2071,2074,2078,2080,2084,2088,2092,2096,2100,2104,2108,2112,2116,2120,2124,2128,2132,2134,2138,2142],{"title":1967,"path":1968,"stem":1969},{"title":1973,"path":1974,"stem":1975},"Astrée","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":1977,"path":1978,"stem":1979},"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":1981,"path":1982,"stem":1983},"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":1985,"path":1986,"stem":1987},"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":1324,"path":1323,"stem":1989},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":1991,"path":1992,"stem":1993},"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":1995,"path":1996,"stem":1997},"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":1999,"path":2000,"stem":2001},"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":2003,"path":2004,"stem":2005},"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":2007,"path":2008,"stem":2009},"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":2011,"path":2012,"stem":2013},"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":1126,"path":1125,"stem":2015},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":2017,"path":2018,"stem":2019},"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":2021,"path":2022,"stem":2023},"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":2025,"path":2026,"stem":2027},"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":2029,"path":2030,"stem":2031},"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":2033,"path":2034,"stem":2035},"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":2037,"path":2038,"stem":2039},"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":2041,"path":2042,"stem":2043},"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":2045,"path":2046,"stem":2047},"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":2049,"path":2050,"stem":2051},"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":1157,"path":1156,"stem":2053},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":2055,"path":2056,"stem":2057},"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":1184,"path":1183,"stem":2059},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":2061,"path":2062,"stem":2063},"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":2065,"path":1206,"stem":2066},"LDRA","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":2068,"path":2069,"stem":2070},"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":2072,"path":1238,"stem":2073},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":2075,"path":2076,"stem":2077},"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":1283,"path":1282,"stem":2079},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":2081,"path":2082,"stem":2083},"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":2085,"path":2086,"stem":2087},"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":2089,"path":2090,"stem":2091},"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":2093,"path":2094,"stem":2095},"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":2097,"path":2098,"stem":2099},"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":2101,"path":2102,"stem":2103},"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":2105,"path":2106,"stem":2107},"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":2109,"path":2110,"stem":2111},"RuleChecker","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F39.rulechecker",{"title":2113,"path":2114,"stem":2115},"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":2117,"path":2118,"stem":2119},"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":2121,"path":2122,"stem":2123},"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":2125,"path":2126,"stem":2127},"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":2129,"path":2130,"stem":2131},"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":1348,"path":1347,"stem":2133},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F45.sonarqube-ccpp-plugin",{"title":2135,"path":2136,"stem":2137},"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":2139,"path":2140,"stem":2141},"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":2143,"path":2144,"stem":2145},"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":2147,"path":2148,"stem":2149,"children":2150},"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",[2151,2152,2156],{"title":2147,"path":2148,"stem":2149},{"title":2153,"path":2154,"stem":2155},"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":2157,"path":2158,"stem":2159},"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":2161,"path":2162,"stem":2163},"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":2165,"path":2166,"stem":2167,"children":2168},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[2169,2170],{"title":2165,"path":2166,"stem":2167},{"title":2171,"path":2172,"stem":2173},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":2175,"path":2176,"stem":2177},"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",1775657779532]