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