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