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