| blob | ad789b83e71b71047a44c9ea728dba225be1af72 |
3 <html>
4 <head>
10 </head>
15 <!-- menu -->
16 <!--#include virtual="menu.html.incl"-->
17 <!-- page content -->
21 <p>This page contains a list of potential checkers to implement in the static analyzer. If you are interested in contributing to the analyzer's development, this is a good resource to help you get started. The specific names of the checkers are subject to review, and are provided here as suggestions.</p>
23 <!-- ========================= allocation/deallocation ======================= -->
32 Potential memory leaks caused by an undefined argument evaluation order.
33 <p>Source: <a href="https://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices">
37 void f(int, int);
38 int g(void *);
39 int h() __attribute__((noreturn));
41 void test() {
42 // It is possible that 'malloc(1)' is called first,
43 // then 'h()', that is (or calls) noreturn and eventually
44 // 'g()' is never called.
45 f(g(malloc(1)), h()); // warn: 'g()' may never be called.
46 }
47 </pre></div>
49 void f(int, int);
50 int g(int *);
51 int h() { throw 1; };
53 void test() {
54 // It is possible that 'new int' is called first,
55 // then 'h()', that throws an exception and eventually
56 // 'g()' is never called.
57 f(g(new int), h()); // warn: 'g()' may never be called.
58 }
59 </pre></div></div></td>
66 Destination buffer passed to memory function is too small.
70 <p>Source: <a href="https://cwe.mitre.org/data/definitions/120.html">CWE-120</a>.</p></div></div></td>
73 void test() {
74 const char* s1 = "abc";
75 char *s2 = new char;
76 strcpy(s2, s1); // warn
77 }
78 </pre></div>
80 void test() {
81 int* p1 = new int[3];
82 int* p2 = new int;
83 memcpy(p2, p1, 3); // warn
84 }
85 </pre></div></div></td>
92 'n' is used to specify the buffer size may be negative.
97 void test() {
98 int *p;
99 int n1 = -1;
100 p = new int[n1]; // warn
101 }
102 </pre></div></div></td>
108 Allocation of zero bytes.
117 void test() {
118 int *p = malloc(0); // warn
119 free(p);
120 }
121 </pre></div>
123 void test() {
124 int *p = new int[0]; // warn
125 delete[] p;
126 }
127 </pre></div></div></td>
129 D6178</a></td></tr>
131 </table>
133 <!-- ======================= constructors/destructors ====================== -->
142 It is dangerous to let an exception leave a destructor.
145 leaving destructors.</p></div></div></td>
148 class A {
149 A() {}
150 ~A() { throw 1; } // warn
151 };
152 </pre></div>
154 void f() throw(int);
156 class A {
157 A() {}
158 ~A() { f(); } // warn
159 };
160 </pre></div></div></td>
167 For a placement copy or move, it is almost certainly an error if the
168 constructed object is also the object being copied from.</div></div></td>
171 class A {};
173 void test(A *dst, A *src) {
174 ::new (dst) A(*dst); // warn (should be 'src')
175 }
176 </pre></div></div></td>
179 </table>
181 <!-- ============================== exceptions ============================= -->
191 function do not throw exceptions.</div></div></td>
194 void test() throw(int) {
195 } // warn
196 </pre></div></div></td>
204 specifier.</div></div></td>
207 void test() throw() {
208 throw(1); // warn
209 }
210 </pre></div></div></td>
217 The type of a thrown exception differs from those specified in
221 struct S{};
223 void test() throw(int) {
224 S s;
225 throw (s); // warn
226 }
227 </pre></div></div></td>
230 </table>
232 <!-- ========================= smart pointers ============================== -->
247 delete[].</code>.
248 <p>Source: C++03 20.4.5p1; C++11 <code>auto_ptr</code> is deprecated (D.10).</p></div></div></td>
254 void test() {
257 }
258 </pre></div>
263 void test() {
265 }
266 </pre></div></div></td>
269 </table>
271 <!-- ============================== dead code ============================== -->
280 A variable is never modified but was not declared const and is not a
284 extern int computeDelta();
286 int test(bool cond) {
287 int i = 0;
288 if (cond) {
289 const int delta = computeDelta();
290 // warn: forgot to modify 'i'
291 }
292 return i;
293 }
294 </pre></div></div></td>
300 Warn about idempotent operations.</div></div></td>
303 void test() {
304 int x = 7;
305 x = x; // warn: value is always the same
306 }
307 </pre></div>
309 void test() {
310 int x = 7;
311 x /= x; // warn: value is always 1
312 }
313 </pre></div>
315 void test() {
317 x *= one; // warn: right op is always 1
318 }
319 </pre></div>
321 void test() {
323 x = x - zero;
324 // warn: the right operand to '-' is always 0
325 }
326 </pre></div></div></td>
330 </table>
332 <!-- ================================ POSIX ================================ -->
342 fail.</div></div></td>
347 int readWrapper(int fd, int *count) {
348 int lcount = read(fd, globalBuf, sizeof(globalBuf));
349 if (lcount < 0)
350 return errno;
351 *count = lcount;
352 return 0;
353 }
355 void use(int fd) {
356 int count;
357 if (!readWrapper(fd, &count))
358 print("%d", count); // should not warn
359 }
360 </pre></div></div></td>
363 </table>
365 <!-- ========================= undefined behavior ========================== -->
375 the destruction of an object with static storage duration.
381 class A {
382 public:
383 ~A() {
384 std::exit(1); // warn
385 }
386 };
387 </pre></div></div></td>
394 Undefined behavior: function containing a definition of static local object is
395 called during the destruction of an object with static storage duration so that
396 flow of control passes through the definition of the previously destroyed
397 static local object.
401 void f();
403 class A {
404 public:
405 ~A() {
406 f(); // warn
407 }
408 };
410 class B {};
412 A a;
414 void f() {
415 static B b;
416 }
417 </pre></div></div></td>
424 The effect of dereferencing a pointer returned as a request for zero size is
425 undefined.<br>
427 unix.Malloc</span>.
433 void test() {
434 int *p = (int *)malloc(0);
435 *p = 1; // warn
436 free(p);
437 }
438 </pre></div>
440 void f(int);
442 void test() {
443 int *p = new int[0];
444 f(*p); // warn
445 delete[] p;
446 }
447 </pre></div></div></td>
454 Undefined behavior: the following usage of the pointer to the object whose
455 lifetime has ended can result in undefined behavior:<br>
456 The object will be or was of a class type with a non-trivial destructor and
458 The object will be or was of a non-POD class type (C++11: any class type) and
459 <ul><li>the pointer is used to access a non-static data member or call a
460 non-static member function of the object</li>
461 <li>the pointer is implicitly converted to a pointer to a base class
462 type</li>
472 class A {
473 public:
474 ~A();
475 };
477 class B : public A {};
479 void test() {
480 A *a = new A;
481 new(a) B;
482 delete a; // warn
483 }
484 </pre></div>
488 class A {
489 public:
490 ~A();
491 };
493 class B {};
495 void test() {
496 A *a = new A;
497 new(a) B;
498 a->~A();
499 }
500 </pre></div>
504 class A {
505 public:
506 ~A();
507 };
509 class B : public A {};
511 class C {};
513 void f(A*);
515 void test() {
516 B *b = new B;
517 new(b) C;
518 f(b); // warn
519 }
520 </pre></div>
524 class A {
525 public:
526 ~A();
527 };
529 class B : public A {};
531 class C {};
533 A* test() {
534 B *b = new B;
535 new(b) C;
537 }
538 </pre></div>
542 class A {
543 public:
544 ~A();
545 };
547 class B : public A {};
549 class C {};
551 A* test() {
552 B *b = new B;
553 new(b) C;
555 }
556 </pre></div></div></td>
563 Undefined behavior: the program must ensure that an object occupies the same
564 storage location when the implicit or explicit destructor call takes place.
570 class A {};
572 class B {
573 public:
574 ~B();
575 };
577 void test() {
578 B b;
579 new (&b) A;
580 } // warn
581 </pre></div>
585 class A {};
587 class B {
588 public:
589 ~B();
590 };
592 void test() {
593 B *b = new B;
594 new (b) A;
595 delete b; // warn
596 }
597 </pre></div></div></td>
604 Undefined behavior: a scalar object shall have its stored value modified at
605 most once by the evaluation of an expression.<br>
606 Note: most cases are currently handled by the Clang core (search for 'multiple
607 unsequenced modifications' warning in Clang tests).
611 int test () {
612 int i = 0;
613 i = ++i + 1; // warn
614 return i;
615 }
616 </pre></div></div></td>
623 Undefined behavior: static declaration is re-entered while the object is being
624 initialized.
628 int test(int i) {
629 static int s = test(2 * i); // warn
630 return i + 1;
631 }
632 </pre></div></div></td>
639 Undefined behavior: const object is being modified.
643 void test() {
644 const int *cp = new const int (0);
646 *p = 1; // warn
647 delete p;
648 }
649 </pre></div>
651 class C {
652 public :
653 int i;
654 C();
655 };
657 void test() {
658 const C cb;
662 }
663 </pre></div></div></td>
670 Undefined behavior: the destructor is invoked for an object whose lifetime
671 has ended.
675 class A {
676 public:
677 void f();
678 A();
679 ~A();
680 };
682 void test() {
683 A a;
684 a.~A();
685 } // warn
686 </pre></div></div></td>
693 Undefined behavior: calls member function but base not yet initialized.
697 class A {
698 public :
699 A(int);
700 };
702 class B : public A {
703 public :
704 int f();
705 B() : A(f()) {} // warn
706 };
707 </pre></div></div></td>
714 C++ Undefined behavior: non-static member or base class of non-POD class type
715 is referred before constructor begins execution.<br>
716 C++11 Undefined behavior: non-static member or base class of a class with a
717 non-trivial constructor is referred before constructor begins execution.
721 struct non_POD {
722 int i;
723 non_POD();
724 };
726 extern non_POD non_pod;
728 int *p = &non_pod.i; // warn
729 </pre></div>
731 struct POD {
732 int i;
733 };
735 struct non_POD : public POD {
736 POD pod;
737 };
739 extern non_POD non_pod;
741 int *p = &non_pod.pod.i; // warn
742 </pre></div>
744 struct POD {
745 int i;
746 };
748 struct non_POD : public POD {};
750 extern non_POD non_pod;
752 POD *p = &non_pod; // warn
753 </pre></div>
755 struct non_POD {
756 int i;
757 non_POD();
758 };
760 struct S {
761 int *k;
762 non_POD non_pod;
763 S() : k(&non_pod.i) {} // warn
764 };
765 </pre></div></div></td>
772 C++03: Undefined behavior: non-static member of non-POD class type is referred
773 after destructor ends execution.<br>
774 C++11: Undefined behavior: non-static member of a class with a non-trivial
775 destructor is referred after destructor ends execution.
779 class C {
780 public:
781 C();
782 void f();
783 };
785 void test() {
786 C *c = new C();
787 c->~C();
788 c->f(); // warn
789 }
790 </pre></div></div></td>
797 Undefined behavior: call to virtual function of an object under construction
798 whose type is neither the constructors own class or one of its bases.
802 class A {
803 public:
804 virtual void f() {};
805 };
807 class B {
808 public:
809 B(A* a) { a->f(); } // warn
810 };
812 class C : public A, B {
813 public:
814 C() : B((A*)this) {}
815 };
816 </pre></div></div></td>
824 construction whose type is neither the constructors own class or one of its
825 bases.
831 class A {};
833 class B {
834 public:
835 B(A* a) {
836 (void)typeid(*a); // warn
837 }
838 };
840 class C : public A, B {
841 public:
842 C() : B((A*)this) {}
843 };
844 </pre></div></div></td>
852 construction whose type is neither the constructors own class or one of its
853 bases.
859 class A {
860 public:
861 virtual void f() {};
862 };
864 class B {
865 public:
866 B(A* a) {
868 }
869 };
871 class C : public A, B {
872 public:
873 C() : B((A*)this) {}
874 };
875 </pre></div></div></td>
882 Undefined behavior: referring to any non-static member or base class of an
883 object in the handler for a function-try-block of a constructor or destructor
884 for that object results in undefined behavior.
888 void f() { throw 1; }
890 class C {
891 int i;
892 public :
893 C()
894 try {
895 f();
896 }
897 catch (...) {
898 i=2; // warn
899 }
900 };
901 </pre></div>
903 void f() { throw 1; }
905 class Base {
906 public:
907 int i;
908 };
910 class C: public Base {
911 public :
912 ~C() try {
913 f();
914 }
915 catch (...) {
916 i=2; // warn
917 }
918 };
919 </pre></div></div></td>
926 Undefined behavior: a function returns when control reaches the end of a
927 handler. This results in undefined behavior in a value-returning function.
931 void f() { throw 1; }
933 int test() try {
934 f();
935 return 1;
936 }
937 catch(int) {
938 } // warn
939 </pre></div></div></td>
947 at the same time the behavior of the program is undefined.
954 void test() {
955 int *data = new int;
958 }
959 </pre></div></div></td>
968 alpha.security.ArrayBoundV2</span>.
975 void test() {
977 char c = s[10]; // warn
978 }
979 </pre></div>
983 void test() {
986 }
987 </pre></div></div></td>
995 stream is undefined.
1001 int test() {
1003 return *v.end(); // warn
1004 }
1005 </pre></div></div></td>
1012 C++03: Undefined behavior: the objects in the array passed to qsort are of
1013 non-POD type.<br>
1014 C++11: Undefined behavior: the objects in the array passed to qsort are of
1015 non-trivial type.
1019 // C++03
1023 struct non_POD {
1024 non_POD();
1025 };
1027 non_POD values[] = { non_POD(), non_POD() };
1029 int compare(const void *a, const void *b);
1031 void test() {
1032 qsort(values, 2, sizeof(non_POD), compare); // warn
1033 }
1034 </pre></div>
1036 // C++11
1039 struct S {};
1041 struct trivial_non_POD : public S {
1042 int i;
1043 };
1045 struct non_trivial {
1046 int i;
1047 non_trivial();
1048 };
1050 trivial_non_POD tnp[2];
1051 non_trivial nt[2];
1053 int compare1(const void *a, const void *b);
1055 int compare2(const void *a, const void *b);
1057 void test() {
1058 qsort(tnp, 2, sizeof(trivial_non_POD), compare1); // ok
1059 qsort(nt, 2, sizeof(non_trivial), compare2); // warn
1060 }
1061 </pre></div></div></td>
1068 Undefined behavior: copy constructor/assignment operator can throw an exception.
1069 The effects are undefined if an exception is thrown.</div></div></td>
1072 class C {
1073 public:
1074 int i, j;
1075 C (const C &c) {
1076 i = c.i;
1077 throw 1; // warn
1078 j = c.j;
1079 };
1080 };
1081 </pre></div>
1083 class C {
1084 public:
1085 int i, j;
1087 i = c.i;
1088 throw 1; // warn
1089 j = c.j;
1090 };
1091 };
1092 </pre></div></div></td>
1101 pointed to by the first argument (source).
1107 struct S {
1108 int i;
1109 S(int ii) : i(ii) {};
1110 };
1112 void test(void) {
1115 }
1116 </pre></div></div></td>
1129 // C++03
1132 void test(void) {
1134 a = b; // warn
1135 b.resize(1);
1136 a = b; // ok
1137 }
1138 </pre></div>
1143 void test(void) {
1145 a *= b; // warn
1146 }
1147 </pre></div>
1152 void test(void) {
1154 a = a + b; // warn
1155 }
1156 </pre></div>
1161 void test(void) {
1164 c = a == b; // warn
1165 }
1166 </pre></div></div></td>
1175 undefined.
1177 p7.</p></div></div></td>
1182 void test(void) {
1184 v.sum(); // warn
1185 }
1186 </pre></div></div></td>
1193 Undefined behavior: element is specified more than once in an indirection.
1200 void test() {
1201 // '1' is specified more then once
1205 a[indirect] = b; //warn
1206 }
1207 </pre></div>
1211 void test() {
1212 // '1' is specified more then once
1216 a[indirect] *= b; //warn
1217 }
1218 </pre></div></div></td>
1234 using namespace std;
1237 };
1241 class my_streambuf
1243 };
1244 public:
1245 my_stream2() {
1246 this->init(new my_streambuf);
1247 }
1248 };
1250 void test() {
1253 delete p1; // warn
1254 delete p2; // ok
1255 }
1256 </pre></div></div></td>
1271 using namespace std;
1274 };
1278 class my_streambuf
1280 };
1281 public:
1282 my_stream2() {
1283 this->init(new my_streambuf);
1284 }
1285 };
1287 void test() {
1290 p1->narrow('a', 'b'); // warn
1291 p2->narrow('a', 'b'); // ok
1292 }
1293 </pre></div></div></td>
1308 class my_streambuf : public std::streambuf {
1309 void f() {
1310 seekpos(-1); // warn
1311 }
1312 };
1313 </pre></div>
1317 void test() {
1318 std::filebuf fb;
1319 std::istream in(&fb);
1320 std::filebuf::off_type pos(-1);
1321 in.seekg(pos); // warn
1322 }
1323 </pre></div></div></td>
1326 </table>
1328 <!-- ============================ different ================================ -->
1333 </thead>
1338 Successive assign to a variable.</div></div></td>
1341 int test() {
1342 int i;
1343 i=1;
1344 i=2; // warn
1345 return i;
1346 }
1347 </pre></div></div></td>
1354 Dereferencing of the null pointer might take place. Checking the pointer for
1355 null should be performed first.
1360 struct S {
1361 int x;
1362 };
1364 struct S* f();
1366 void test() {
1367 struct S *p1 = f();
1368 int x1 = p1->x; // warn
1369 if (p1) {};
1371 struct S *p2 = f();
1372 int x2 = p2->x; // ok
1373 }
1374 </pre></div></div></td>
1381 Dereferencing of the null pointer might take place. Checking the pointer for
1382 null should be performed first.
1387 struct S {int i;};
1389 struct S* f();
1391 void test() {
1392 struct S *p = f();
1393 if (p->i && p) {}; // warn
1394 }
1395 </pre></div></div></td>
1402 Identical accessor bodies. Possibly a misprint.</div></div></td>
1405 class A {
1406 int i;
1407 int j;
1408 public:
1409 int getI() { return i; }
1410 int getJ() { return i; } // warn
1411 };
1412 </pre></div>
1414 class A {
1415 int i;
1416 int j;
1417 public:
1418 void setI(int& ii) { i = ii; }
1419 void setJ(int& jj) { i = jj; } // warn
1420 };
1421 </pre></div></div></td>
1428 Accessors exist for a public class field. Should this field really be
1429 public?</div></div></td>
1432 class A {
1433 public:
1434 int i; // warn
1435 int getI() { return i; }
1436 void setI(int& ii) { i = ii; }
1437 };
1438 </pre></div></div></td>
1445 Calling a function ignoring its return value is of no use (create the list of
1446 known system/library/API functions falling into this category).</div></div></td>
1451 void test() {
1453 v.empty(); // warn
1454 }
1455 </pre></div></div></td>
1462 Wrong variable is possibly used in the loop/cond-expression of
1464 'proper_variable_name'?</div></div></td>
1467 void test() {
1468 int i = 0;
1469 int j = 0;
1471 }
1472 </pre></div>
1474 void test() {
1475 int i = 0;
1476 int j = 0;
1478 }
1479 </pre></div></div></td>
1486 Comparing floating point numbers may be not precise.</div></div></td>
1491 double test() {
1492 double b = sin(M_PI / 6.0);
1493 if (b == 0.5) // warn
1494 b = 0;
1495 return b;
1496 }
1497 </pre></div></div></td>
1509 int f();
1511 void test() {
1512 bool b = true;
1513 if (b & f()) {} // warn
1514 }
1515 </pre></div></div></td>
1523 statement.</div></div></td>
1526 void test(int c) {
1527 switch(c){
1528 case 1:
1529 c += 1; break;
1530 defalt: // warn (did you mean 'default'?)
1531 c -= 1; break;
1532 }
1533 }
1534 </pre></div></div></td>
1542 identical.</div></div></td>
1545 int test(int c) {
1547 c += 1;
1549 c -= 1;
1550 return c;
1551 }
1552 </pre></div></div></td>
1560 expression result.</div></div></td>
1563 void test(unsigned a) {
1565 }
1566 </pre></div></div></td>
1573 An expression is always evaluated to true/false.</div></div></td>
1576 void test() {
1577 int i = 0;
1578 if (i != 0) {}; // warn
1579 }
1580 </pre></div>
1582 void test(int i) {
1584 }
1585 </pre></div>
1587 void test(int i) {
1589 }
1590 </pre></div></div></td>
1597 Comparison operation has higher precedence then assignment. Boolean value is
1598 assigned to a variable of other type. Parenthesis may bee required around an
1599 assignment.</div></div></td>
1602 int f();
1604 void test(int x, int y) {
1605 bool b;
1606 if((b = x != y)) {} // ok
1607 if((x = f() != y)) {} // warn
1608 }
1609 </pre></div></div></td>
1623 void test(int a) {
1625 }
1626 </pre></div>
1628 void test(int a) {
1630 }
1631 </pre></div></div></td>
1638 The object was created but is not being used.</div></div></td>
1641 struct S {
1642 int x, y;
1643 S(int xx, int yy) : x(xx), y(yy) {}
1644 S(int xx) {
1645 S(xx, 0); // warn
1646 }
1647 };
1648 </pre></div>
1652 void test() {
1653 std::exception();
1654 // warn (did you mean 'throw std::exception()'?)
1655 }
1656 </pre></div></div></td>
1663 Pointer to static array is being compared to NULL. May the subscripting is
1664 missing.</div></div></td>
1667 void test() {
1670 }
1671 </pre></div></div></td>
1678 Odd implicit conversion to boolean.
1683 bool test() {
1684 return 1.; // warn
1685 }
1686 </pre></div>
1688 bool test() {
1689 return ""; // warn
1690 }
1691 </pre></div></div></td>
1698 Out-of-bound dynamic array access.
1703 void test() {
1704 int *p = new int[1];
1705 int i = 1;
1706 if(p[i]) {}; // warn
1707 delete[] p;
1708 }
1709 </pre></div></div></td>
1716 Buffer copy without checking the size of input.
1721 void test(char* string) {
1722 char buf[24];
1723 strcpy(buf, string); // warn
1724 }
1725 </pre></div></div></td>
1732 Integer overflow.
1733 <br>Note: partially handled by Clang core
1734 (search for 'overflow in expression' warning in Clang tests).
1741 int f(int x);
1743 void test() {
1744 f(INT_MAX + 1); // warn
1745 }
1746 </pre></div>
1750 int test() {
1752 return x * 2; // warn
1753 }
1754 </pre></div></div></td>
1761 Unexpected sign extension might take place.
1766 unsigned long long test(long long sll) {
1767 unsigned long long ull = sll; // warn
1768 return ull;
1769 }
1770 </pre></div>
1772 void f(unsigned int i);
1774 void test(int si) {
1775 f(si); // warn
1776 }
1777 </pre></div>
1779 unsigned int test(int i) {
1780 return i;
1781 }
1782 </pre></div></div></td>
1789 Numeric truncation might take place.
1794 unsigned long test(unsigned long long ull) {
1795 unsigned long ul = ull; // warn
1796 return ul;
1797 }
1798 </pre></div>
1800 void f(int i);
1802 void test(long long sll) {
1803 f(sll); // warn
1804 }
1805 </pre></div>
1807 int f();
1809 short test(long long sll) {
1810 short ss = f();
1811 return ss;
1812 }
1813 </pre></div></div></td>
1820 A class has dynamically allocated data members but do not define a copy
1821 constructor/assignment operator.
1823 leaving destructors.</p></div></div></td>
1826 class C {
1827 int *p; // warn
1828 public:
1829 C() { p = new int; }
1830 ~C() { delete p; }
1831 };
1832 </pre></div></div></td>
1835 </table>
1837 <!-- ============================ WinAPI =================================== -->
1847 lpApplicationName</i></code> is NULL then the executable name must be in the
1849 If the executable or path name has a space in it, there is a risk that a
1850 different executable could be run because of the way the function parses
1851 spaces.
1852 <p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#security-remarks">
1858 void test() {
1859 STARTUPINFO si;
1860 PROCESS_INFORMATION pi;
1861 CreateProcess(NULL, TEXT("C:\\Program Files\\App -L -S"),
1862 NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
1863 // warn
1864 }
1865 </pre></div></div></td>
1874 <p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya#security-remarks">
1880 HINSTANCE test() {
1881 char filePath[100];
1883 return LoadLibrary(filePath); // warn
1884 }
1885 </pre></div></div></td>
1893 the input buffer equals the number of characters in the Unicode string, while
1894 the size of the output buffer equals the number of bytes.
1895 <p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte">
1901 void test() {
1902 wchar_t ws[] = L"abc";
1903 char s[3];
1905 3, NULL, NULL); // warn
1906 }
1907 </pre></div></div></td>
1911 </table>
1913 <!-- =========================== optimization ============================== -->
1922 Optimization: It is more effective to pass constant parameter by reference to
1923 avoid unnecessary object copying.</div></div></td>
1926 struct A {};
1928 void f(const struct A a); // warn
1929 </pre></div></div></td>
1936 Optimization: It is more effective to use prefix increment operator with
1937 iterator.
1939 Distinguish between prefix and postfix forms of increment and decrement
1940 operators.</p></div></div></td>
1945 void test() {
1948 for(it = v.begin();
1949 it != v.end(); it++) {}; // warn
1950 }
1951 </pre></div></div></td>
1959 expression. It is more effective to hold a value returned
1965 void test(const char* s) {
1968 }
1969 </pre></div></div></td>
1983 void test() {
1984 std::string s;
1985 if (strlen(s.c_str()) != 0) {}; // warn
1986 }
1987 </pre></div></div></td>
1995 method to identify an empty container.</div></div></td>
2000 void test() {
2002 if (l.size() != 0) {}; // warn
2003 }
2004 </pre></div></div></td>
2008 </table>
2010 <br>
2013 </body>
2014 </html>