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