[{"data":1,"prerenderedAt":2638},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp53-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp53-cpp":1944,"sidebar-sei-cert-cpp-coding-standard":1951},[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":1929,"extension":1930,"meta":1931,"navigation":7,"path":1940,"seo":1941,"stem":1942,"__hash__":1943},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F05.exp53-cpp.md","EXP53-CPP. Do not read uninitialized memory",{"type":32,"value":33,"toc":1912},"minimark",[34,38,48,84,87,130,155,182,188,201,206,211,288,292,295,352,355,371,443,446,453,525,531,632,635,657,777,780,790,906,914,926,1020,1026,1035,1124,1128,1136,1203,1207,1787,1791,1804,1808,1833,1837,1884,1887,1908],[35,36,30],"h1",{"id":37},"exp53-cpp-do-not-read-uninitialized-memory",[39,40,41,42,47],"p",{},"Local, automatic variables assume unexpected values if they are read before they are initialized. The C++ Standard, [dcl.init], paragraph 12 [ ",[43,44,46],"a",{"href":45},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], states the following:",[49,50,51,59],"blockquote",{},[39,52,53,54,58],{},"If no initializer is specified for an object, the object is default-initialized. When storage for an object with automatic or dynamic storage duration is obtained, the object has an ",[55,56,57],"em",{},"indeterminate value"," , and if no initialization is performed for the object, that object retains an indeterminate value until that value is replaced. If an indeterminate value is produced by an evaluation, the behavior is undefined except in the following cases:",[39,60,61,62,65,66,68,69,71,72,74,75,77,78,80,81,83],{},"— If an indeterminate value of unsigned narrow character type is produced by the evaluation of:",[63,64],"br",{},"\n— the second or third operand of a conditional expression,",[63,67],{},"\n— the right operand of a comma expression,",[63,70],{},"\n— the operand of a cast or conversion to an unsigned narrow character type, or",[63,73],{},"\n— a discarded-value expression,",[63,76],{},"\nthen the result of the operation is an indeterminate value.",[63,79],{},"\n— If an indeterminate value of unsigned narrow character type is produced by the evaluation of the right operand of a simple assignment operator whose first operand is an lvalue of unsigned narrow character type, an indeterminate value replaces the value of the object referred to by the left operand.",[63,82],{},"\n— If an indeterminate value of unsigned narrow character type is produced by the evaluation of the initialization expression when initializing an object of unsigned narrow character type, that object is initialized to an indeterminate value.",[39,85,86],{},"The default initialization of an object is described by paragraph 7 of the same subclause:",[49,88,89],{},[39,90,91,92,95,96,100,101,103,104,106,107,109,110,112,113,103,115,117,118,120,121,123,124,126,127,129],{},"To ",[55,93,94],{},"default-initialize"," an object of type ",[97,98,99],"code",{},"T"," means:",[63,102],{},"\n— if ",[97,105,99],{}," is a (possibly cv-qualified) class type, the default constructor for ",[97,108,99],{}," is called (and the initialization is ill-formed if ",[97,111,99],{}," has no default constructor or overload resolution results in an ambiguity or in a function that is deleted or inaccessible from the context of the initialization);",[63,114],{},[97,116,99],{}," is an array type, each element is default-initialized;",[63,119],{},"\n— otherwise, no initialization is performed.",[63,122],{},"\nIf a program calls for the default initialization of an object of a const-qualified type ",[97,125,99],{}," , ",[97,128,99],{}," shall be a class type with a user-provided default constructor.",[39,131,132,133,135,136,138,139,141,142,145,146,149,150,154],{},"As a result, objects of type ",[97,134,99],{}," with automatic or dynamic storage duration must be explicitly initialized before having their value read as part of an expression unless ",[97,137,99],{}," is a class type or an array thereof or is an unsigned narrow character type. If ",[97,140,99],{}," is an unsigned narrow character type, it may be used to initialize an object of unsigned narrow character type, which results in both objects having an ",[43,143,57],{"href":144},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-indeterminatevalue"," . This technique can be used to implement copy operations such as ",[97,147,148],{},"std::memcpy()"," without triggering ",[43,151,153],{"href":152},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-undefinedbehavior","undefined behavior"," .",[39,156,157,158,161,162,165,166,169,170,173,174,177,178,181],{},"Additionally, memory dynamically allocated with a ",[97,159,160],{},"new"," expression is default-initialized when the ",[55,163,164],{},"new-initialized"," is omitted. Memory allocated by the standard library function ",[97,167,168],{},"std::calloc()"," is zero-initialized. Memory allocated by the standard library function ",[97,171,172],{},"std::realloc()"," assumes the values of the original pointer but may not initialize the full range of memory. Memory allocated by any other means ( ",[97,175,176],{},"std::malloc()"," , allocator objects, ",[97,179,180],{},"  operator new() "," , and so on) is assumed to be default-initialized.",[39,183,184,185,187],{},"Objects of static or thread storage duration are zero-initialized before any other initialization takes place [ ",[43,186,46],{"href":45}," ] and need not be explicitly initialized before having their value read.",[39,189,190,191,195,196,200],{},"Reading uninitialized variables for creating entropy is problematic because these memory accesses can be removed by compiler optimization. VU925211 is an example of a ",[43,192,194],{"href":193},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerability"," caused by this coding error [ ",[43,197,199],{"href":198},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-VU925211","VU#925211"," ].",[202,203,205],"h2",{"id":204},"noncompliant-code-example","Noncompliant Code Example",[39,207,208,209,154],{},"In this noncompliant code example, an uninitialized local variable is evaluated as part of an expression to print its value, resulting in ",[43,210,153],{"href":152},[212,213,215],"code-block",{"quality":214},"bad",[216,217,222],"pre",{"className":218,"code":219,"language":220,"meta":221,"style":221},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Ciostream>\n \nvoid f() {\n  int i;\n  std::cout \u003C\u003C i;\n}\n","cpp","",[97,223,224,237,244,258,267,282],{"__ignoreMap":221},[225,226,229,233],"span",{"class":227,"line":228},"line",1,[225,230,232],{"class":231},"sC2Qs","#include",[225,234,236],{"class":235},"sstjo"," \u003Ciostream>\n",[225,238,240],{"class":227,"line":239},2,[225,241,243],{"class":242},"sMOD_"," \n",[225,245,247,251,255],{"class":227,"line":246},3,[225,248,250],{"class":249},"sq6CD","void",[225,252,254],{"class":253},"srTi1"," f",[225,256,257],{"class":242},"() {\n",[225,259,261,264],{"class":227,"line":260},4,[225,262,263],{"class":249},"  int",[225,265,266],{"class":242}," i;\n",[225,268,270,274,277,280],{"class":227,"line":269},5,[225,271,273],{"class":272},"sz2Vg","  std",[225,275,276],{"class":242},"::cout ",[225,278,279],{"class":231},"\u003C\u003C",[225,281,266],{"class":242},[225,283,285],{"class":227,"line":284},6,[225,286,287],{"class":242},"}\n",[202,289,291],{"id":290},"compliant-solution","Compliant Solution",[39,293,294],{},"In this compliant solution, the object is initialized prior to printing its value.",[212,296,298],{"quality":297},"good",[216,299,301],{"className":218,"code":300,"language":220,"meta":221,"style":221},"#include \u003Ciostream>\n \nvoid f() {\n  int i = 0;\n  std::cout \u003C\u003C i;\n}\n",[97,302,303,309,313,321,338,348],{"__ignoreMap":221},[225,304,305,307],{"class":227,"line":228},[225,306,232],{"class":231},[225,308,236],{"class":235},[225,310,311],{"class":227,"line":239},[225,312,243],{"class":242},[225,314,315,317,319],{"class":227,"line":246},[225,316,250],{"class":249},[225,318,254],{"class":253},[225,320,257],{"class":242},[225,322,323,325,328,331,335],{"class":227,"line":260},[225,324,263],{"class":249},[225,326,327],{"class":242}," i ",[225,329,330],{"class":231},"=",[225,332,334],{"class":333},"s7F3e"," 0",[225,336,337],{"class":242},";\n",[225,339,340,342,344,346],{"class":227,"line":269},[225,341,273],{"class":272},[225,343,276],{"class":242},[225,345,279],{"class":231},[225,347,266],{"class":242},[225,349,350],{"class":227,"line":284},[225,351,287],{"class":242},[202,353,205],{"id":354},"noncompliant-code-example-1",[39,356,357,358,361,362,365,366,368,369,154],{},"In this noncompliant code example, an ",[97,359,360],{},"  int * "," object is allocated by a ",[55,363,364],{},"new-expression"," , but the memory it points to is not initialized. The object's pointer value and the value it points to are printed to the standard output stream. Printing the pointer value is well-defined, but attempting to print the value pointed to yields an ",[43,367,57],{"href":144}," , resulting in ",[43,370,153],{"href":152},[212,372,373],{"quality":214},[216,374,376],{"className":218,"code":375,"language":220,"meta":221,"style":221},"#include \u003Ciostream>\n \nvoid f() {\n  int *i = new int;\n  std::cout \u003C\u003C i \u003C\u003C \", \" \u003C\u003C *i;\n}\n",[97,377,378,384,388,396,416,439],{"__ignoreMap":221},[225,379,380,382],{"class":227,"line":228},[225,381,232],{"class":231},[225,383,236],{"class":235},[225,385,386],{"class":227,"line":239},[225,387,243],{"class":242},[225,389,390,392,394],{"class":227,"line":246},[225,391,250],{"class":249},[225,393,254],{"class":253},[225,395,257],{"class":242},[225,397,398,400,403,406,408,411,414],{"class":227,"line":260},[225,399,263],{"class":249},[225,401,402],{"class":231}," *",[225,404,405],{"class":242},"i ",[225,407,330],{"class":231},[225,409,410],{"class":231}," new",[225,412,413],{"class":249}," int",[225,415,337],{"class":242},[225,417,418,420,422,424,426,428,431,434,436],{"class":227,"line":269},[225,419,273],{"class":272},[225,421,276],{"class":242},[225,423,279],{"class":231},[225,425,327],{"class":242},[225,427,279],{"class":231},[225,429,430],{"class":235}," \", \"",[225,432,433],{"class":231}," \u003C\u003C",[225,435,402],{"class":231},[225,437,438],{"class":242},"i;\n",[225,440,441],{"class":227,"line":284},[225,442,287],{"class":242},[202,444,291],{"id":445},"compliant-solution-1",[39,447,448,449,452],{},"In this compliant solution, the memory is direct-initialized to the value ",[97,450,451],{},"12"," prior to printing its value.",[212,454,455],{"quality":297},[216,456,458],{"className":218,"code":457,"language":220,"meta":221,"style":221},"#include \u003Ciostream>\n \nvoid f() {\n  int *i = new int(12);\n  std::cout \u003C\u003C i \u003C\u003C \", \" \u003C\u003C *i;\n}\n",[97,459,460,466,471,479,501,521],{"__ignoreMap":221},[225,461,462,464],{"class":227,"line":228},[225,463,232],{"class":231},[225,465,236],{"class":235},[225,467,468],{"class":227,"line":239},[225,469,470],{"class":242}," \n",[225,472,473,475,477],{"class":227,"line":246},[225,474,250],{"class":249},[225,476,254],{"class":253},[225,478,257],{"class":242},[225,480,481,483,485,487,489,491,493,496,498],{"class":227,"line":260},[225,482,263],{"class":249},[225,484,402],{"class":231},[225,486,405],{"class":242},[225,488,330],{"class":231},[225,490,410],{"class":231},[225,492,413],{"class":249},[225,494,495],{"class":242},"(",[225,497,451],{"class":333},[225,499,500],{"class":242},");\n",[225,502,503,505,507,509,511,513,515,517,519],{"class":227,"line":269},[225,504,273],{"class":272},[225,506,276],{"class":242},[225,508,279],{"class":231},[225,510,327],{"class":242},[225,512,279],{"class":231},[225,514,430],{"class":235},[225,516,433],{"class":231},[225,518,402],{"class":231},[225,520,438],{"class":242},[225,522,523],{"class":227,"line":284},[225,524,287],{"class":242},[39,526,527,528,530],{},"Initialization of an object produced by a ",[55,529,364],{}," is performed by placing (possibly empty) parenthesis or curly braces after the type being allocated. This causes direct initialization of the pointed-to object to occur, which will zero-initialize the object if the initialization omits a value, as illustrated by the following code.",[216,532,536],{"className":533,"code":534,"language":535,"meta":221,"style":221},"language-java shiki shiki-themes github-light github-dark monokai","int *i = new int(); \u002F\u002F zero-initializes *i\nint *j = new int{}; \u002F\u002F zero-initializes *j\nint *k = new int(12); \u002F\u002F initializes *k to 12\nint *l = new int{12}; \u002F\u002F initializes *l to 12\n","java",[97,537,538,560,581,606],{"__ignoreMap":221},[225,539,540,543,545,547,549,551,553,556],{"class":227,"line":228},[225,541,542],{"class":249},"int",[225,544,402],{"class":231},[225,546,405],{"class":242},[225,548,330],{"class":231},[225,550,410],{"class":231},[225,552,413],{"class":253},[225,554,555],{"class":242},"(); ",[225,557,559],{"class":558},"s8-w5","\u002F\u002F zero-initializes *i\n",[225,561,562,564,566,569,571,573,575,578],{"class":227,"line":239},[225,563,542],{"class":249},[225,565,402],{"class":231},[225,567,568],{"class":242},"j ",[225,570,330],{"class":231},[225,572,410],{"class":231},[225,574,413],{"class":249},[225,576,577],{"class":242},"{}; ",[225,579,580],{"class":558},"\u002F\u002F zero-initializes *j\n",[225,582,583,585,587,590,592,594,596,598,600,603],{"class":227,"line":246},[225,584,542],{"class":249},[225,586,402],{"class":231},[225,588,589],{"class":242},"k ",[225,591,330],{"class":231},[225,593,410],{"class":231},[225,595,413],{"class":253},[225,597,495],{"class":242},[225,599,451],{"class":333},[225,601,602],{"class":242},"); ",[225,604,605],{"class":558},"\u002F\u002F initializes *k to 12\n",[225,607,608,610,612,615,617,619,621,624,626,629],{"class":227,"line":260},[225,609,542],{"class":249},[225,611,402],{"class":231},[225,613,614],{"class":242},"l ",[225,616,330],{"class":231},[225,618,410],{"class":231},[225,620,413],{"class":249},[225,622,623],{"class":242},"{",[225,625,451],{"class":333},[225,627,628],{"class":242},"}; ",[225,630,631],{"class":558},"\u002F\u002F initializes *l to 12\n",[202,633,205],{"id":634},"noncompliant-code-example-2",[39,636,637,638,641,642,645,646,649,650,652,653,656],{},"In this noncompliant code example, the class member variable ",[97,639,640],{},"c"," is not explicitly initialized by a ",[55,643,644],{},"ctor-initializer"," in the default constructor. Despite the local variable ",[97,647,648],{},"s"," being default-initialized, the use of ",[97,651,640],{}," within the call to ",[97,654,655],{},"S::f()"," results in the evaluation of an object with indeterminate value, resulting in undefined behavior.",[212,658,659],{"quality":214},[216,660,662],{"className":218,"code":661,"language":220,"meta":221,"style":221},"class S {\n  int c;\n \npublic:\n  int f(int i) const { return i + c; }\n};\n \nvoid f() {\n  S s;\n  int i = s.f(10);\n}\n",[97,663,664,675,682,686,691,725,730,735,744,750,772],{"__ignoreMap":221},[225,665,666,669,672],{"class":227,"line":228},[225,667,668],{"class":249},"class",[225,670,671],{"class":272}," S",[225,673,674],{"class":242}," {\n",[225,676,677,679],{"class":227,"line":239},[225,678,263],{"class":249},[225,680,681],{"class":242}," c;\n",[225,683,684],{"class":227,"line":246},[225,685,243],{"class":242},[225,687,688],{"class":227,"line":260},[225,689,690],{"class":249},"public:\n",[225,692,693,695,697,699,701,705,708,711,714,717,719,722],{"class":227,"line":269},[225,694,263],{"class":249},[225,696,254],{"class":253},[225,698,495],{"class":242},[225,700,542],{"class":249},[225,702,704],{"class":703},"sTHNf"," i",[225,706,707],{"class":242},") ",[225,709,710],{"class":231},"const",[225,712,713],{"class":242}," { ",[225,715,716],{"class":231},"return",[225,718,327],{"class":242},[225,720,721],{"class":231},"+",[225,723,724],{"class":242}," c; }\n",[225,726,727],{"class":227,"line":284},[225,728,729],{"class":242},"};\n",[225,731,733],{"class":227,"line":732},7,[225,734,243],{"class":242},[225,736,738,740,742],{"class":227,"line":737},8,[225,739,250],{"class":249},[225,741,254],{"class":253},[225,743,257],{"class":242},[225,745,747],{"class":227,"line":746},9,[225,748,749],{"class":242},"  S s;\n",[225,751,753,755,757,759,762,765,767,770],{"class":227,"line":752},10,[225,754,263],{"class":249},[225,756,327],{"class":242},[225,758,330],{"class":231},[225,760,761],{"class":242}," s.",[225,763,764],{"class":253},"f",[225,766,495],{"class":242},[225,768,769],{"class":333},"10",[225,771,500],{"class":242},[225,773,775],{"class":227,"line":774},11,[225,776,287],{"class":242},[202,778,291],{"id":779},"compliant-solution-2",[39,781,782,783,786,787],{},"In this compliant solution, ",[97,784,785],{},"S"," is given a default constructor that initializes the class member variable ",[97,788,789],{},"c.",[212,791,792],{"quality":297},[216,793,795],{"className":218,"code":794,"language":220,"meta":221,"style":221},"class S {\n  int c;\n \npublic:\n  S() : c(0) {}\n  int f(int i) const { return i + c; }\n};\n \nvoid f() {\n  S s;\n  int i = s.f(10);\n}\n",[97,796,797,805,811,815,819,837,863,867,871,879,883,901],{"__ignoreMap":221},[225,798,799,801,803],{"class":227,"line":228},[225,800,668],{"class":249},[225,802,671],{"class":272},[225,804,674],{"class":242},[225,806,807,809],{"class":227,"line":239},[225,808,263],{"class":249},[225,810,681],{"class":242},[225,812,813],{"class":227,"line":246},[225,814,470],{"class":242},[225,816,817],{"class":227,"line":260},[225,818,690],{"class":249},[225,820,821,824,827,829,831,834],{"class":227,"line":269},[225,822,823],{"class":253},"  S",[225,825,826],{"class":242},"() : ",[225,828,640],{"class":253},[225,830,495],{"class":242},[225,832,833],{"class":333},"0",[225,835,836],{"class":242},") {}\n",[225,838,839,841,843,845,847,849,851,853,855,857,859,861],{"class":227,"line":284},[225,840,263],{"class":249},[225,842,254],{"class":253},[225,844,495],{"class":242},[225,846,542],{"class":249},[225,848,704],{"class":703},[225,850,707],{"class":242},[225,852,710],{"class":231},[225,854,713],{"class":242},[225,856,716],{"class":231},[225,858,327],{"class":242},[225,860,721],{"class":231},[225,862,724],{"class":242},[225,864,865],{"class":227,"line":732},[225,866,729],{"class":242},[225,868,869],{"class":227,"line":737},[225,870,470],{"class":242},[225,872,873,875,877],{"class":227,"line":746},[225,874,250],{"class":249},[225,876,254],{"class":253},[225,878,257],{"class":242},[225,880,881],{"class":227,"line":752},[225,882,749],{"class":242},[225,884,885,887,889,891,893,895,897,899],{"class":227,"line":774},[225,886,263],{"class":249},[225,888,327],{"class":242},[225,890,330],{"class":231},[225,892,761],{"class":242},[225,894,764],{"class":253},[225,896,495],{"class":242},[225,898,769],{"class":333},[225,900,500],{"class":242},[225,902,904],{"class":227,"line":903},12,[225,905,287],{"class":242},[202,907,909,910,913],{"id":908},"noncompliant-code-example-uninitialized-delete","Noncompliant Code Example (Uninitialized ",[97,911,912],{},"delete"," )",[39,915,916,917,920,921,923,924,154],{},"In this noncompliant code example, the ",[97,918,919],{},"catch"," handler attempts to free the resource. However, the pointer variable has not previously been initialized to a known value.  If the allocation of memory for ",[97,922,39],{}," fails, the program will jump to the catch clause without initializing it. This will result in reading the uninitialized pointer, resulting in ",[43,925,153],{"href":152},[212,927,928],{"quality":214},[216,929,931],{"className":218,"code":930,"language":220,"meta":221,"style":221},"#include \u003Cnew>\n \nvoid f() {\n  int *p;\n  try {\n    p = new int;\n  } catch (std::bad_alloc &) {\n    delete p;\n  }\n}\n",[97,932,933,940,944,952,961,968,981,1003,1011,1016],{"__ignoreMap":221},[225,934,935,937],{"class":227,"line":228},[225,936,232],{"class":231},[225,938,939],{"class":235}," \u003Cnew>\n",[225,941,942],{"class":227,"line":239},[225,943,243],{"class":242},[225,945,946,948,950],{"class":227,"line":246},[225,947,250],{"class":249},[225,949,254],{"class":253},[225,951,257],{"class":242},[225,953,954,956,958],{"class":227,"line":260},[225,955,263],{"class":249},[225,957,402],{"class":231},[225,959,960],{"class":242},"p;\n",[225,962,963,966],{"class":227,"line":269},[225,964,965],{"class":231},"  try",[225,967,674],{"class":242},[225,969,970,973,975,977,979],{"class":227,"line":284},[225,971,972],{"class":242},"    p ",[225,974,330],{"class":231},[225,976,410],{"class":231},[225,978,413],{"class":249},[225,980,337],{"class":242},[225,982,983,986,988,991,994,997,1000],{"class":227,"line":732},[225,984,985],{"class":242},"  } ",[225,987,919],{"class":231},[225,989,990],{"class":242}," (",[225,992,993],{"class":272},"std",[225,995,996],{"class":242},"::bad_alloc ",[225,998,999],{"class":231},"&",[225,1001,1002],{"class":242},") {\n",[225,1004,1005,1008],{"class":227,"line":737},[225,1006,1007],{"class":231},"    delete",[225,1009,1010],{"class":242}," p;\n",[225,1012,1013],{"class":227,"line":746},[225,1014,1015],{"class":242},"  }\n",[225,1017,1018],{"class":227,"line":752},[225,1019,287],{"class":242},[202,1021,1023,1024,913],{"id":1022},"compliant-solution-uninitialized-delete","Compliant Solution (Uninitialized ",[97,1025,912],{},[39,1027,1028,1029,1032,1033,154],{},"This compliant solution initializes the pointer value to ",[97,1030,1031],{},"nullptr"," , which prevents an uninitialized value from being passed to ",[97,1034,912],{},[212,1036,1037],{"quality":297},[216,1038,1040],{"className":218,"code":1039,"language":220,"meta":221,"style":221},"#include \u003Cnew>\n \nvoid f() {\n  int *p = nullptr;\n  try {\n    p = new int;\n  } catch (std::bad_alloc &) {\n    delete p;\n  }\n}\n",[97,1041,1042,1048,1052,1060,1076,1082,1094,1110,1116,1120],{"__ignoreMap":221},[225,1043,1044,1046],{"class":227,"line":228},[225,1045,232],{"class":231},[225,1047,939],{"class":235},[225,1049,1050],{"class":227,"line":239},[225,1051,243],{"class":242},[225,1053,1054,1056,1058],{"class":227,"line":246},[225,1055,250],{"class":249},[225,1057,254],{"class":253},[225,1059,257],{"class":242},[225,1061,1062,1064,1066,1069,1071,1074],{"class":227,"line":260},[225,1063,263],{"class":249},[225,1065,402],{"class":231},[225,1067,1068],{"class":242},"p ",[225,1070,330],{"class":231},[225,1072,1073],{"class":333}," nullptr",[225,1075,337],{"class":242},[225,1077,1078,1080],{"class":227,"line":269},[225,1079,965],{"class":231},[225,1081,674],{"class":242},[225,1083,1084,1086,1088,1090,1092],{"class":227,"line":284},[225,1085,972],{"class":242},[225,1087,330],{"class":231},[225,1089,410],{"class":231},[225,1091,413],{"class":249},[225,1093,337],{"class":242},[225,1095,1096,1098,1100,1102,1104,1106,1108],{"class":227,"line":732},[225,1097,985],{"class":242},[225,1099,919],{"class":231},[225,1101,990],{"class":242},[225,1103,993],{"class":272},[225,1105,996],{"class":242},[225,1107,999],{"class":231},[225,1109,1002],{"class":242},[225,1111,1112,1114],{"class":227,"line":737},[225,1113,1007],{"class":231},[225,1115,1010],{"class":242},[225,1117,1118],{"class":227,"line":746},[225,1119,1015],{"class":242},[225,1121,1122],{"class":227,"line":752},[225,1123,287],{"class":242},[202,1125,1127],{"id":1126},"risk-assessment","Risk Assessment",[39,1129,1130,1131,1135],{},"Reading uninitialized variables is undefined behavior and can result in unexpected program behavior. In some cases, these ",[43,1132,1134],{"href":1133},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-securityflaw","security flaws"," may allow the execution of arbitrary code.",[1137,1138,1139,1140,1139,1170],"table",{},"\n  ",[1141,1142,1143,1144,1139],"thead",{},"\n    ",[1145,1146,1147,1148,1147,1152,1147,1155,1147,1158,1147,1161,1147,1164,1147,1167,1143],"tr",{},"\n      ",[1149,1150,1151],"th",{},"Rule",[1149,1153,1154],{},"Severity",[1149,1156,1157],{},"Likelihood",[1149,1159,1160],{},"Detectable",[1149,1162,1163],{},"Repairable",[1149,1165,1166],{},"Priority",[1149,1168,1169],{},"Level",[1171,1172,1143,1173,1139],"tbody",{},[1145,1174,1147,1175,1147,1179,1147,1182,1147,1185,1147,1188,1147,1191,1147,1198,1143],{},[1176,1177,1178],"td",{},"EXP53-CPP",[1176,1180,1181],{},"High",[1176,1183,1184],{},"Probable",[1176,1186,1187],{},"No",[1176,1189,1190],{},"Yes",[1176,1192,1194],{"style":1193},"color: #e74c3c;",[1195,1196,1197],"b",{},"P12",[1176,1199,1200],{"style":1193},[1195,1201,1202],{},"L1",[202,1204,1206],{"id":1205},"automated-detection","Automated Detection",[1137,1208,1211],{"className":1209},[1210],"wrapped",[1171,1212,1213,1237,1305,1336,1373,1404,1432,1495,1524,1548,1567,1608,1687,1735],{},[1145,1214,1217,1222,1227,1232],{"className":1215},[1216],"header",[1149,1218,1219],{},[39,1220,1221],{},"Tool",[1149,1223,1224],{},[39,1225,1226],{},"Version",[1149,1228,1229],{},[39,1230,1231],{},"Checker",[1149,1233,1234],{},[39,1235,1236],{},"Description",[1145,1238,1241,1247,1257,1302],{"className":1239},[1240],"odd",[1176,1242,1243],{},[43,1244,1246],{"href":1245},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","Astrée",[1176,1248,1249],{},[1250,1251,1254],"div",{"className":1252},[1253],"content-wrapper",[39,1255,1256],{},"25.10",[1176,1258,1260],{"style":1259},"vertical-align: top",[39,1261,1262,1268,1269,1268,1274,1268,1279,1268,1284,1268,1289,1268,1294,1268,1299],{},[1263,1264,1265,1266],"strong",{},"csa-call-uninitialized-function-pointer",[63,1267],{}," ",[1263,1270,1271,1272],{},"csa-call-uninitialized-object-pointer",[63,1273],{},[1263,1275,1276,1277],{},"csa-uninitialized-array-subscript",[63,1278],{},[1263,1280,1281,1282],{},"csa-uninitialized-assign",[63,1283],{},[1263,1285,1286,1287],{},"csa-uninitialized-binop-operand",[63,1288],{},[1263,1290,1291,1292],{},"csa-uninitialized-branch-condition",[63,1293],{},[1263,1295,1296,1297],{},"csa-uninitialized-return",[63,1298],{},[1263,1300,1301],{},"uninitialized-read",[1176,1303,1304],{},"Partially checked",[1145,1306,1309,1315,1323,1333],{"className":1307},[1308],"even",[1176,1310,1311],{},[43,1312,1314],{"href":1313},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","Clang",[1176,1316,1317],{},[1250,1318,1320],{"className":1319},[1253],[39,1321,1322],{},"3.9",[1176,1324,1325,1328,1330],{},[97,1326,1327],{},"      -Wuninitialized     ",[63,1329],{},[97,1331,1332],{},"      clang-analyzer-core.UndefinedBinaryOperatorResult     ",[1176,1334,1335],{},"Does not catch all instances of this rule, such as uninitialized values read from heap-allocated memory.",[1145,1337,1339,1345,1353,1365],{"className":1338},[1240],[1176,1340,1341],{},[43,1342,1344],{"href":1343},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodee","Codee",[1176,1346,1347],{},[1250,1348,1350],{"className":1349},[1253],[39,1351,1352],{},"2025.4.6",[1176,1354,1355,1360],{},[39,1356,1357],{},[1263,1358,1359],{},"PWR079",[39,1361,1362],{},[1263,1363,1364],{},"PWR080",[1176,1366,1367,1370],{},[39,1368,1369],{},"Avoid undefined behavior due to uninitialized variables",[39,1371,1372],{},"Conditionally initialized variables can lead to undefined behavior",[1145,1374,1376,1382,1388,1398],{"className":1375},[1308],[1176,1377,1378],{},[43,1379,1381],{"href":1380},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[1176,1383,1384],{},[1250,1385,1387],{"className":1386},[1253],"9.1p0",[1176,1389,1390],{},[39,1391,1392],{},[1263,1393,1394,1395,1397],{},"LANG.STRUCT.RPL",[63,1396],{},"\nLANG.MEM.UVAR",[1176,1399,1400,1401,1403],{},"Return pointer to local",[63,1402],{},"\nUninitialized variable",[1145,1405,1407,1413,1421,1428],{"className":1406},[1240],[1176,1408,1409],{},[43,1410,1412],{"href":1411},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[1176,1414,1415],{},[1250,1416,1418],{"className":1417},[1253],[39,1419,1420],{},"2025.2",[1176,1422,1423],{},[39,1424,1425],{},[1263,1426,1427],{},"DF726, DF2727, DF2728, DF2961, DF2962, DF2963, DF2966, DF2967, DF2968, DF2971, DF2972, DF2973, DF2976, DF2977, DF978",[1176,1429,1430],{},[63,1431],{},[1145,1433,1435,1441,1446,1491],{"className":1434},[1308],[1176,1436,1437],{},[43,1438,1440],{"href":1439},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","Klocwork",[1176,1442,1443],{},[1250,1444,1420],{"className":1445},[1253],[1176,1447,1448,1451,1453,1456,1458,1461,1463,1466,1468,1471,1473,1476,1478,1481,1483,1486,1488],{},[1263,1449,1450],{},"UNINIT.CTOR.MIGHT",[63,1452],{},[1263,1454,1455],{},"UNINIT.CTOR.MUST",[63,1457],{},[1263,1459,1460],{},"UNINIT.HEAP.MIGHT",[63,1462],{},[1263,1464,1465],{},"UNINIT.HEAP.MUST",[63,1467],{},[1263,1469,1470],{},"UNINIT.STACK.ARRAY.MIGHT",[63,1472],{},[1263,1474,1475],{},"UNINIT.STACK.ARRAY.MUST",[63,1477],{},[1263,1479,1480],{},"UNINIT.STACK.ARRAY.PARTIAL.MUST",[63,1482],{},[1263,1484,1485],{},"UNINIT.STACK.MIGHT",[63,1487],{},[1263,1489,1490],{},"UNINIT.STACK.MUST",[1176,1492,1493],{},[63,1494],{},[1145,1496,1498,1504,1510,1519],{"className":1497},[1240],[1176,1499,1500],{},[43,1501,1503],{"href":1502},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","LDRA tool suite",[1176,1505,1506],{},[1250,1507,1509],{"className":1508},[1253],"9.7.1",[1176,1511,1512],{},[39,1513,1514],{},[1263,1515,1516,1517],{},"53 D, 69 D, 631 S, 652 S",[63,1518],{},[1176,1520,1521],{},[39,1522,1523],{},"Partially implemented",[1145,1525,1527,1533,1538,1545],{"className":1526},[1308],[1176,1528,1529],{},[43,1530,1532],{"href":1531},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1176,1534,1535],{},[1250,1536,1420],{"className":1537},[1253],[1176,1539,1540],{},[1263,1541,1542,1543],{},"CERT_CPP-EXP53-a",[63,1544],{},[1176,1546,1547],{},"Avoid use before initialization",[1145,1549,1551,1556,1560,1564],{"className":1550},[1240],[1176,1552,1553],{},[43,1554,1555],{"href":1531},"Parasoft Insure++",[1176,1557,1558],{},[63,1559],{},[1176,1561,1562],{},[63,1563],{},[1176,1565,1566],{},"Runtime detection",[1145,1568,1570,1576,1584,1590],{"className":1569},[1308],[1176,1571,1572],{},[43,1573,1575],{"href":1574},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1176,1577,1578],{},[1250,1579,1581],{"className":1580},[1253],[39,1582,1583],{},"R2025b",[1176,1585,1586],{},[43,1587,1589],{"href":1588},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcexp53cpp.html","CERT C++: EXP53-CPP",[1176,1591,1592,1595,1605],{},[39,1593,1594],{},"Checks for:",[1596,1597,1598,1602],"ul",{},[1599,1600,1601],"li",{},"Non-initialized variable",[1599,1603,1604],{},"Non-initialized pointer",[39,1606,1607],{},"Rule partially covered.",[1145,1609,1611,1617,1625,1683],{"className":1610},[1240],[1176,1612,1613],{},[43,1614,1616],{"href":1615},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio","PVS-Studio",[1176,1618,1619],{},[1250,1620,1622],{"className":1621},[1253],[39,1623,1624],{},"7.42",[1176,1626,1627,126,1633,126,1639,126,1645,126,1651,126,1657,126,1663,126,1669,126,1675],{},[43,1628,1630],{"href":1629},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv546\u002F",[1263,1631,1632],{},"V546",[43,1634,1636],{"href":1635},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv573\u002F",[1263,1637,1638],{},"V573",[1263,1640,1641],{},[43,1642,1644],{"href":1643},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv614\u002F","V614",[1263,1646,1647],{},[43,1648,1650],{"href":1649},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv670\u002F","V670",[1263,1652,1653],{},[43,1654,1656],{"href":1655},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv679\u002F","V679",[1263,1658,1659],{},[43,1660,1662],{"href":1661},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv730\u002F","V730",[43,1664,1666],{"href":1665},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv788\u002F",[1263,1667,1668],{},"V788",[1263,1670,1671],{},[43,1672,1674],{"href":1673},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv1007\u002F","V1007",[1263,1676,1677,1681],{},[43,1678,1680],{"href":1679},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv1050\u002F","V1050",[63,1682],{},[1176,1684,1685],{},[63,1686],{},[1145,1688,1690,1696,1701,1733],{"className":1689},[1308],[1176,1691,1692],{},[43,1693,1695],{"href":1694},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker","RuleChecker",[1176,1697,1698],{},[1250,1699,1256],{"className":1700},[1253],[1176,1702,1703,1268,1707,1268,1711,1268,1715,1268,1719,1268,1723,1268,1727,1268,1731],{},[1263,1704,1265,1705],{},[63,1706],{},[1263,1708,1271,1709],{},[63,1710],{},[1263,1712,1276,1713],{},[63,1714],{},[1263,1716,1281,1717],{},[63,1718],{},[1263,1720,1286,1721],{},[63,1722],{},[1263,1724,1291,1725],{},[63,1726],{},[1263,1728,1296,1729],{},[63,1730],{},[1263,1732,1301],{},[1176,1734,1304],{},[1145,1736,1738,1744,1750,1784],{"className":1737},[1240],[1176,1739,1740],{},[43,1741,1743],{"href":1742},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsecurity-reviewer-static-reviewer","Security Reviewer - Static Reviewer",[1176,1745,1746],{},[1250,1747,1749],{"className":1748},[1253],"6.02",[1176,1751,1752],{},[1263,1753,1754,1755,1757,1758,1760,1761,1763,1764,1766,1767,1769,1770,1772,1773,1775,1776,1778,1779,1781,1782],{},"C54",[63,1756],{},"\nC55",[63,1759],{},"\nC56",[63,1762],{},"\nC57",[63,1765],{},"\nC58",[63,1768],{},"\nC59",[63,1771],{},"\nC60",[63,1774],{},"\nC61",[63,1777],{},"\nC62",[63,1780],{},"\nC63",[63,1783],{},[1176,1785,1786],{},"Fully implemented",[202,1788,1790],{"id":1789},"related-vulnerabilities","Related Vulnerabilities",[39,1792,1793,1794,1797,1798,154],{},"Search for ",[43,1795,1796],{"href":193},"vulnerabilities"," resulting from the violation of this rule on the ",[43,1799,1803],{"href":1800,"rel":1801},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+EXP33-CPP",[1802],"nofollow","CERT website",[202,1805,1807],{"id":1806},"related-guidelines","Related Guidelines",[1137,1809,1810,1818],{},[1141,1811,1812],{},[1145,1813,1814,1816],{},[1149,1815],{},[1149,1817],{},[1171,1819,1820],{},[1145,1821,1822,1827],{},[1176,1823,1824],{},[43,1825,1826],{"href":17},"SEI CERT C Coding Standard",[1176,1828,1829],{},[43,1830,1832],{"href":1831},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp33-c","EXP33-C. Do not read uninitialized memory",[202,1834,1836],{"id":1835},"bibliography","Bibliography",[1137,1838,1840,1849],{"className":1839},[1210],[1841,1842,1843,1847],"colgroup",{},[1844,1845],"col",{"style":1846},"width: 50%",[1844,1848],{"style":1846},[1171,1850,1851,1872],{},[1145,1852,1854,1860],{"className":1853},[1240],[1176,1855,1856,1857,1859],{},"[ ",[43,1858,46],{"href":45}," ]",[1176,1861,1862,1863,1865,1866,1868,1869,1871],{},"Clause 5, \"Expressions\"",[63,1864],{},"\nSubclause 5.3.4, \"New\"",[63,1867],{},"\nSubclause 8.5, \"Initializers\"",[63,1870],{},"\nSubclause 12.6.2, \"Initializing Bases and Members\"",[1145,1873,1875,1881],{"className":1874},[1308],[1176,1876,1856,1877,1859],{},[43,1878,1880],{"href":1879},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-LockheedMartin05","Lockheed Martin 2005",[1176,1882,1883],{},"Rule 142, All variables shall be initialized before use",[1885,1886],"hr",{},[39,1888,1889,1268,1896,1268,1902],{},[43,1890,1892],{"href":1891},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp52-cpp",[1893,1894],"img",{"src":1895},"\u002Fattachments\u002F88046682\u002F88480621.png",[43,1897,1899],{"href":1898},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002F",[1893,1900],{"src":1901},"\u002Fattachments\u002F88046682\u002F88475556.png",[43,1903,1905],{"href":1904},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp54-cpp",[1893,1906],{"src":1907},"\u002Fattachments\u002F88046682\u002F88475555.png",[1909,1910,1911],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sz2Vg, html code.shiki .sz2Vg{--shiki-default:#6F42C1;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-text-decoration:underline}html .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 .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html pre.shiki code .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}",{"title":221,"searchDepth":239,"depth":239,"links":1913},[1914,1915,1916,1917,1918,1919,1920,1922,1924,1925,1926,1927,1928],{"id":204,"depth":239,"text":205},{"id":290,"depth":239,"text":291},{"id":354,"depth":239,"text":205},{"id":445,"depth":239,"text":291},{"id":634,"depth":239,"text":205},{"id":779,"depth":239,"text":291},{"id":908,"depth":239,"text":1921},"Noncompliant Code Example (Uninitialized delete )",{"id":1022,"depth":239,"text":1923},"Compliant Solution (Uninitialized delete )",{"id":1126,"depth":239,"text":1127},{"id":1205,"depth":239,"text":1206},{"id":1789,"depth":239,"text":1790},{"id":1806,"depth":239,"text":1807},{"id":1835,"depth":239,"text":1836},"Local, automatic variables assume unexpected values if they are read before they are initialized. The C++ Standard, [dcl.init], paragraph 12 [ ISO\u002FIEC 14882-2014 ], states the following:","md",{"tags":1932},[1933,1934,1935,1936,1937,1938,1939],"review","review-dms","rule","nptc-aliasing","review-ajb","nptc","exp","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp53-cpp",{"title":30,"description":1929},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F05.exp53-cpp","76hps3YHm-nFBdWALuSsr0-egyw12ipQkQ_EZpwGPmc",[1945,1948],{"title":1946,"path":1891,"stem":1947,"children":-1},"EXP52-CPP. Do not rely on side effects in unevaluated operands","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F04.exp52-cpp",{"title":1949,"path":1904,"stem":1950,"children":-1},"EXP54-CPP. Do not access an object outside of its lifetime","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F06.exp54-cpp",[1952],{"title":1953,"path":1954,"stem":1955,"children":1956},"SEI CERT C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[1957,1958,2025,2420,2624,2634],{"title":1953,"path":1954,"stem":1955},{"title":1959,"path":1960,"stem":1961,"children":1962},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[1963,1964],{"title":1959,"path":1960,"stem":1961},{"title":1965,"path":1966,"stem":1967,"children":1968},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[1969,1970,1974,1978,1982,1986,1990,1994,1998,2002,2006,2010,2014,2018,2022],{"title":1965,"path":1966,"stem":1967},{"title":1971,"path":1972,"stem":1973},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":1975,"path":1976,"stem":1977},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":1979,"path":1980,"stem":1981},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":1983,"path":1984,"stem":1985},"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":1987,"path":1988,"stem":1989},"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":1991,"path":1992,"stem":1993},"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":1995,"path":1996,"stem":1997},"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":1999,"path":2000,"stem":2001},"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":2003,"path":2004,"stem":2005},"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":2007,"path":2008,"stem":2009},"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":2011,"path":2012,"stem":2013},"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":2015,"path":2016,"stem":2017},"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":2019,"path":2020,"stem":2021},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":1206,"path":2023,"stem":2024},"\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":2026,"path":2027,"stem":2028,"children":2029},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[2030,2031,2053,2087,2129,2179,2237,2290,2304,2314,2352,2378],{"title":2026,"path":2027,"stem":2028},{"title":2032,"path":2033,"stem":2034,"children":2035},"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",[2036,2037,2041,2045,2049],{"title":2032,"path":2033,"stem":2034},{"title":2038,"path":2039,"stem":2040},"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":2042,"path":2043,"stem":2044},"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":2046,"path":2047,"stem":2048},"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":2050,"path":2051,"stem":2052},"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":2054,"path":2055,"stem":2056,"children":2057},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[2058,2059,2063,2067,2071,2075,2079,2083],{"title":2054,"path":2055,"stem":2056},{"title":2060,"path":2061,"stem":2062},"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":2064,"path":2065,"stem":2066},"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":2068,"path":2069,"stem":2070},"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":2072,"path":2073,"stem":2074},"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":2076,"path":2077,"stem":2078},"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":2080,"path":2081,"stem":2082},"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":2084,"path":2085,"stem":2086},"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":2088,"path":2089,"stem":2090,"children":2091},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[2092,2093,2097,2101,2105,2109,2113,2117,2121,2125],{"title":2088,"path":2089,"stem":2090},{"title":2094,"path":2095,"stem":2096},"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":2098,"path":2099,"stem":2100},"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":2102,"path":2103,"stem":2104},"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":2106,"path":2107,"stem":2108},"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":2110,"path":2111,"stem":2112},"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":2114,"path":2115,"stem":2116},"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":2118,"path":2119,"stem":2120},"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":2122,"path":2123,"stem":2124},"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":2126,"path":2127,"stem":2128},"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":2130,"path":2131,"stem":2132,"children":2133},"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",[2134,2135,2139,2143,2147,2151,2155,2159,2163,2167,2171,2175],{"title":2130,"path":2131,"stem":2132},{"title":2136,"path":2137,"stem":2138},"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":2140,"path":2141,"stem":2142},"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":2144,"path":2145,"stem":2146},"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":2148,"path":2149,"stem":2150},"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":2152,"path":2153,"stem":2154},"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":2156,"path":2157,"stem":2158},"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":2160,"path":2161,"stem":2162},"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":2164,"path":2165,"stem":2166},"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":2168,"path":2169,"stem":2170},"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":2172,"path":2173,"stem":2174},"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":2176,"path":2177,"stem":2178},"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":2180,"path":2181,"stem":2182,"children":2183},"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",[2184,2185,2189,2193,2197,2201,2205,2209,2213,2217,2221,2225,2229,2233],{"title":2180,"path":2181,"stem":2182},{"title":2186,"path":2187,"stem":2188},"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":2190,"path":2191,"stem":2192},"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":2194,"path":2195,"stem":2196},"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":2198,"path":2199,"stem":2200},"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":2202,"path":2203,"stem":2204},"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":2206,"path":2207,"stem":2208},"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":2210,"path":2211,"stem":2212},"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":2214,"path":2215,"stem":2216},"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":2218,"path":2219,"stem":2220},"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":2222,"path":2223,"stem":2224},"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":2226,"path":2227,"stem":2228},"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":2230,"path":2231,"stem":2232},"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":2234,"path":2235,"stem":2236},"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":2238,"path":2239,"stem":2240,"children":2241},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[2242,2243,2247,2251,2252,2253,2254,2258,2262,2266,2270,2274,2278,2282,2286],{"title":2238,"path":2239,"stem":2240},{"title":2244,"path":2245,"stem":2246},"EXP50-CPP. Do not depend on the order of evaluation for side effects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F02.exp50-cpp",{"title":2248,"path":2249,"stem":2250},"EXP51-CPP. Do not delete an array through a pointer of the incorrect type","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F03.exp51-cpp",{"title":1946,"path":1891,"stem":1947},{"title":30,"path":1940,"stem":1942},{"title":1949,"path":1904,"stem":1950},{"title":2255,"path":2256,"stem":2257},"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":2259,"path":2260,"stem":2261},"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":2263,"path":2264,"stem":2265},"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":2267,"path":2268,"stem":2269},"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":2271,"path":2272,"stem":2273},"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":2275,"path":2276,"stem":2277},"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":2279,"path":2280,"stem":2281},"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":2283,"path":2284,"stem":2285},"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":2287,"path":2288,"stem":2289},"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":2291,"path":2292,"stem":2293,"children":2294},"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",[2295,2296,2300],{"title":2291,"path":2292,"stem":2293},{"title":2297,"path":2298,"stem":2299},"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":2301,"path":2302,"stem":2303},"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":2305,"path":2306,"stem":2307,"children":2308},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[2309,2310],{"title":2305,"path":2306,"stem":2307},{"title":2311,"path":2312,"stem":2313},"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":2315,"path":2316,"stem":2317,"children":2318},"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",[2319,2320,2324,2328,2332,2336,2340,2344,2348],{"title":2315,"path":2316,"stem":2317},{"title":2321,"path":2322,"stem":2323},"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":2325,"path":2326,"stem":2327},"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":2329,"path":2330,"stem":2331},"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":2333,"path":2334,"stem":2335},"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":2337,"path":2338,"stem":2339},"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":2341,"path":2342,"stem":2343},"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":2345,"path":2346,"stem":2347},"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":2349,"path":2350,"stem":2351},"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":2353,"path":2354,"stem":2355,"children":2356},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[2357,2358,2362,2366,2370,2374],{"title":2353,"path":2354,"stem":2355},{"title":2359,"path":2360,"stem":2361},"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":2363,"path":2364,"stem":2365},"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":2367,"path":2368,"stem":2369},"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":2371,"path":2372,"stem":2373},"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":2375,"path":2376,"stem":2377},"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":2379,"path":2380,"stem":2381,"children":2382},"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",[2383,2384,2388,2392,2396,2400,2404,2408,2412,2416],{"title":2379,"path":2380,"stem":2381},{"title":2385,"path":2386,"stem":2387},"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":2389,"path":2390,"stem":2391},"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":2393,"path":2394,"stem":2395},"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":2397,"path":2398,"stem":2399},"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":2401,"path":2402,"stem":2403},"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":2405,"path":2406,"stem":2407},"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":2409,"path":2410,"stem":2411},"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":2413,"path":2414,"stem":2415},"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":2417,"path":2418,"stem":2419},"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":2421,"path":2422,"stem":2423,"children":2424},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[2425,2426,2430,2434,2606,2620],{"title":2421,"path":2422,"stem":2423},{"title":2427,"path":2428,"stem":2429},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":2431,"path":2432,"stem":2433},"BB. Definitions","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":2435,"path":2436,"stem":2437,"children":2438},"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",[2439,2440,2442,2446,2450,2454,2456,2460,2464,2468,2472,2474,2478,2480,2484,2488,2492,2496,2500,2504,2508,2512,2516,2518,2522,2524,2528,2531,2535,2538,2542,2544,2548,2552,2556,2558,2562,2566,2570,2572,2576,2578,2582,2586,2590,2594,2598,2602],{"title":2435,"path":2436,"stem":2437},{"title":1246,"path":1245,"stem":2441},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":2443,"path":2444,"stem":2445},"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":2447,"path":2448,"stem":2449},"Axivion Bauhaus Suite","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Faxivion-bauhaus-suite","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F04.axivion-bauhaus-suite",{"title":2451,"path":2452,"stem":2453},"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":1314,"path":1313,"stem":2455},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":2457,"path":2458,"stem":2459},"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":2461,"path":2462,"stem":2463},"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":2465,"path":2466,"stem":2467},"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":2469,"path":2470,"stem":2471},"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":1344,"path":1343,"stem":2473},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F11.codee",{"title":2475,"path":2476,"stem":2477},"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":1381,"path":1380,"stem":2479},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":2481,"path":2482,"stem":2483},"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":2485,"path":2486,"stem":2487},"Coverity","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcoverity","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F15.coverity",{"title":2489,"path":2490,"stem":2491},"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":2493,"path":2494,"stem":2495},"ECLAIR","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Feclair","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F17.eclair",{"title":2497,"path":2498,"stem":2499},"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":2501,"path":2502,"stem":2503},"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":2505,"path":2506,"stem":2507},"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":2509,"path":2510,"stem":2511},"GCC","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fgcc","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F21.gcc",{"title":2513,"path":2514,"stem":2515},"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":1412,"path":1411,"stem":2517},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":2519,"path":2520,"stem":2521},"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":1440,"path":1439,"stem":2523},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":2525,"path":2526,"stem":2527},"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":2529,"path":1502,"stem":2530},"LDRA","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":2532,"path":2533,"stem":2534},"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":2536,"path":1531,"stem":2537},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":2539,"path":2540,"stem":2541},"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":1575,"path":1574,"stem":2543},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":2545,"path":2546,"stem":2547},"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":2549,"path":2550,"stem":2551},"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":2553,"path":2554,"stem":2555},"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":1616,"path":1615,"stem":2557},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F35.pvs-studio",{"title":2559,"path":2560,"stem":2561},"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":2563,"path":2564,"stem":2565},"Rose","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frose","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F37.rose",{"title":2567,"path":2568,"stem":2569},"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":1695,"path":1694,"stem":2571},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F39.rulechecker",{"title":2573,"path":2574,"stem":2575},"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":1743,"path":1742,"stem":2577},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F41.security-reviewer-static-reviewer",{"title":2579,"path":2580,"stem":2581},"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":2583,"path":2584,"stem":2585},"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":2587,"path":2588,"stem":2589},"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":2591,"path":2592,"stem":2593},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F45.sonarqube-ccpp-plugin",{"title":2595,"path":2596,"stem":2597},"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":2599,"path":2600,"stem":2601},"Splint","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsplint","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F47.splint",{"title":2603,"path":2604,"stem":2605},"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":2607,"path":2608,"stem":2609,"children":2610},"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",[2611,2612,2616],{"title":2607,"path":2608,"stem":2609},{"title":2613,"path":2614,"stem":2615},"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":2617,"path":2618,"stem":2619},"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":2621,"path":2622,"stem":2623},"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":2625,"path":2626,"stem":2627,"children":2628},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[2629,2630],{"title":2625,"path":2626,"stem":2627},{"title":2631,"path":2632,"stem":2633},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":2635,"path":2636,"stem":2637},"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",1775657781501]