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