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