1 /* 2 * Cppcheck - A tool for static C/C++ code analysis 3 * Copyright (C) 2007-2021 Cppcheck team. 4 * 5 * This program is free software: you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation, either version 3 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program. If not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 20 #include "checkclass.h" 21 #include "settings.h" 22 #include "testsuite.h" 23 #include "tokenize.h" 24 25 26 class TestConstructors : public TestFixture { 27 public: TestConstructors()28 TestConstructors() : TestFixture("TestConstructors") {} 29 30 private: 31 Settings settings; 32 check(const char code[],bool inconclusive=false)33 void check(const char code[], bool inconclusive = false) { 34 // Clear the error buffer.. 35 errout.str(""); 36 37 settings.certainty.setEnabled(Certainty::inconclusive, inconclusive); 38 39 // Tokenize.. 40 Tokenizer tokenizer(&settings, this); 41 std::istringstream istr(code); 42 tokenizer.tokenize(istr, "test.cpp"); 43 44 // Check class constructors.. 45 CheckClass checkClass(&tokenizer, &settings, this); 46 checkClass.constructors(); 47 } 48 check(const char code[],const Settings & s)49 void check(const char code[], const Settings &s) { 50 // Clear the error buffer.. 51 errout.str(""); 52 53 // Tokenize.. 54 Tokenizer tokenizer(&s, this); 55 std::istringstream istr(code); 56 tokenizer.tokenize(istr, "test.cpp"); 57 58 // Check class constructors.. 59 CheckClass checkClass(&tokenizer, &s, this); 60 checkClass.constructors(); 61 } 62 run()63 void run() OVERRIDE { 64 settings.severity.enable(Severity::style); 65 settings.severity.enable(Severity::warning); 66 67 TEST_CASE(simple1); 68 TEST_CASE(simple2); 69 TEST_CASE(simple3); 70 TEST_CASE(simple4); 71 TEST_CASE(simple5); // ticket #2560 72 TEST_CASE(simple6); // ticket #4085 - uninstantiated template class 73 TEST_CASE(simple7); // ticket #4531 74 TEST_CASE(simple8); 75 TEST_CASE(simple9); // ticket #4574 76 TEST_CASE(simple10); // ticket #4388 77 TEST_CASE(simple11); // ticket #4536, #6214 78 TEST_CASE(simple12); // ticket #4620 79 TEST_CASE(simple13); // #5498 - no constructor, c++11 assignments 80 TEST_CASE(simple14); // #6253 template base 81 TEST_CASE(simple15); // #8942 multiple arguments, decltype 82 83 TEST_CASE(noConstructor1); 84 TEST_CASE(noConstructor2); 85 TEST_CASE(noConstructor3); 86 TEST_CASE(noConstructor4); 87 TEST_CASE(noConstructor5); 88 TEST_CASE(noConstructor6); // ticket #4386 89 TEST_CASE(noConstructor7); // ticket #4391 90 TEST_CASE(noConstructor8); // ticket #4404 91 TEST_CASE(noConstructor9); // ticket #4419 92 TEST_CASE(noConstructor10); // ticket #6614 93 TEST_CASE(noConstructor11); // ticket #3552 94 TEST_CASE(noConstructor12); // #8951 - member initialization 95 96 TEST_CASE(forwardDeclaration); // ticket #4290/#3190 97 98 TEST_CASE(initvar_with_this); // BUG 2190300 99 TEST_CASE(initvar_if); // BUG 2190290 100 TEST_CASE(initvar_operator_eq1); // BUG 2190376 101 TEST_CASE(initvar_operator_eq2); // BUG 2190376 102 TEST_CASE(initvar_operator_eq3); 103 TEST_CASE(initvar_operator_eq4); // ticket #2204 104 TEST_CASE(initvar_operator_eq5); // ticket #4119 105 TEST_CASE(initvar_operator_eq6); 106 TEST_CASE(initvar_same_classname); // BUG 2208157 107 TEST_CASE(initvar_chained_assign); // BUG 2270433 108 TEST_CASE(initvar_2constructors); // BUG 2270353 109 TEST_CASE(initvar_constvar); 110 TEST_CASE(initvar_staticvar); 111 TEST_CASE(initvar_brace_init); 112 TEST_CASE(initvar_union); 113 TEST_CASE(initvar_delegate); // ticket #4302 114 TEST_CASE(initvar_delegate2); 115 TEST_CASE(initvar_derived_class); // ticket #10161 116 117 TEST_CASE(initvar_private_constructor); // BUG 2354171 - private constructor 118 TEST_CASE(initvar_copy_constructor); // ticket #1611 119 TEST_CASE(initvar_nested_constructor); // ticket #1375 120 TEST_CASE(initvar_nocopy1); // ticket #2474 121 TEST_CASE(initvar_nocopy2); // ticket #2484 122 TEST_CASE(initvar_nocopy3); // ticket #3611 123 TEST_CASE(initvar_with_member_function_this); // ticket #4824 124 125 TEST_CASE(initvar_destructor); // No variables need to be initialized in a destructor 126 TEST_CASE(initvar_func_ret_func_ptr); // ticket #4449 127 128 TEST_CASE(initvar_alias); // #6921 129 130 TEST_CASE(initvar_templateMember); // #7205 131 132 TEST_CASE(operatorEqSTL); 133 134 TEST_CASE(uninitVar1); 135 TEST_CASE(uninitVar2); 136 TEST_CASE(uninitVar3); 137 TEST_CASE(uninitVar4); 138 TEST_CASE(uninitVar5); 139 TEST_CASE(uninitVar6); 140 TEST_CASE(uninitVar7); 141 TEST_CASE(uninitVar8); 142 TEST_CASE(uninitVar9); // ticket #1730 143 TEST_CASE(uninitVar10); // ticket #1993 144 TEST_CASE(uninitVar11); 145 TEST_CASE(uninitVar12); // ticket #2078 146 TEST_CASE(uninitVar13); // ticket #1195 147 TEST_CASE(uninitVar14); // ticket #2149 148 TEST_CASE(uninitVar15); 149 TEST_CASE(uninitVar16); 150 TEST_CASE(uninitVar17); 151 TEST_CASE(uninitVar18); // ticket #2465 152 TEST_CASE(uninitVar19); // ticket #2792 153 TEST_CASE(uninitVar20); // ticket #2867 154 TEST_CASE(uninitVar21); // ticket #2947 155 TEST_CASE(uninitVar22); // ticket #3043 156 TEST_CASE(uninitVar23); // ticket #3702 157 TEST_CASE(uninitVar24); // ticket #3190 158 TEST_CASE(uninitVar25); // ticket #4789 159 TEST_CASE(uninitVar26); 160 TEST_CASE(uninitVar27); // ticket #5170 - rtl::math::setNan(&d) 161 TEST_CASE(uninitVar28); // ticket #6258 162 TEST_CASE(uninitVar29); 163 TEST_CASE(uninitVar30); // ticket #6417 164 TEST_CASE(uninitVar31); // ticket #8271 165 TEST_CASE(uninitVar32); // ticket #8835 166 TEST_CASE(uninitVar33); // ticket #10295 167 TEST_CASE(uninitVarEnum1); 168 TEST_CASE(uninitVarEnum2); // ticket #8146 169 TEST_CASE(uninitVarStream); 170 TEST_CASE(uninitVarTypedef); 171 TEST_CASE(uninitVarMemset); 172 TEST_CASE(uninitVarArray1); 173 TEST_CASE(uninitVarArray2); 174 TEST_CASE(uninitVarArray3); 175 TEST_CASE(uninitVarArray4); 176 TEST_CASE(uninitVarArray5); 177 TEST_CASE(uninitVarArray6); 178 TEST_CASE(uninitVarArray7); 179 TEST_CASE(uninitVarArray8); 180 TEST_CASE(uninitVarArray9); // ticket #6957, #6959 181 TEST_CASE(uninitVarArray2D); 182 TEST_CASE(uninitVarArray3D); 183 TEST_CASE(uninitVarCpp11Init1); 184 TEST_CASE(uninitVarCpp11Init2); 185 TEST_CASE(uninitVarStruct1); // ticket #2172 186 TEST_CASE(uninitVarStruct2); // ticket #838 187 TEST_CASE(uninitVarUnion1); // ticket #3196 188 TEST_CASE(uninitVarUnion2); 189 TEST_CASE(uninitMissingFuncDef); // can't expand function in constructor 190 TEST_CASE(privateCtor1); // If constructor is private.. 191 TEST_CASE(privateCtor2); // If constructor is private.. 192 TEST_CASE(function); // Function is not variable 193 TEST_CASE(uninitVarPublished); // Borland C++: Variables in the published section are auto-initialized 194 TEST_CASE(uninitVarInheritClassInit); // Borland C++: if class inherits from TObject, all variables are initialized 195 TEST_CASE(uninitOperator); // No FP about uninitialized 'operator[]' 196 TEST_CASE(uninitFunction1); // No FP when initialized in function 197 TEST_CASE(uninitFunction2); // No FP when initialized in function 198 TEST_CASE(uninitFunction3); // No FP when initialized in function 199 TEST_CASE(uninitFunction4); 200 TEST_CASE(uninitFunction5); 201 TEST_CASE(uninitSameClassName); // No FP when two classes have the same name 202 TEST_CASE(uninitFunctionOverload); // No FP when there are overloaded functions 203 TEST_CASE(uninitVarOperatorEqual); // ticket #2415 204 TEST_CASE(uninitVarPointer); // ticket #3801 205 TEST_CASE(uninitConstVar); 206 TEST_CASE(constructors_crash1); // ticket #5641 207 TEST_CASE(classWithOperatorInName);// ticket #2827 208 TEST_CASE(templateConstructor); // ticket #7942 209 TEST_CASE(typedefArray); // ticket #5766 210 211 TEST_CASE(uninitAssignmentWithOperator); // ticket #7429 212 TEST_CASE(uninitCompoundAssignment); // ticket #7429 213 TEST_CASE(uninitComparisonAssignment); // ticket #7429 214 215 TEST_CASE(uninitTemplate1); // ticket #7372 216 217 TEST_CASE(unknownTemplateType); 218 } 219 220 simple1()221 void simple1() { 222 check("class Fred\n" 223 "{\n" 224 "public:\n" 225 " int i;\n" 226 "};"); 227 ASSERT_EQUALS("", errout.str()); 228 229 check("class Fred\n" 230 "{\n" 231 "private:\n" 232 " int i;\n" 233 "};"); 234 ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor although it has private member variables.\n", errout.str()); 235 236 check("struct Fred\n" 237 "{\n" 238 "private:\n" 239 " int i;\n" 240 "};"); 241 ASSERT_EQUALS("[test.cpp:1]: (style) The struct 'Fred' does not have a constructor although it has private member variables.\n", errout.str()); 242 } 243 244 simple2()245 void simple2() { 246 check("class Fred\n" 247 "{\n" 248 "public:\n" 249 " Fred() : i(0) { }\n" 250 " Fred(Fred const & other) : i(other.i) {}\n" 251 " Fred(Fred && other) : i(other.i) {}\n" 252 " int i;\n" 253 "};"); 254 ASSERT_EQUALS("", errout.str()); 255 256 check("class Fred\n" 257 "{\n" 258 "public:\n" 259 " Fred() { i = 0; }\n" 260 " Fred(Fred const & other) {i=other.i}\n" 261 " Fred(Fred && other) {i=other.i}\n" 262 " int i;\n" 263 "};"); 264 ASSERT_EQUALS("", errout.str()); 265 266 check("class Fred\n" 267 "{\n" 268 "public:\n" 269 " Fred() { }\n" 270 " Fred(Fred const & other) {}\n" 271 " Fred(Fred && other) {}\n" 272 " int i;\n" 273 "};"); 274 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n" 275 "[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n" 276 "[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 277 278 check("struct Fred\n" 279 "{\n" 280 " Fred() { }\n" 281 " Fred(Fred const & other) {}\n" 282 " Fred(Fred && other) {}\n" 283 " int i;\n" 284 "};"); 285 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n" 286 "[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n" 287 "[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 288 } 289 290 simple3()291 void simple3() { 292 check("struct Fred\n" 293 "{\n" 294 " Fred();\n" 295 " int i;\n" 296 "};\n" 297 "Fred::Fred() :i(0)\n" 298 "{ }"); 299 ASSERT_EQUALS("", errout.str()); 300 301 check("struct Fred\n" 302 "{\n" 303 " Fred();\n" 304 " int i;\n" 305 "};\n" 306 "Fred::Fred()\n" 307 "{ i = 0; }"); 308 ASSERT_EQUALS("", errout.str()); 309 310 check("struct Fred\n" 311 "{\n" 312 " Fred();\n" 313 " int i;\n" 314 "};\n" 315 "Fred::Fred()\n" 316 "{ }"); 317 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 318 } 319 320 simple4()321 void simple4() { 322 check("struct Fred\n" 323 "{\n" 324 " Fred();\n" 325 " explicit Fred(int _i);\n" 326 " Fred(Fred const & other);\n" 327 " int i;\n" 328 "};\n" 329 "Fred::Fred()\n" 330 "{ }\n" 331 "Fred::Fred(int _i)\n" 332 "{\n" 333 " i = _i;\n" 334 "}\n", true); 335 ASSERT_EQUALS("[test.cpp:8]: (warning, inconclusive) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 336 } 337 simple5()338 void simple5() { // ticket #2560 339 check("namespace Nsp\n" 340 "{\n" 341 " class B { };\n" 342 "}\n" 343 "class Altren : public Nsp::B\n" 344 "{\n" 345 "public:\n" 346 " Altren () : Nsp::B(), mValue(0)\n" 347 " {\n" 348 " }\n" 349 "private:\n" 350 " int mValue;\n" 351 "};"); 352 ASSERT_EQUALS("", errout.str()); 353 } 354 simple6()355 void simple6() { // ticket #4085 - uninstantiated template class 356 check("template <class T> struct A {\n" 357 " A<T>() { x = 0; }\n" 358 " A<T>(const T & t) { x = t.x; }\n" 359 "private:\n" 360 " int x;\n" 361 "};"); 362 ASSERT_EQUALS("", errout.str()); 363 364 check("template <class T> struct A {\n" 365 " A<T>() : x(0) { }\n" 366 " A<T>(const T & t) : x(t.x) { }\n" 367 "private:\n" 368 " int x;\n" 369 "};"); 370 ASSERT_EQUALS("", errout.str()); 371 372 check("template <class T> struct A {\n" 373 " A<T>() : x(0) { }\n" 374 " A<T>(const T & t) : x(t.x) { }\n" 375 "private:\n" 376 " int x;\n" 377 " int y;\n" 378 "};"); 379 ASSERT_EQUALS("[test.cpp:2]: (warning) Member variable 'A::y' is not initialized in the constructor.\n" 380 "[test.cpp:3]: (warning) Member variable 'A::y' is not initialized in the constructor.\n", errout.str()); 381 } 382 simple7()383 void simple7() { // ticket #4531 384 check("class Fred;\n" 385 "struct Fred {\n" 386 " int x;\n" 387 "};"); 388 ASSERT_EQUALS("", errout.str()); 389 } 390 simple8()391 void simple8() { 392 check("struct Fred { int x; };\n" 393 "class Barney { Fred fred; };\n" 394 "class Wilma { struct Betty { int x; } betty; };"); 395 ASSERT_EQUALS("[test.cpp:2]: (style) The class 'Barney' does not have a constructor although it has private member variables.\n" 396 "[test.cpp:3]: (style) The class 'Wilma' does not have a constructor although it has private member variables.\n", errout.str()); 397 } 398 simple9()399 void simple9() { // ticket #4574 400 check("class Unknown::Fred {\n" 401 "public:\n" 402 " Fred() : x(0) { }\n" 403 "private:\n" 404 " int x;\n" 405 "};"); 406 ASSERT_EQUALS("", errout.str()); 407 } 408 simple10()409 void simple10() { // ticket #4388 410 check("class Fred {\n" 411 "public:\n" 412 " Fred() = default;\n" 413 "private:\n" 414 " int x;\n" 415 "};"); 416 ASSERT_EQUALS("", errout.str()); 417 } 418 simple11()419 void simple11() { // ticket #4536, #6214 420 check("class Fred {\n" 421 "public:\n" 422 " Fred() {}\n" 423 "private:\n" 424 " int x = 0;\n" 425 " int y = f();\n" 426 " int z{0};\n" 427 " int (*pf[2])(){nullptr, nullptr};\n" 428 " int a[2][3] = {{1,2,3},{4,5,6}};\n" 429 " int b{1}, c{2};\n" 430 " int d, e{3};\n" 431 " int f{4}, g;\n" 432 "};"); 433 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n" 434 "[test.cpp:3]: (warning) Member variable 'Fred::g' is not initialized in the constructor.\n", errout.str()); 435 } 436 simple12()437 void simple12() { // ticket #4620 438 check("class Fred {\n" 439 " int x;\n" 440 "public:\n" 441 " Fred() { Init(); }\n" 442 " void Init(int i = 0);\n" 443 "};\n" 444 "void Fred::Init(int i) { x = i; }"); 445 ASSERT_EQUALS("", errout.str()); 446 447 check("class Fred {\n" 448 " int x;\n" 449 " int y;\n" 450 "public:\n" 451 " Fred() { Init(0); }\n" 452 " void Init(int i, int j = 0);\n" 453 "};\n" 454 "void Fred::Init(int i, int j) { x = i; y = j; }"); 455 ASSERT_EQUALS("", errout.str()); 456 } 457 simple13()458 void simple13() { // #5498 459 check("class Fred {\n" 460 " int x=1;\n" 461 " int *y=0;\n" 462 "};"); 463 ASSERT_EQUALS("", errout.str()); 464 } 465 simple14()466 void simple14() { // #6253 template base 467 check("class Fred : public Base<A, B> {" 468 "public:" 469 " Fred()\n" 470 " :Base<A, B>(1),\n" 471 " x(1)\n" 472 " {}\n" 473 "private:\n" 474 " int x;\n" 475 "};"); 476 ASSERT_EQUALS("", errout.str()); 477 478 check("class Fred : public Base<A, B> {" 479 "public:" 480 " Fred()\n" 481 " :Base<A, B>{1},\n" 482 " x{1}\n" 483 " {}\n" 484 "private:\n" 485 " int x;\n" 486 "};"); 487 ASSERT_EQUALS("", errout.str()); 488 } 489 simple15()490 void simple15() { // #8942 491 check("class A\n" 492 "{\n" 493 "public:\n" 494 " int member;\n" 495 "};\n" 496 "class B\n" 497 "{\n" 498 "public:\n" 499 " B(const decltype(A::member)& x, const decltype(A::member)& y) : x(x), y(y) {}\n" 500 "private:\n" 501 " const decltype(A::member)& x;\n" 502 " const decltype(A::member)& y;\n" 503 "};\n"); 504 ASSERT_EQUALS("", errout.str()); 505 } 506 noConstructor1()507 void noConstructor1() { 508 // There are nonstatic member variables - constructor is needed 509 check("class Fred\n" 510 "{\n" 511 " int i;\n" 512 "};"); 513 ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor although it has private member variables.\n", errout.str()); 514 } 515 noConstructor2()516 void noConstructor2() { 517 check("class Fred\n" 518 "{\n" 519 "public:\n" 520 " static void foobar();\n" 521 "};\n" 522 "\n" 523 "void Fred::foobar()\n" 524 "{ }"); 525 ASSERT_EQUALS("", errout.str()); 526 } 527 noConstructor3()528 void noConstructor3() { 529 check("class Fred\n" 530 "{\n" 531 "private:\n" 532 " static int foobar;\n" 533 "};"); 534 ASSERT_EQUALS("", errout.str()); 535 } 536 noConstructor4()537 void noConstructor4() { 538 check("class Fred\n" 539 "{\n" 540 "public:\n" 541 " int foobar;\n" 542 "};"); 543 ASSERT_EQUALS("", errout.str()); 544 } 545 noConstructor5()546 void noConstructor5() { 547 check("namespace Foo\n" 548 "{\n" 549 " int i;\n" 550 "}"); 551 ASSERT_EQUALS("", errout.str()); 552 } 553 noConstructor6()554 void noConstructor6() { 555 // ticket #4386 556 check("class Ccpucycles {\n" 557 " friend class foo::bar;\n" 558 " Ccpucycles() :\n" 559 " m_v(0), m_b(true)\n" 560 " {}\n" 561 "private:\n" 562 " cpucyclesT m_v;\n" 563 " bool m_b;\n" 564 "};"); 565 ASSERT_EQUALS("", errout.str()); 566 } 567 noConstructor7()568 void noConstructor7() { 569 // ticket #4391 570 check("short bar;\n" 571 "class foo;"); 572 ASSERT_EQUALS("", errout.str()); 573 } 574 noConstructor8()575 void noConstructor8() { 576 // ticket #4404 577 check("class LineSegment;\n" 578 "class PointArray { };\n" 579 "void* tech_ = NULL;"); 580 ASSERT_EQUALS("", errout.str()); 581 } 582 noConstructor9()583 void noConstructor9() { 584 // ticket #4419 585 check("class CGreeting : public CGreetingBase<char> {\n" 586 "public:\n" 587 " CGreeting() : CGreetingBase<char>(), MessageSet(false) {}\n" 588 "private:\n" 589 " bool MessageSet;\n" 590 "};"); 591 ASSERT_EQUALS("", errout.str()); 592 } 593 noConstructor10()594 void noConstructor10() { 595 // ticket #6614 596 check("class A : public wxDialog\n" 597 "{\n" 598 "private:\n" 599 " DECLARE_EVENT_TABLE()\n" 600 "public:\n" 601 " A(wxWindow *parent,\n" 602 " wxWindowID id = 1,\n" 603 " const wxString &title = wxT(" "),\n" 604 " const wxPoint& pos = wxDefaultPosition,\n" 605 " const wxSize& size = wxDefaultSize,\n" 606 " long style = wxDIALOG_NO_PARENT | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCLOSE_BOX);\n" 607 " virtual ~A();\n" 608 "private:\n" 609 " wxTimer *WxTimer1;\n" 610 "};"); 611 ASSERT_EQUALS("", errout.str()); 612 } 613 614 noConstructor11()615 void noConstructor11() { // #3552 616 check("class Fred { int x; };\n" 617 "union U { int y; Fred fred; };"); 618 ASSERT_EQUALS("", errout.str()); 619 } 620 noConstructor12()621 void noConstructor12() { // #8951 622 check("class Fred { int x{0}; };"); 623 ASSERT_EQUALS("", errout.str()); 624 625 check("class Fred { int x=0; };"); 626 ASSERT_EQUALS("", errout.str()); 627 628 check("class Fred { int x[1]={0}; };"); // #8850 629 ASSERT_EQUALS("", errout.str()); 630 631 check("class Fred { int x[1]{0}; };"); 632 ASSERT_EQUALS("", errout.str()); 633 } 634 635 // ticket #4290 "False Positive: style (noConstructor): The class 'foo' does not have a constructor." 636 // ticket #3190 "SymbolDatabase: Parse of sub class constructor fails" forwardDeclaration()637 void forwardDeclaration() { 638 check("class foo;\n" 639 "int bar;"); 640 ASSERT_EQUALS("", errout.str()); 641 642 check("class foo;\n" 643 "class foo;"); 644 ASSERT_EQUALS("", errout.str()); 645 646 check("class foo{};\n" 647 "class foo;"); 648 ASSERT_EQUALS("", errout.str()); 649 } 650 initvar_with_this()651 void initvar_with_this() { 652 check("struct Fred\n" 653 "{\n" 654 " Fred()\n" 655 " { this->i = 0; }\n" 656 " int i;\n" 657 "};"); 658 ASSERT_EQUALS("", errout.str()); 659 } 660 initvar_if()661 void initvar_if() { 662 check("struct Fred\n" 663 "{\n" 664 " Fred()\n" 665 " {\n" 666 " if (true)\n" 667 " i = 0;\n" 668 " else\n" 669 " i = 1;\n" 670 " }\n" 671 " int i;\n" 672 "};"); 673 ASSERT_EQUALS("", errout.str()); 674 } 675 initvar_operator_eq1()676 void initvar_operator_eq1() { 677 // Bug 2190376 and #3820 - False positive, Uninitialized member variable with operator= 678 679 check("struct Fred\n" 680 "{\n" 681 " int i;\n" 682 "\n" 683 " Fred()\n" 684 " { i = 0; }\n" 685 "\n" 686 " Fred(const Fred &fred)\n" 687 " { *this = fred; }\n" 688 "\n" 689 " const Fred & operator=(const Fred &fred)\n" 690 " { i = fred.i; return *this; }\n" 691 "};"); 692 ASSERT_EQUALS("", errout.str()); 693 694 check("struct Fred {\n" 695 " int i;\n" 696 "\n" 697 " Fred(const Fred &fred)\n" 698 " { (*this) = fred; }\n" 699 "\n" 700 " const Fred & operator=(const Fred &fred)\n" 701 " { i = fred.i; return *this; }\n" 702 "};"); 703 ASSERT_EQUALS("", errout.str()); 704 705 check("struct A\n" 706 "{\n" 707 " A() : i(0), j(0) {}\n" 708 "\n" 709 " A &operator=(const int &value)\n" 710 " {\n" 711 " i = value;\n" 712 " return (*this);\n" 713 " }\n" 714 "\n" 715 " int i;\n" 716 " int j;\n" 717 "};"); 718 ASSERT_EQUALS("", errout.str()); 719 } 720 721 initvar_operator_eq2()722 void initvar_operator_eq2() { 723 check("struct Fred\n" 724 "{\n" 725 " Fred() { i = 0; }\n" 726 " void operator=(const Fred &fred) { }\n" 727 " int i;\n" 728 "};"); 729 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str()); 730 } 731 initvar_operator_eq3()732 void initvar_operator_eq3() { 733 check("struct Fred\n" 734 "{\n" 735 " Fred() { Init(); }\n" 736 " void operator=(const Fred &fred) { Init(); }\n" 737 "private:\n" 738 " void Init() { i = 0; }\n" 739 " int i;\n" 740 "};"); 741 ASSERT_EQUALS("", errout.str()); 742 } 743 initvar_operator_eq4()744 void initvar_operator_eq4() { 745 check("class Fred\n" 746 "{\n" 747 " int i;\n" 748 "public:\n" 749 " Fred() : i(5) { }\n" 750 " Fred & operator=(const Fred &fred)\n" 751 " {\n" 752 " if (&fred != this)\n" 753 " {\n" 754 " }\n" 755 " return *this\n" 756 " }\n" 757 "};"); 758 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str()); 759 760 check("class Fred\n" 761 "{\n" 762 " int * i;\n" 763 "public:\n" 764 " Fred() : i(NULL) { }\n" 765 " Fred & operator=(const Fred &fred)\n" 766 " {\n" 767 " if (&fred != this)\n" 768 " {\n" 769 " }\n" 770 " return *this\n" 771 " }\n" 772 "};"); 773 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str()); 774 775 check("class Fred\n" 776 "{\n" 777 " const int * i;\n" 778 "public:\n" 779 " Fred() : i(NULL) { }\n" 780 " Fred & operator=(const Fred &fred)\n" 781 " {\n" 782 " if (&fred != this)\n" 783 " {\n" 784 " }\n" 785 " return *this\n" 786 " }\n" 787 "};"); 788 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str()); 789 790 check("class Fred\n" 791 "{\n" 792 " const int i;\n" 793 "public:\n" 794 " Fred() : i(5) { }\n" 795 " Fred & operator=(const Fred &fred)\n" 796 " {\n" 797 " if (&fred != this)\n" 798 " {\n" 799 " }\n" 800 " return *this\n" 801 " }\n" 802 "};"); 803 ASSERT_EQUALS("", errout.str()); 804 } 805 initvar_operator_eq5()806 void initvar_operator_eq5() { // #4119 - false positive when using swap to assign variables 807 check("class Fred {\n" 808 " int i;\n" 809 "public:\n" 810 " Fred() : i(5) { }\n" 811 " ~Fred() { }\n" 812 " Fred(const Fred &fred) : i(fred.i) { }\n" 813 " Fred & operator=(const Fred &rhs) {\n" 814 " Fred(rhs).swap(*this);\n" 815 " return *this;\n" 816 " }\n" 817 "};"); 818 ASSERT_EQUALS("", errout.str()); 819 } 820 initvar_operator_eq6()821 void initvar_operator_eq6() { // std::vector 822 check("struct Fred {\n" 823 " uint8_t data;\n" 824 " Fred & operator=(const Fred &rhs) {\n" 825 " return *this;\n" 826 " }\n" 827 "};",true); 828 ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='.\n", errout.str()); 829 830 check("struct Fred {\n" 831 " std::vector<int> ints;\n" 832 " Fred & operator=(const Fred &rhs) {\n" 833 " return *this;\n" 834 " }\n" 835 "};",true); 836 ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='.\n", errout.str()); 837 838 check("struct Fred {\n" 839 " Data data;\n" 840 " Fred & operator=(const Fred &rhs) {\n" 841 " return *this;\n" 842 " }\n" 843 "};",true); 844 ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='.\n", errout.str()); 845 } 846 initvar_same_classname()847 void initvar_same_classname() { 848 // Bug 2208157 - False positive: Uninitialized variable, same class name 849 850 check("void func1()\n" 851 "{\n" 852 " class Fred\n" 853 " {\n" 854 " int a;\n" 855 " Fred() { a = 0; }\n" 856 " };\n" 857 "}\n" 858 "\n" 859 "void func2()\n" 860 "{\n" 861 " class Fred\n" 862 " {\n" 863 " int b;\n" 864 " Fred() { b = 0; }\n" 865 " };\n" 866 "}"); 867 868 ASSERT_EQUALS("", errout.str()); 869 870 check("void func1()\n" 871 "{\n" 872 " struct Fred\n" 873 " {\n" 874 " int a;\n" 875 " Fred() { a = 0; }\n" 876 " };\n" 877 "}\n" 878 "\n" 879 "void func2()\n" 880 "{\n" 881 " class Fred\n" 882 " {\n" 883 " int b;\n" 884 " Fred() { b = 0; }\n" 885 " };\n" 886 "}"); 887 888 ASSERT_EQUALS("", errout.str()); 889 890 check("void func1()\n" 891 "{\n" 892 " struct Fred\n" 893 " {\n" 894 " int a;\n" 895 " Fred() { a = 0; }\n" 896 " };\n" 897 "}\n" 898 "\n" 899 "void func2()\n" 900 "{\n" 901 " struct Fred\n" 902 " {\n" 903 " int b;\n" 904 " Fred() { b = 0; }\n" 905 " };\n" 906 "}"); 907 908 ASSERT_EQUALS("", errout.str()); 909 910 check("class Foo {\n" 911 " void func1()\n" 912 " {\n" 913 " struct Fred\n" 914 " {\n" 915 " int a;\n" 916 " Fred() { a = 0; }\n" 917 " };\n" 918 " }\n" 919 "\n" 920 " void func2()\n" 921 " {\n" 922 " struct Fred\n" 923 " {\n" 924 " int b;\n" 925 " Fred() { b = 0; }\n" 926 " };\n" 927 " }\n" 928 "};"); 929 930 ASSERT_EQUALS("", errout.str()); 931 932 check("class Foo {\n" 933 " void func1()\n" 934 " {\n" 935 " struct Fred\n" 936 " {\n" 937 " int a;\n" 938 " Fred() { }\n" 939 " };\n" 940 " }\n" 941 "\n" 942 " void func2()\n" 943 " {\n" 944 " struct Fred\n" 945 " {\n" 946 " int b;\n" 947 " Fred() { }\n" 948 " };\n" 949 " }\n" 950 "};"); 951 952 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::a' is not initialized in the constructor.\n" 953 "[test.cpp:16]: (warning) Member variable 'Fred::b' is not initialized in the constructor.\n", errout.str()); 954 } 955 initvar_chained_assign()956 void initvar_chained_assign() { 957 // Bug 2270433 - Uninitialized variable false positive on chained assigns 958 959 check("struct c\n" 960 "{\n" 961 " c();\n" 962 "\n" 963 " int m_iMyInt1;\n" 964 " int m_iMyInt2;\n" 965 "}\n" 966 "\n" 967 "c::c()\n" 968 "{\n" 969 " m_iMyInt1 = m_iMyInt2 = 0;\n" 970 "}"); 971 972 ASSERT_EQUALS("", errout.str()); 973 } 974 975 initvar_2constructors()976 void initvar_2constructors() { 977 check("struct c\n" 978 "{\n" 979 " c();\n" 980 " explicit c(bool b);" 981 "\n" 982 " void InitInt();\n" 983 "\n" 984 " int m_iMyInt;\n" 985 " int m_bMyBool;\n" 986 "}\n" 987 "\n" 988 "c::c()\n" 989 "{\n" 990 " m_bMyBool = false;\n" 991 " InitInt();" 992 "}\n" 993 "\n" 994 "c::c(bool b)\n" 995 "{\n" 996 " m_bMyBool = b;\n" 997 " InitInt();\n" 998 "}\n" 999 "\n" 1000 "void c::InitInt()\n" 1001 "{\n" 1002 " m_iMyInt = 0;\n" 1003 "}"); 1004 1005 ASSERT_EQUALS("", errout.str()); 1006 } 1007 1008 initvar_constvar()1009 void initvar_constvar() { 1010 check("struct Fred\n" 1011 "{\n" 1012 " const char *s;\n" 1013 " Fred();\n" 1014 "};\n" 1015 "Fred::Fred() : s(NULL)\n" 1016 "{ }"); 1017 ASSERT_EQUALS("", errout.str()); 1018 1019 check("struct Fred\n" 1020 "{\n" 1021 " const char *s;\n" 1022 " Fred();\n" 1023 "};\n" 1024 "Fred::Fred()\n" 1025 "{ s = NULL; }"); 1026 ASSERT_EQUALS("", errout.str()); 1027 1028 check("struct Fred\n" 1029 "{\n" 1030 " const char *s;\n" 1031 " Fred();\n" 1032 "};\n" 1033 "Fred::Fred()\n" 1034 "{ }"); 1035 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::s' is not initialized in the constructor.\n", errout.str()); 1036 } 1037 1038 initvar_staticvar()1039 void initvar_staticvar() { 1040 check("class Fred\n" 1041 "{\n" 1042 "public:\n" 1043 " Fred() { }\n" 1044 " static void *p;\n" 1045 "};"); 1046 ASSERT_EQUALS("", errout.str()); 1047 } 1048 1049 initvar_brace_init()1050 void initvar_brace_init() { // #10142 1051 check("class C\n" 1052 "{\n" 1053 "public:\n" 1054 " C() {}\n" 1055 "\n" 1056 "private:\n" 1057 " std::map<int, double> * values_{};\n" 1058 "};"); 1059 ASSERT_EQUALS("", errout.str()); 1060 } 1061 1062 initvar_union()1063 void initvar_union() { 1064 check("class Fred\n" 1065 "{\n" 1066 " union\n" 1067 " {\n" 1068 " int a;\n" 1069 " char b[4];\n" 1070 " } U;\n" 1071 "public:\n" 1072 " Fred()\n" 1073 " {\n" 1074 " U.a = 0;\n" 1075 " }\n" 1076 "};"); 1077 ASSERT_EQUALS("", errout.str()); 1078 1079 check("class Fred\n" 1080 "{\n" 1081 " union\n" 1082 " {\n" 1083 " int a;\n" 1084 " char b[4];\n" 1085 " } U;\n" 1086 "public:\n" 1087 " Fred()\n" 1088 " {\n" 1089 " }\n" 1090 "};"); 1091 TODO_ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Fred::U' is not initialized in the constructor.\n", "", errout.str()); 1092 } 1093 1094 initvar_delegate()1095 void initvar_delegate() { 1096 check("class A {\n" 1097 " int number;\n" 1098 "public:\n" 1099 " A(int n) { }\n" 1100 " A() : A(42) {}\n" 1101 "};"); 1102 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n" 1103 "[test.cpp:5]: (warning) Member variable 'A::number' is not initialized in the constructor.\n", errout.str()); 1104 1105 check("class A {\n" 1106 " int number;\n" 1107 "public:\n" 1108 " A(int n) { number = n; }\n" 1109 " A() : A(42) {}\n" 1110 "};"); 1111 ASSERT_EQUALS("", errout.str()); 1112 1113 check("class A {\n" 1114 " int number;\n" 1115 "public:\n" 1116 " A(int n) : A() { }\n" 1117 " A() {}\n" 1118 "};", true); 1119 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n" 1120 "[test.cpp:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor.\n", errout.str()); 1121 1122 check("class A {\n" 1123 " int number;\n" 1124 "public:\n" 1125 " A(int n) : A() { }\n" 1126 " A() { number = 42; }\n" 1127 "};"); 1128 ASSERT_EQUALS("", errout.str()); 1129 1130 check("class A {\n" 1131 " int number;\n" 1132 "public:\n" 1133 " A(int n) { }\n" 1134 " A() : A{42} {}\n" 1135 "};"); 1136 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n" 1137 "[test.cpp:5]: (warning) Member variable 'A::number' is not initialized in the constructor.\n", errout.str()); 1138 1139 check("class A {\n" 1140 " int number;\n" 1141 "public:\n" 1142 " A(int n) { number = n; }\n" 1143 " A() : A{42} {}\n" 1144 "};"); 1145 ASSERT_EQUALS("", errout.str()); 1146 1147 check("class A {\n" 1148 " int number;\n" 1149 "public:\n" 1150 " A(int n) : A{} { }\n" 1151 " A() {}\n" 1152 "};", true); 1153 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n" 1154 "[test.cpp:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor.\n", errout.str()); 1155 1156 check("class A {\n" 1157 " int number;\n" 1158 "public:\n" 1159 " A(int n) : A{} { }\n" 1160 " A() { number = 42; }\n" 1161 "};"); 1162 ASSERT_EQUALS("", errout.str()); 1163 1164 // Ticket #6675 1165 check("struct Foo {\n" 1166 " Foo();\n" 1167 " Foo(int foo);\n" 1168 " int foo_;\n" 1169 "};\n" 1170 "Foo::Foo() : Foo(0) {}\n" 1171 "Foo::Foo(int foo) : foo_(foo) {}"); 1172 ASSERT_EQUALS("", errout.str()); 1173 1174 // Noexcept ctors 1175 check("class A {\n" 1176 "private:\n" 1177 " int _a;\n" 1178 "public:\n" 1179 " A(const int a) noexcept : _a{a} {}\n" 1180 " A() noexcept;\n" 1181 "};\n" 1182 "\n" 1183 "A::A() noexcept: A(0) {}"); 1184 ASSERT_EQUALS("", errout.str()); 1185 1186 // Ticket #8581 1187 check("class A {\n" 1188 "private:\n" 1189 " int _a;\n" 1190 "public:\n" 1191 " A(int a) : _a(a) {}\n" 1192 " A(float a) : A(int(a)) {}\n" 1193 "};"); 1194 ASSERT_EQUALS("", errout.str()); 1195 1196 // Ticket #8258 1197 check("struct F{};\n" 1198 "struct Foo {\n" 1199 " Foo(int a, F&& f, int b = 21) : _a(a), _b(b), _f(f) {}\n" 1200 " Foo(int x, const char* value) : Foo(x, F(), 42) {}\n" 1201 " Foo(int x, int* value) : Foo(x, F()) {}\n" 1202 " int _a;\n" 1203 " int _b;\n" 1204 " F _f;\n" 1205 "};"); 1206 ASSERT_EQUALS("", errout.str()); 1207 } 1208 initvar_delegate2()1209 void initvar_delegate2() { 1210 check("class Foo {\n" 1211 "public:\n" 1212 " explicit Foo(const Bar bar);\n" 1213 " Foo(const std::string& id);\n" 1214 " virtual ~RtpSession() { }\n" 1215 "protected:\n" 1216 " bool a;\n" 1217 " uint16_t b;\n" 1218 "};\n" 1219 "\n" 1220 "Foo::Foo(const Bar var)\n" 1221 " : Foo(bar->getId())\n" 1222 "{\n" 1223 "}\n" 1224 "\n" 1225 "Foo::Foo(const std::string& id)\n" 1226 " : a(true)\n" 1227 " , b(0)\n" 1228 "{\n" 1229 "}"); 1230 ASSERT_EQUALS("", errout.str()); 1231 } 1232 initvar_derived_class()1233 void initvar_derived_class() { 1234 check("class Base {\n" 1235 "public:\n" 1236 " virtual void foo() = 0;\n" 1237 " int x;\n" // <- uninitialized 1238 "};\n" 1239 "\n" 1240 "class Derived: public Base {\n" 1241 "public:\n" 1242 " Derived() {}\n" 1243 " void foo() override;\n" 1244 "};"); 1245 ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Base::x' is not initialized in the constructor. Maybe it should be initialized directly in the class Base?\n", errout.str()); 1246 } 1247 initvar_private_constructor()1248 void initvar_private_constructor() { 1249 settings.standards.cpp = Standards::CPP11; 1250 check("class Fred\n" 1251 "{\n" 1252 "private:\n" 1253 " int var;\n" 1254 " Fred();\n" 1255 "};\n" 1256 "Fred::Fred()\n" 1257 "{ }"); 1258 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::var' is not initialized in the constructor.\n", errout.str()); 1259 1260 settings.standards.cpp = Standards::CPP03; 1261 check("class Fred\n" 1262 "{\n" 1263 "private:\n" 1264 " int var;\n" 1265 " Fred();\n" 1266 "};\n" 1267 "Fred::Fred()\n" 1268 "{ }"); 1269 ASSERT_EQUALS("", errout.str()); 1270 } 1271 initvar_copy_constructor()1272 void initvar_copy_constructor() { // ticket #1611 1273 check("class Fred\n" 1274 "{\n" 1275 "private:\n" 1276 " std::string var;\n" 1277 "public:\n" 1278 " Fred() { };\n" 1279 " Fred(const Fred &) { };\n" 1280 "};"); 1281 ASSERT_EQUALS("", errout.str()); 1282 1283 check("class Fred\n" 1284 "{\n" 1285 "private:\n" 1286 " std::string var;\n" 1287 "public:\n" 1288 " Fred() { };\n" 1289 " Fred(const Fred &) { };\n" 1290 "};", true); 1291 ASSERT_EQUALS("[test.cpp:7]: (warning, inconclusive) Member variable 'Fred::var' is not assigned in the copy constructor. Should it be copied?\n", errout.str()); 1292 1293 check("class Fred\n" 1294 "{\n" 1295 "private:\n" 1296 " std::string var;\n" 1297 "public:\n" 1298 " Fred();\n" 1299 " Fred(const Fred &);\n" 1300 "};\n" 1301 "Fred::Fred() { };\n" 1302 "Fred::Fred(const Fred &) { };\n", true); 1303 ASSERT_EQUALS("[test.cpp:10]: (warning, inconclusive) Member variable 'Fred::var' is not assigned in the copy constructor. Should it be copied?\n", errout.str()); 1304 } 1305 initvar_nested_constructor()1306 void initvar_nested_constructor() { // ticket #1375 1307 check("class A {\n" 1308 "public:\n" 1309 " A();\n" 1310 " struct B {\n" 1311 " explicit B(int x);\n" 1312 " struct C {\n" 1313 " explicit C(int y);\n" 1314 " struct D {\n" 1315 " int d;\n" 1316 " explicit D(int z);\n" 1317 " };\n" 1318 " int c;\n" 1319 " };\n" 1320 " int b;\n" 1321 " };\n" 1322 "private:\n" 1323 " int a;\n" 1324 " B b;\n" 1325 "};\n" 1326 "A::A(){}\n" 1327 "A::B::B(int x){}\n" 1328 "A::B::C::C(int y){}\n" 1329 "A::B::C::D::D(int z){}"); 1330 // Note that the example code is not compilable. The A constructor must 1331 // explicitly initialize A::b. A warning for A::b is not necessary. 1332 ASSERT_EQUALS("[test.cpp:20]: (warning) Member variable 'A::a' is not initialized in the constructor.\n" 1333 "[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n" 1334 "[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n" 1335 "[test.cpp:23]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str()); 1336 1337 check("class A {\n" 1338 "public:\n" 1339 " A();\n" 1340 " struct B {\n" 1341 " explicit B(int x);\n" 1342 " struct C {\n" 1343 " explicit C(int y);\n" 1344 " struct D {\n" 1345 " D(const D &);\n" 1346 " int d;\n" 1347 " };\n" 1348 " int c;\n" 1349 " };\n" 1350 " int b;\n" 1351 " };\n" 1352 "private:\n" 1353 " int a;\n" 1354 " B b;\n" 1355 "};\n" 1356 "A::A(){}\n" 1357 "A::B::B(int x){}\n" 1358 "A::B::C::C(int y){}\n" 1359 "A::B::C::D::D(const A::B::C::D & d){}"); 1360 // Note that the example code is not compilable. The A constructor must 1361 // explicitly initialize A::b. A warning for A::b is not necessary. 1362 ASSERT_EQUALS("[test.cpp:20]: (warning) Member variable 'A::a' is not initialized in the constructor.\n" 1363 "[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n" 1364 "[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n" 1365 "[test.cpp:23]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str()); 1366 1367 check("class A {\n" 1368 "public:\n" 1369 " A();\n" 1370 " struct B {\n" 1371 " explicit B(int x);\n" 1372 " struct C {\n" 1373 " explicit C(int y);\n" 1374 " struct D {\n" 1375 " struct E { int e; };\n" 1376 " struct E d;\n" 1377 " explicit D(const E &);\n" 1378 " };\n" 1379 " int c;\n" 1380 " };\n" 1381 " int b;\n" 1382 " };\n" 1383 "private:\n" 1384 " int a;\n" 1385 " B b;\n" 1386 "};\n" 1387 "A::A(){}\n" 1388 "A::B::B(int x){}\n" 1389 "A::B::C::C(int y){}\n" 1390 "A::B::C::D::D(const A::B::C::D::E & e){}"); 1391 // Note that the example code is not compilable. The A constructor must 1392 // explicitly initialize A::b. A warning for A::b is not necessary. 1393 ASSERT_EQUALS("[test.cpp:21]: (warning) Member variable 'A::a' is not initialized in the constructor.\n" 1394 "[test.cpp:22]: (warning) Member variable 'B::b' is not initialized in the constructor.\n" 1395 "[test.cpp:23]: (warning) Member variable 'C::c' is not initialized in the constructor.\n" 1396 "[test.cpp:24]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str()); 1397 } 1398 initvar_nocopy1()1399 void initvar_nocopy1() { // ticket #2474 1400 check("class B\n" 1401 "{\n" 1402 " B (const B & Var);\n" 1403 "};\n" 1404 "class A\n" 1405 "{\n" 1406 " B m_SemVar;\n" 1407 "public:\n" 1408 " A(){}\n" 1409 " A(const A&){}\n" 1410 " A(A &&){}\n" 1411 " const A& operator=(const A&){return *this;}\n" 1412 "};"); 1413 ASSERT_EQUALS("", errout.str()); 1414 1415 check("class B\n" 1416 "{\n" 1417 " B (B && Var);\n" 1418 "};\n" 1419 "class A\n" 1420 "{\n" 1421 " B m_SemVar;\n" 1422 "public:\n" 1423 " A(){}\n" 1424 " A(const A&){}\n" 1425 " A(A &&){}\n" 1426 " const A& operator=(const A&){return *this;}\n" 1427 "};"); 1428 ASSERT_EQUALS("", errout.str()); 1429 1430 check("class B\n" 1431 "{\n" 1432 " B & operator= (const B & Var);\n" 1433 "public:\n" 1434 " B ();\n" 1435 "};\n" 1436 "class A\n" 1437 "{\n" 1438 " B m_SemVar;\n" 1439 "public:\n" 1440 " A(){}\n" 1441 " A(const A&){}\n" 1442 " A(A &&){}\n" 1443 " const A& operator=(const A&){return *this;}\n" 1444 "};"); 1445 ASSERT_EQUALS("", errout.str()); 1446 1447 check("class B\n" 1448 "{\n" 1449 "public:\n" 1450 " B (const B & Var);\n" 1451 "};\n" 1452 "class A\n" 1453 "{\n" 1454 " B m_SemVar;\n" 1455 "public:\n" 1456 " A(){}\n" 1457 " A(const A&){}\n" 1458 " A(A &&){}\n" 1459 " const A& operator=(const A&){return *this;}\n" 1460 "};"); 1461 ASSERT_EQUALS("", errout.str()); 1462 1463 check("class A : public std::vector<int>\n" 1464 "{\n" 1465 "public:\n" 1466 " A(const A &a);\n" 1467 "};\n" 1468 "class B\n" 1469 "{\n" 1470 " A a;\n" 1471 "public:\n" 1472 " B(){}\n" 1473 " B(const B&){}\n" 1474 " B(B &&){}\n" 1475 " const B& operator=(const B&){return *this;}\n" 1476 "};", true); 1477 ASSERT_EQUALS("[test.cpp:11]: (warning, inconclusive) Member variable 'B::a' is not assigned in the copy constructor. Should it be copied?\n" 1478 "[test.cpp:12]: (warning, inconclusive) Member variable 'B::a' is not assigned in the copy constructor. Should it be copied?\n" 1479 "[test.cpp:13]: (warning, inconclusive) Member variable 'B::a' is not assigned a value in 'B::operator='.\n", 1480 errout.str()); 1481 1482 check("class B\n" 1483 "{\n" 1484 "public:\n" 1485 " B (B && Var);\n" 1486 " int data;\n" 1487 "};\n" 1488 "class A\n" 1489 "{\n" 1490 " B m_SemVar;\n" 1491 "public:\n" 1492 " A(){}\n" 1493 " A(const A&){}\n" 1494 " A(A &&){}\n" 1495 " const A& operator=(const A&){return *this;}\n" 1496 "};"); 1497 ASSERT_EQUALS("[test.cpp:13]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n", errout.str()); 1498 1499 check("class B\n" 1500 "{\n" 1501 "public:\n" 1502 " B ();\n" 1503 " B & operator= (const B & Var);\n" 1504 " int data;\n" 1505 "};\n" 1506 "class A\n" 1507 "{\n" 1508 " B m_SemVar;\n" 1509 "public:\n" 1510 " A(){}\n" 1511 " A(const A&){}\n" 1512 " A(A &&){}\n" 1513 " const A& operator=(const A&){return *this;}\n" 1514 "};"); 1515 ASSERT_EQUALS("", errout.str()); 1516 1517 check("class A\n" 1518 "{\n" 1519 " B m_SemVar;\n" 1520 "public:\n" 1521 " A(){}\n" 1522 " A(const A&){}\n" 1523 " const A& operator=(const A&){return *this;}\n" 1524 "};"); 1525 ASSERT_EQUALS("", errout.str()); 1526 } 1527 initvar_nocopy2()1528 void initvar_nocopy2() { // ticket #2484 1529 check("class B\n" 1530 "{\n" 1531 " B (B & Var);\n" 1532 " B & operator= (const B & Var);\n" 1533 " int data;\n" 1534 "};\n" 1535 "class A\n" 1536 "{\n" 1537 " B m_SemVar;\n" 1538 "public:\n" 1539 " A(){}\n" 1540 " A(const A&){}\n" 1541 " const A& operator=(const A&){return *this;}\n" 1542 "};", true); 1543 ASSERT_EQUALS("", errout.str()); 1544 1545 check("class B\n" 1546 "{\n" 1547 "public:\n" 1548 " B (B & Var);\n" 1549 " B & operator= (const B & Var);\n" 1550 " int data;\n" 1551 "};\n" 1552 "class A\n" 1553 "{\n" 1554 " B m_SemVar;\n" 1555 "public:\n" 1556 " A(){}\n" 1557 " A(const A&){}\n" 1558 " const A& operator=(const A&){return *this;}\n" 1559 "};", true); 1560 ASSERT_EQUALS("[test.cpp:12]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n" 1561 "[test.cpp:13]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n" 1562 "[test.cpp:14]: (warning) Member variable 'A::m_SemVar' is not assigned a value in 'A::operator='.\n", errout.str()); 1563 } 1564 initvar_nocopy3()1565 void initvar_nocopy3() { // #3611 - unknown type is non-copyable 1566 check("struct A {\n" 1567 " B b;\n" 1568 " A() {}\n" 1569 " A(const A& rhs) {}\n" 1570 "};"); 1571 ASSERT_EQUALS("", errout.str()); 1572 1573 check("struct A {\n" 1574 " B b;\n" 1575 " A() {}\n" 1576 " A(const A& rhs) {}\n" 1577 "};", true); 1578 ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) Member variable 'A::b' is not assigned in the copy constructor. Should it be copied?\n", errout.str()); 1579 } 1580 initvar_with_member_function_this()1581 void initvar_with_member_function_this() { 1582 check("struct Foo {\n" 1583 " Foo(int m) { this->setMember(m); }\n" 1584 " void setMember(int m) { member = m; }\n" 1585 " int member;\n" 1586 "};"); 1587 ASSERT_EQUALS("", errout.str()); 1588 } 1589 initvar_destructor()1590 void initvar_destructor() { 1591 check("class Fred\n" 1592 "{\n" 1593 "private:\n" 1594 " int var;\n" 1595 "public:\n" 1596 " Fred() : var(0) {}\n" 1597 " ~Fred() {}\n" 1598 "};"); 1599 ASSERT_EQUALS("", errout.str()); 1600 } 1601 initvar_func_ret_func_ptr()1602 void initvar_func_ret_func_ptr() { // ticket #4449 (segmentation fault) 1603 check("class something {\n" 1604 " int * ( something :: * process()) () { return 0; }\n" 1605 " something() { process(); }\n" 1606 "};"); 1607 ASSERT_EQUALS("", errout.str()); 1608 } 1609 initvar_alias()1610 void initvar_alias() { // #6921 1611 check("struct S {\n" 1612 " int a;\n" 1613 " S() {\n" 1614 " int& pa = a;\n" 1615 " pa = 4;\n" 1616 " }\n" 1617 "};"); 1618 ASSERT_EQUALS("", errout.str()); 1619 1620 check("struct S {\n" 1621 " int a;\n" 1622 " S() {\n" 1623 " int* pa = &a;\n" 1624 " *pa = 4;\n" 1625 " }\n" 1626 "};"); 1627 ASSERT_EQUALS("", errout.str()); 1628 1629 check("struct S {\n" 1630 " int a[2];\n" 1631 " S() {\n" 1632 " int* pa = a;\n" 1633 " for (int i = 0; i < 2; i++)\n" 1634 " *pa++ = i;\n" 1635 " }\n" 1636 "};"); 1637 ASSERT_EQUALS("", errout.str()); 1638 1639 check("struct S {\n" 1640 " int* a[2];\n" 1641 " S() {\n" 1642 " int* pa = a[1];\n" 1643 " *pa = 0;\n" 1644 " }\n" 1645 "};"); 1646 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'S::a' is not initialized in the constructor.\n", errout.str()); 1647 1648 check("struct S {\n" 1649 " int a;\n" 1650 " S() {\n" 1651 " int pa = a;\n" 1652 " pa = 4;\n" 1653 " }\n" 1654 "};"); 1655 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'S::a' is not initialized in the constructor.\n", errout.str()); 1656 } 1657 initvar_templateMember()1658 void initvar_templateMember() { 1659 check("template<int n_>\n" 1660 "struct Wrapper {\n" 1661 " static void foo(int * x) {\n" 1662 " for (int i(0); i <= n_; ++i)\n" 1663 " x[i] = 5;\n" 1664 " }\n" 1665 "};\n" 1666 "class A {\n" 1667 "public:\n" 1668 " static constexpr int dim = 5;\n" 1669 " int x[dim + 1];\n" 1670 " A() {\n" 1671 " Wrapper<dim>::foo(x);\n" 1672 " }\n" 1673 "};"); 1674 ASSERT_EQUALS("", errout.str()); 1675 } 1676 operatorEqSTL()1677 void operatorEqSTL() { 1678 check("class Fred\n" 1679 "{\n" 1680 "private:\n" 1681 " std::vector<int> ints;\n" 1682 "public:\n" 1683 " Fred();\n" 1684 " void operator=(const Fred &f);\n" 1685 "};\n" 1686 "\n" 1687 "Fred::Fred()\n" 1688 "{ }\n" 1689 "\n" 1690 "void Fred::operator=(const Fred &f)\n" 1691 "{ }", true); 1692 ASSERT_EQUALS("[test.cpp:13]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='.\n", errout.str()); 1693 } 1694 uninitVar1()1695 void uninitVar1() { 1696 check("enum ECODES\n" 1697 "{\n" 1698 " CODE_1 = 0,\n" 1699 " CODE_2 = 1\n" 1700 "};\n" 1701 "\n" 1702 "class Fred\n" 1703 "{\n" 1704 "public:\n" 1705 " Fred() {}\n" 1706 "\n" 1707 "private:\n" 1708 " ECODES _code;\n" 1709 "};"); 1710 1711 ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Fred::_code' is not initialized in the constructor.\n", errout.str()); 1712 1713 1714 check("class A{};\n" 1715 "\n" 1716 "class B : public A\n" 1717 "{\n" 1718 "public:\n" 1719 " B() {}\n" 1720 "private:\n" 1721 " float f;\n" 1722 "};"); 1723 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'B::f' is not initialized in the constructor.\n", errout.str()); 1724 1725 check("class C\n" 1726 "{\n" 1727 " FILE *fp;\n" 1728 "\n" 1729 "public:\n" 1730 " explicit C(FILE *fp);\n" 1731 "};\n" 1732 "\n" 1733 "C::C(FILE *fp) {\n" 1734 " C::fp = fp;\n" 1735 "}"); 1736 ASSERT_EQUALS("", errout.str()); 1737 } 1738 uninitVar2()1739 void uninitVar2() { 1740 check("class John\n" 1741 "{\n" 1742 "public:\n" 1743 " John() { (*this).i = 0; }\n" 1744 "private:\n" 1745 " int i;\n" 1746 "};"); 1747 ASSERT_EQUALS("", errout.str()); 1748 } 1749 uninitVar3()1750 void uninitVar3() { 1751 // No FP when struct has constructor 1752 check("class Foo\n" 1753 "{\n" 1754 "public:\n" 1755 " Foo() { }\n" 1756 "private:\n" 1757 " struct Bar {\n" 1758 " Bar();\n" 1759 " };\n" 1760 " Bar bars[2];\n" 1761 "};"); 1762 ASSERT_EQUALS("", errout.str()); 1763 1764 // Using struct that doesn't have constructor 1765 check("class Foo\n" 1766 "{\n" 1767 "public:\n" 1768 " Foo() { }\n" 1769 "private:\n" 1770 " struct Bar {\n" 1771 " int x;\n" 1772 " };\n" 1773 " Bar bars[2];\n" 1774 "};"); 1775 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::bars' is not initialized in the constructor.\n", errout.str()); 1776 } 1777 uninitVar4()1778 void uninitVar4() { 1779 check("class Foo\n" 1780 "{\n" 1781 "public:\n" 1782 " Foo() { bar.x = 0; }\n" 1783 "private:\n" 1784 " struct Bar {\n" 1785 " int x;\n" 1786 " };\n" 1787 " struct Bar bar;\n" 1788 "};"); 1789 ASSERT_EQUALS("", errout.str()); 1790 } 1791 uninitVar5()1792 void uninitVar5() { 1793 check("class Foo\n" 1794 "{\n" 1795 "public:\n" 1796 " Foo() { }\n" 1797 " Foo &operator=(const Foo &)\n" 1798 " { return *this; }\n" 1799 " static int i;\n" 1800 "};"); 1801 ASSERT_EQUALS("", errout.str()); 1802 } 1803 uninitVar6()1804 void uninitVar6() { 1805 check("class Foo : public Bar\n" 1806 "{\n" 1807 "public:\n" 1808 " explicit Foo(int i) : Bar(mi=i) { }\n" 1809 "private:\n" 1810 " int mi;\n" 1811 "};"); 1812 ASSERT_EQUALS("", errout.str()); 1813 1814 check("class Foo : public Bar\n" 1815 "{\n" 1816 "public:\n" 1817 " explicit Foo(int i) : Bar{mi=i} { }\n" 1818 "private:\n" 1819 " int mi;\n" 1820 "};"); 1821 ASSERT_EQUALS("", errout.str()); 1822 } 1823 uninitVar7()1824 void uninitVar7() { 1825 check("class Foo {\n" 1826 " int a;\n" 1827 "public:\n" 1828 " Foo() : a(0) {}\n" 1829 " Foo& operator=(const Foo&);\n" 1830 " void Swap(Foo& rhs);\n" 1831 "};\n" 1832 "\n" 1833 "void Foo::Swap(Foo& rhs) {\n" 1834 " std::swap(a,rhs.a);\n" 1835 "}\n" 1836 "\n" 1837 "Foo& Foo::operator=(const Foo& rhs) {\n" 1838 " Foo copy(rhs);\n" 1839 " copy.Swap(*this);\n" 1840 " return *this;\n" 1841 "}"); 1842 ASSERT_EQUALS("", errout.str()); 1843 } 1844 uninitVar8()1845 void uninitVar8() { 1846 check("class Foo {\n" 1847 " int a;\n" 1848 "public:\n" 1849 " Foo() : a(0) {}\n" 1850 " Foo& operator=(const Foo&);\n" 1851 "};\n" 1852 "\n" 1853 "Foo& Foo::operator=(const Foo& rhs) {\n" 1854 " if (&rhs != this)\n" 1855 " {\n" 1856 " }\n" 1857 " return *this;\n" 1858 "}"); 1859 ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'Foo::a' is not assigned a value in 'Foo::operator='.\n", errout.str()); 1860 } 1861 uninitVar9()1862 void uninitVar9() { // ticket #1730 1863 check("class Prefs {\n" 1864 "private:\n" 1865 " int xasd;\n" 1866 "public:\n" 1867 " explicit Prefs(wxSize size);\n" 1868 "};\n" 1869 "Prefs::Prefs(wxSize size)\n" 1870 "{\n" 1871 " SetMinSize( wxSize( 48,48 ) );\n" 1872 "}"); 1873 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Prefs::xasd' is not initialized in the constructor.\n", errout.str()); 1874 } 1875 uninitVar10()1876 void uninitVar10() { // ticket #1993 1877 check("class A {\n" 1878 "public:\n" 1879 " A();\n" 1880 "private:\n" 1881 " int var1;\n" 1882 " int var2;\n" 1883 "};\n" 1884 "A::A() : var1(0) { }"); 1885 ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'A::var2' is not initialized in the constructor.\n", errout.str()); 1886 } 1887 uninitVar11()1888 void uninitVar11() { 1889 check("class A {\n" 1890 "public:\n" 1891 " explicit A(int a = 0);\n" 1892 "private:\n" 1893 " int var;\n" 1894 "};\n" 1895 "A::A(int a) { }"); 1896 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::var' is not initialized in the constructor.\n", errout.str()); 1897 } 1898 uninitVar12()1899 void uninitVar12() { // ticket #2078 1900 check("class Point\n" 1901 "{\n" 1902 "public:\n" 1903 " Point()\n" 1904 " {\n" 1905 " Point(0, 0);\n" 1906 " }\n" 1907 " Point(int x, int y)\n" 1908 " : x(x), y(y)\n" 1909 " {}\n" 1910 " int x, y;\n" 1911 "};"); 1912 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Point::x' is not initialized in the constructor.\n" 1913 "[test.cpp:4]: (warning) Member variable 'Point::y' is not initialized in the constructor.\n", errout.str()); 1914 } 1915 uninitVar13()1916 void uninitVar13() { // ticket #1195 1917 check("class A {\n" 1918 "private:\n" 1919 " std::vector<int> *ints;\n" 1920 "public:\n" 1921 " A()\n" 1922 " {}\n" 1923 "};"); 1924 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'A::ints' is not initialized in the constructor.\n", errout.str()); 1925 } 1926 uninitVar14()1927 void uninitVar14() { // ticket #2149 1928 // no namespace 1929 check("class Foo\n" 1930 "{\n" 1931 "public:\n" 1932 " Foo();\n" 1933 "private:\n" 1934 " bool mMember;\n" 1935 "};\n" 1936 "Foo::Foo()\n" 1937 "{\n" 1938 "}"); 1939 ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str()); 1940 1941 // single namespace 1942 check("namespace Output\n" 1943 "{\n" 1944 " class Foo\n" 1945 " {\n" 1946 " public:\n" 1947 " Foo();\n" 1948 " private:\n" 1949 " bool mMember;\n" 1950 " };\n" 1951 " Foo::Foo()\n" 1952 " {\n" 1953 " }\n" 1954 "}"); 1955 ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str()); 1956 1957 // constructor outside namespace 1958 check("namespace Output\n" 1959 "{\n" 1960 " class Foo\n" 1961 " {\n" 1962 " public:\n" 1963 " Foo();\n" 1964 " private:\n" 1965 " bool mMember;\n" 1966 " };\n" 1967 "}\n" 1968 "Foo::Foo()\n" 1969 "{\n" 1970 "}"); 1971 ASSERT_EQUALS("", errout.str()); 1972 1973 // constructor outside namespace 1974 check("namespace Output\n" 1975 "{\n" 1976 " class Foo\n" 1977 " {\n" 1978 " public:\n" 1979 " Foo();\n" 1980 " private:\n" 1981 " bool mMember;\n" 1982 " };\n" 1983 "}\n" 1984 "Output::Foo::Foo()\n" 1985 "{\n" 1986 "}"); 1987 ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str()); 1988 1989 // constructor in separate namespace 1990 check("namespace Output\n" 1991 "{\n" 1992 " class Foo\n" 1993 " {\n" 1994 " public:\n" 1995 " Foo();\n" 1996 " private:\n" 1997 " bool mMember;\n" 1998 " };\n" 1999 "}\n" 2000 "namespace Output\n" 2001 "{\n" 2002 " Foo::Foo()\n" 2003 " {\n" 2004 " }\n" 2005 "}"); 2006 ASSERT_EQUALS("[test.cpp:13]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str()); 2007 2008 // constructor in different separate namespace 2009 check("namespace Output\n" 2010 "{\n" 2011 " class Foo\n" 2012 " {\n" 2013 " public:\n" 2014 " Foo();\n" 2015 " private:\n" 2016 " bool mMember;\n" 2017 " };\n" 2018 "}\n" 2019 "namespace Input\n" 2020 "{\n" 2021 " Foo::Foo()\n" 2022 " {\n" 2023 " }\n" 2024 "}"); 2025 ASSERT_EQUALS("", errout.str()); 2026 2027 // constructor in different separate namespace (won't compile) 2028 check("namespace Output\n" 2029 "{\n" 2030 " class Foo\n" 2031 " {\n" 2032 " public:\n" 2033 " Foo();\n" 2034 " private:\n" 2035 " bool mMember;\n" 2036 " };\n" 2037 "}\n" 2038 "namespace Input\n" 2039 "{\n" 2040 " Output::Foo::Foo()\n" 2041 " {\n" 2042 " }\n" 2043 "}"); 2044 ASSERT_EQUALS("", errout.str()); 2045 2046 // constructor in nested separate namespace 2047 check("namespace A\n" 2048 "{\n" 2049 " namespace Output\n" 2050 " {\n" 2051 " class Foo\n" 2052 " {\n" 2053 " public:\n" 2054 " Foo();\n" 2055 " private:\n" 2056 " bool mMember;\n" 2057 " };\n" 2058 " }\n" 2059 " namespace Output\n" 2060 " {\n" 2061 " Foo::Foo()\n" 2062 " {\n" 2063 " }\n" 2064 " }\n" 2065 "}"); 2066 ASSERT_EQUALS("[test.cpp:15]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str()); 2067 2068 // constructor in nested different separate namespace 2069 check("namespace A\n" 2070 "{\n" 2071 " namespace Output\n" 2072 " {\n" 2073 " class Foo\n" 2074 " {\n" 2075 " public:\n" 2076 " Foo();\n" 2077 " private:\n" 2078 " bool mMember;\n" 2079 " };\n" 2080 " }\n" 2081 " namespace Input\n" 2082 " {\n" 2083 " Foo::Foo()\n" 2084 " {\n" 2085 " }\n" 2086 " }\n" 2087 "}"); 2088 ASSERT_EQUALS("", errout.str()); 2089 2090 // constructor in nested different separate namespace 2091 check("namespace A\n" 2092 "{\n" 2093 " namespace Output\n" 2094 " {\n" 2095 " class Foo\n" 2096 " {\n" 2097 " public:\n" 2098 " Foo();\n" 2099 " private:\n" 2100 " bool mMember;\n" 2101 " };\n" 2102 " }\n" 2103 " namespace Input\n" 2104 " {\n" 2105 " Output::Foo::Foo()\n" 2106 " {\n" 2107 " }\n" 2108 " }\n" 2109 "}"); 2110 ASSERT_EQUALS("", errout.str()); 2111 } 2112 uninitVar15()2113 void uninitVar15() { 2114 check("class Fred\n" 2115 "{\n" 2116 " int a;\n" 2117 "public:\n" 2118 " Fred();\n" 2119 " ~Fred();\n" 2120 "};\n" 2121 "Fred::~Fred()\n" 2122 "{\n" 2123 "}"); 2124 ASSERT_EQUALS("", errout.str()); 2125 } 2126 uninitVar16()2127 void uninitVar16() { 2128 check("struct Foo\n" 2129 "{\n" 2130 " int a;\n" 2131 " void set(int x) { a = x; }\n" 2132 "};\n" 2133 "class Bar\n" 2134 "{\n" 2135 " Foo foo;\n" 2136 "public:\n" 2137 " Bar()\n" 2138 " {\n" 2139 " foo.set(0);\n" 2140 " }\n" 2141 "};"); 2142 ASSERT_EQUALS("", errout.str()); 2143 2144 check("struct Foo\n" 2145 "{\n" 2146 " int a;\n" 2147 " void set(int x) { a = x; }\n" 2148 "};\n" 2149 "class Bar\n" 2150 "{\n" 2151 " Foo foo;\n" 2152 "public:\n" 2153 " Bar()\n" 2154 " {\n" 2155 " }\n" 2156 "};"); 2157 ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Bar::foo' is not initialized in the constructor.\n", errout.str()); 2158 } 2159 uninitVar17()2160 void uninitVar17() { 2161 check("struct Foo\n" 2162 "{\n" 2163 " int a;\n" 2164 "};\n" 2165 "class Bar\n" 2166 "{\n" 2167 " Foo foo[10];\n" 2168 "public:\n" 2169 " Bar()\n" 2170 " {\n" 2171 " foo[0].a = 0;\n" 2172 " }\n" 2173 "};"); 2174 ASSERT_EQUALS("", errout.str()); 2175 2176 check("struct Foo\n" 2177 "{\n" 2178 " int a;\n" 2179 "};\n" 2180 "class Bar\n" 2181 "{\n" 2182 " Foo foo[10];\n" 2183 "public:\n" 2184 " Bar()\n" 2185 " {\n" 2186 " }\n" 2187 "};"); 2188 ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Bar::foo' is not initialized in the constructor.\n", errout.str()); 2189 } 2190 uninitVar18()2191 void uninitVar18() { // ticket #2465 2192 check("struct Altren\n" 2193 "{\n" 2194 " explicit Altren(int _a = 0) : value(0) { }\n" 2195 " int value;\n" 2196 "};\n" 2197 "class A\n" 2198 "{\n" 2199 "public:\n" 2200 " A() { }\n" 2201 "private:\n" 2202 " Altren value;\n" 2203 "};"); 2204 ASSERT_EQUALS("", errout.str()); 2205 } 2206 uninitVar19()2207 void uninitVar19() { // ticket #2792 2208 check("class mystring\n" 2209 "{\n" 2210 " char* m_str;\n" 2211 " int m_len;\n" 2212 "public:\n" 2213 " explicit mystring(const char* str)\n" 2214 " {\n" 2215 " m_len = strlen(str);\n" 2216 " m_str = (char*) malloc(m_len+1);\n" 2217 " memcpy(m_str, str, m_len+1);\n" 2218 " }\n" 2219 " mystring& operator=(const mystring& copy)\n" 2220 " {\n" 2221 " return (*this = copy.m_str);\n" 2222 " }\n" 2223 " ~mystring()\n" 2224 " {\n" 2225 " free(m_str);\n" 2226 " }\n" 2227 "};"); 2228 ASSERT_EQUALS("", errout.str()); 2229 } 2230 uninitVar20()2231 void uninitVar20() { // ticket #2867 2232 check("Object::MemFunc() {\n" 2233 " class LocalClass {\n" 2234 " public:\n" 2235 " LocalClass() : dataLength_(0) {}\n" 2236 " std::streamsize dataLength_;\n" 2237 " double bitsInData_;\n" 2238 " } obj;\n" 2239 "};"); 2240 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n", errout.str()); 2241 2242 check("struct copy_protected;\n" 2243 "Object::MemFunc() {\n" 2244 " class LocalClass : public copy_protected {\n" 2245 " public:\n" 2246 " LocalClass() : copy_protected(1), dataLength_(0) {}\n" 2247 " std::streamsize dataLength_;\n" 2248 " double bitsInData_;\n" 2249 " } obj;\n" 2250 "};"); 2251 ASSERT_EQUALS( 2252 "[test.cpp:5]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n", 2253 errout.str()); 2254 2255 check("struct copy_protected;\n" 2256 "Object::MemFunc() {\n" 2257 " class LocalClass : ::copy_protected {\n" 2258 " public:\n" 2259 " LocalClass() : copy_protected(1), dataLength_(0) {}\n" 2260 " std::streamsize dataLength_;\n" 2261 " double bitsInData_;\n" 2262 " } obj;\n" 2263 "};"); 2264 ASSERT_EQUALS( 2265 "[test.cpp:5]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n", 2266 errout.str()); 2267 } 2268 uninitVar21()2269 void uninitVar21() { // ticket #2947 2270 check("class Fred {\n" 2271 "private:\n" 2272 " int a[23];\n" 2273 "public:\n" 2274 " Fred();\n" 2275 "};\n" 2276 "Fred::Fred() {\n" 2277 " a[x::y] = 0;\n" 2278 "}"); 2279 ASSERT_EQUALS("", errout.str()); 2280 } 2281 uninitVar22()2282 void uninitVar22() { // ticket #3043 2283 check("class Fred {\n" 2284 " public:\n" 2285 " Fred & operator=(const Fred &);\n" 2286 " virtual Fred & clone(const Fred & other);\n" 2287 " int x;\n" 2288 "};\n" 2289 "Fred & Fred::operator=(const Fred & other) {\n" 2290 " return clone(other);\n" 2291 "}\n" 2292 "Fred & Fred::clone(const Fred & other) {\n" 2293 " x = 0;\n" 2294 " return *this;\n" 2295 "}"); 2296 ASSERT_EQUALS("", errout.str()); 2297 2298 check("class Fred {\n" 2299 " public:\n" 2300 " Fred & operator=(const Fred &);\n" 2301 " virtual Fred & clone(const Fred & other);\n" 2302 " int x;\n" 2303 "};\n" 2304 "Fred & Fred::operator=(const Fred & other) {\n" 2305 " return clone(other);\n" 2306 "}\n" 2307 "Fred & Fred::clone(const Fred & other) {\n" 2308 " return *this;\n" 2309 "}"); 2310 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::x' is not assigned a value in 'Fred::operator='.\n", errout.str()); 2311 } 2312 uninitVar23()2313 void uninitVar23() { // ticket #3702 2314 check("class Fred {\n" 2315 " int x;\n" 2316 "public:\n" 2317 " Fred(struct A a, struct B b);\n" 2318 " Fred(C c, struct D d);\n" 2319 " Fred(struct E e, F f);\n" 2320 " Fred(struct G, struct H);\n" 2321 " Fred(I, J);\n" 2322 "};\n" 2323 "Fred::Fred(A a, B b) { }\n" 2324 "Fred::Fred(struct C c, D d) { }\n" 2325 "Fred::Fred(E e, struct F f) { }\n" 2326 "Fred::Fred(G g, H h) { }\n" 2327 "Fred::Fred(struct I i, struct J j) { }"); 2328 ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n" 2329 "[test.cpp:11]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n" 2330 "[test.cpp:12]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n" 2331 "[test.cpp:13]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n" 2332 "[test.cpp:14]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n", errout.str()); 2333 } 2334 uninitVar24()2335 void uninitVar24() { // ticket #3190 2336 check("class Foo;\n" 2337 "class Bar;\n" 2338 "class Sub;\n" 2339 "class Foo { class Sub; };\n" 2340 "class Bar { class Sub; };\n" 2341 "class Bar::Sub {\n" 2342 " int b;\n" 2343 "public:\n" 2344 " Sub() { }\n" 2345 " Sub(int);\n" 2346 "};\n" 2347 "Bar::Sub::Sub(int) { };\n" 2348 "class ::Foo::Sub {\n" 2349 " int f;\n" 2350 "public:\n" 2351 " ~Sub();\n" 2352 " Sub();\n" 2353 "};\n" 2354 "::Foo::Sub::~Sub() { }\n" 2355 "::Foo::Sub::Sub() { }\n" 2356 "class Foo;\n" 2357 "class Bar;\n" 2358 "class Sub;\n", true); 2359 2360 ASSERT_EQUALS("[test.cpp:9]: (warning, inconclusive) Member variable 'Sub::b' is not initialized in the constructor.\n" 2361 "[test.cpp:12]: (warning) Member variable 'Sub::b' is not initialized in the constructor.\n" 2362 "[test.cpp:20]: (warning) Member variable 'Sub::f' is not initialized in the constructor.\n", errout.str()); 2363 } 2364 uninitVar25()2365 void uninitVar25() { // ticket #4789 2366 check("struct A {\n" 2367 " int a;\n" 2368 " int b;\n" 2369 " int c;\n" 2370 " A(int x = 0, int y = 0, int z = 0);\n" 2371 "};\n" 2372 "A::A(int x = 0, int y = 0, int z = 0) { }\n" 2373 "struct B {\n" 2374 " int a;\n" 2375 " int b;\n" 2376 " int c;\n" 2377 " B(int x = 0, int y = 0, int z = 0);\n" 2378 "};\n" 2379 "B::B(int x, int y, int z) { }\n" 2380 "struct C {\n" 2381 " int a;\n" 2382 " int b;\n" 2383 " int c;\n" 2384 " C(int, int, int);\n" 2385 "};\n" 2386 "C::C(int x = 0, int y = 0, int z = 0) { }\n" 2387 "struct D {\n" 2388 " int a;\n" 2389 " int b;\n" 2390 " int c;\n" 2391 " D(int, int, int);\n" 2392 "};\n" 2393 "D::D(int x, int y, int z) { }\n" 2394 "struct E {\n" 2395 " int a;\n" 2396 " int b;\n" 2397 " int c;\n" 2398 " E(int x, int y, int z);\n" 2399 "};\n" 2400 "E::E(int, int, int) { }\n" 2401 "struct F {\n" 2402 " int a;\n" 2403 " int b;\n" 2404 " int c;\n" 2405 " F(int x = 0, int y = 0, int z = 0);\n" 2406 "};\n" 2407 "F::F(int, int, int) { }\n", true); 2408 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::a' is not initialized in the constructor.\n" 2409 "[test.cpp:7]: (warning) Member variable 'A::b' is not initialized in the constructor.\n" 2410 "[test.cpp:7]: (warning) Member variable 'A::c' is not initialized in the constructor.\n" 2411 "[test.cpp:14]: (warning) Member variable 'B::a' is not initialized in the constructor.\n" 2412 "[test.cpp:14]: (warning) Member variable 'B::b' is not initialized in the constructor.\n" 2413 "[test.cpp:14]: (warning) Member variable 'B::c' is not initialized in the constructor.\n" 2414 "[test.cpp:21]: (warning) Member variable 'C::a' is not initialized in the constructor.\n" 2415 "[test.cpp:21]: (warning) Member variable 'C::b' is not initialized in the constructor.\n" 2416 "[test.cpp:21]: (warning) Member variable 'C::c' is not initialized in the constructor.\n" 2417 "[test.cpp:28]: (warning) Member variable 'D::a' is not initialized in the constructor.\n" 2418 "[test.cpp:28]: (warning) Member variable 'D::b' is not initialized in the constructor.\n" 2419 "[test.cpp:28]: (warning) Member variable 'D::c' is not initialized in the constructor.\n" 2420 "[test.cpp:35]: (warning) Member variable 'E::a' is not initialized in the constructor.\n" 2421 "[test.cpp:35]: (warning) Member variable 'E::b' is not initialized in the constructor.\n" 2422 "[test.cpp:35]: (warning) Member variable 'E::c' is not initialized in the constructor.\n" 2423 "[test.cpp:42]: (warning) Member variable 'F::a' is not initialized in the constructor.\n" 2424 "[test.cpp:42]: (warning) Member variable 'F::b' is not initialized in the constructor.\n" 2425 "[test.cpp:42]: (warning) Member variable 'F::c' is not initialized in the constructor.\n", errout.str()); 2426 } 2427 uninitVar26()2428 void uninitVar26() { 2429 check("class A {\n" 2430 " int * v;\n" 2431 " int sz;\n" 2432 "public:\n" 2433 " A(int s) {\n" 2434 " v = new int [sz = s];\n" 2435 " }\n" 2436 "};"); 2437 ASSERT_EQUALS("", errout.str()); 2438 } 2439 uninitVar27()2440 void uninitVar27() { 2441 check("class A {\n" 2442 " double d;\n" 2443 "public:\n" 2444 " A() {\n" 2445 " rtl::math::setNan(&d);\n" 2446 " }\n" 2447 "};"); 2448 ASSERT_EQUALS("", errout.str()); 2449 check("class A {\n" 2450 " double d;\n" 2451 "public:\n" 2452 " A() {\n" 2453 " ::rtl::math::setNan(&d);\n" 2454 " }\n" 2455 "};"); 2456 ASSERT_EQUALS("", errout.str()); 2457 } 2458 uninitVar28()2459 void uninitVar28() { 2460 check("class Fred {\n" 2461 " int i;\n" 2462 " float f;\n" 2463 "public:\n" 2464 " Fred() {\n" 2465 " foo(1);\n" 2466 " foo(1.0f);\n" 2467 " }\n" 2468 " void foo(int a) { i = a; }\n" 2469 " void foo(float a) { f = a; }\n" 2470 "};"); 2471 ASSERT_EQUALS("", errout.str()); 2472 } 2473 uninitVar29()2474 void uninitVar29() { 2475 check("class A {\n" 2476 " int i;\n" 2477 "public:\n" 2478 " A() { foo(); }\n" 2479 " void foo() const { };\n" 2480 " void foo() { i = 0; }\n" 2481 "};\n" 2482 "class B {\n" 2483 " int i;\n" 2484 "public:\n" 2485 " B() { foo(); }\n" 2486 " void foo() { i = 0; }\n" 2487 " void foo() const { }\n" 2488 "};\n" 2489 "class C {\n" 2490 " int i;\n" 2491 "public:\n" 2492 " C() { foo(); }\n" 2493 " void foo() const { i = 0; }\n" 2494 " void foo() { }\n" 2495 "};\n" 2496 "class D {\n" 2497 " int i;\n" 2498 "public:\n" 2499 " D() { foo(); }\n" 2500 " void foo() { }\n" 2501 " void foo() const { i = 0; }\n" 2502 "};"); 2503 ASSERT_EQUALS("[test.cpp:18]: (warning) Member variable 'C::i' is not initialized in the constructor.\n" 2504 "[test.cpp:25]: (warning) Member variable 'D::i' is not initialized in the constructor.\n", errout.str()); 2505 } 2506 uninitVar30()2507 void uninitVar30() { // ticket #6417 2508 check("namespace NS {\n" 2509 " class MyClass {\n" 2510 " public:\n" 2511 " MyClass();\n" 2512 " ~MyClass();\n" 2513 " private:\n" 2514 " bool SomeVar;\n" 2515 " };\n" 2516 "}\n" 2517 "using namespace NS;\n" 2518 "MyClass::~MyClass() { }\n" 2519 "MyClass::MyClass() : SomeVar(false) { }"); 2520 ASSERT_EQUALS("", errout.str()); 2521 } 2522 uninitVar31()2523 void uninitVar31() { // ticket #8271 2524 check("void bar();\n" 2525 "class MyClass {\n" 2526 "public:\n" 2527 " MyClass();\n" 2528 " void Restart();\n" 2529 "protected:\n" 2530 " int m_retCode;\n" 2531 "};\n" 2532 "MyClass::MyClass() {\n" 2533 " bar(),Restart();\n" 2534 "}\n" 2535 "void MyClass::Restart() {\n" 2536 " m_retCode = 0;\n" 2537 "}"); 2538 ASSERT_EQUALS("", errout.str()); 2539 } 2540 uninitVar32()2541 void uninitVar32() { // ticket #8835 2542 check("class Foo {\n" 2543 " friend class Bar;\n" 2544 " int member;\n" 2545 "public:\n" 2546 " Foo()\n" 2547 " {\n" 2548 " if (1) {}\n" 2549 " }\n" 2550 "};"); 2551 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str()); 2552 check("class Foo {\n" 2553 " friend class Bar;\n" 2554 " int member;\n" 2555 "public:\n" 2556 " Foo()\n" 2557 " {\n" 2558 " while (1) {}\n" 2559 " }\n" 2560 "};"); 2561 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str()); 2562 check("class Foo {\n" 2563 " friend class Bar;\n" 2564 " int member;\n" 2565 "public:\n" 2566 " Foo()\n" 2567 " {\n" 2568 " for (;;) {}\n" 2569 " }\n" 2570 "};"); 2571 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str()); 2572 } 2573 uninitVar33()2574 void uninitVar33() { // ticket #10295 2575 check("namespace app {\n" 2576 " class B {\n" 2577 " public:\n" 2578 " B(void);\n" 2579 " int x;\n" 2580 " };\n" 2581 "};\n" 2582 "app::B::B(void){}"); 2583 ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'B::x' is not initialized in the constructor.\n", errout.str()); 2584 } 2585 uninitVarArray1()2586 void uninitVarArray1() { 2587 check("class John\n" 2588 "{\n" 2589 "public:\n" 2590 " John() {}\n" 2591 "\n" 2592 "private:\n" 2593 " char name[255];\n" 2594 "};"); 2595 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'John::name' is not initialized in the constructor.\n", errout.str()); 2596 2597 check("class John\n" 2598 "{\n" 2599 "public:\n" 2600 " John() {John::name[0] = '\\0';}\n" 2601 "\n" 2602 "private:\n" 2603 " char name[255];\n" 2604 "};"); 2605 ASSERT_EQUALS("", errout.str()); 2606 2607 check("class John\n" 2608 "{\n" 2609 "public:\n" 2610 " John() { strcpy(name, \"\"); }\n" 2611 "\n" 2612 "private:\n" 2613 " char name[255];\n" 2614 "};"); 2615 ASSERT_EQUALS("", errout.str()); 2616 2617 check("class John\n" 2618 "{\n" 2619 "public:\n" 2620 " John() { }\n" 2621 "\n" 2622 " double operator[](const unsigned long i);\n" 2623 "};"); 2624 ASSERT_EQUALS("", errout.str()); 2625 2626 check("class A;\n" 2627 "class John\n" 2628 "{\n" 2629 "public:\n" 2630 " John() { }\n" 2631 " A a[5];\n" 2632 "};"); 2633 ASSERT_EQUALS("", errout.str()); 2634 2635 check("class A;\n" 2636 "class John\n" 2637 "{\n" 2638 "public:\n" 2639 " John() { }\n" 2640 " A (*a)[5];\n" 2641 "};"); 2642 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'John::a' is not initialized in the constructor.\n", errout.str()); 2643 } 2644 uninitVarArray2()2645 void uninitVarArray2() { 2646 check("class John\n" 2647 "{\n" 2648 "public:\n" 2649 " John() { *name = 0; }\n" 2650 "\n" 2651 "private:\n" 2652 " char name[255];\n" 2653 "};"); 2654 ASSERT_EQUALS("", errout.str()); 2655 2656 // #5754 2657 check("class John\n" 2658 "{\n" 2659 "public:\n" 2660 " John() {*this->name = '\\0';}\n" 2661 "\n" 2662 "private:\n" 2663 " char name[255];\n" 2664 "};"); 2665 ASSERT_EQUALS("", errout.str()); 2666 } 2667 uninitVarArray3()2668 void uninitVarArray3() { 2669 check("class John\n" 2670 "{\n" 2671 "private:\n" 2672 " int a[100];\n" 2673 " int b[100];\n" 2674 "\n" 2675 "public:\n" 2676 " John()\n" 2677 " {\n" 2678 " memset(a,0,sizeof(a));\n" 2679 " memset(b,0,sizeof(b));\n" 2680 " }\n" 2681 "};"); 2682 ASSERT_EQUALS("", errout.str()); 2683 } 2684 uninitVarArray4()2685 void uninitVarArray4() { 2686 check("class John\n" 2687 "{\n" 2688 "private:\n" 2689 " int a[100];\n" 2690 " int b[100];\n" 2691 "\n" 2692 "public:\n" 2693 " John()\n" 2694 " {\n" 2695 " if (snprintf(a,10,\"a\")) { }\n" 2696 " if (snprintf(b,10,\"b\")) { }\n" 2697 " }\n" 2698 "};"); 2699 ASSERT_EQUALS("", errout.str()); 2700 } 2701 uninitVarArray5()2702 void uninitVarArray5() { 2703 check("class Foo\n" 2704 "{\n" 2705 "private:\n" 2706 " Bar bars[10];\n" 2707 "public:\n" 2708 " Foo()\n" 2709 " { }\n" 2710 "};"); 2711 ASSERT_EQUALS("", errout.str()); 2712 } 2713 uninitVarArray6()2714 void uninitVarArray6() { 2715 check("class Foo\n" 2716 "{\n" 2717 "public:\n" 2718 " Foo();\n" 2719 " static const char STR[];\n" 2720 "};\n" 2721 "const char Foo::STR[] = \"abc\";\n" 2722 "Foo::Foo() { }"); 2723 ASSERT_EQUALS("", errout.str()); 2724 } 2725 uninitVarArray7()2726 void uninitVarArray7() { 2727 check("class Foo\n" 2728 "{\n" 2729 " int array[10];\n" 2730 "public:\n" 2731 " Foo() { }\n" 2732 "};"); 2733 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::array' is not initialized in the constructor.\n", errout.str()); 2734 2735 check("class Foo\n" 2736 "{\n" 2737 " int array[10];\n" 2738 "public:\n" 2739 " Foo() { memset(array, 0, sizeof(array)); }\n" 2740 "};"); 2741 ASSERT_EQUALS("", errout.str()); 2742 2743 check("class Foo\n" 2744 "{\n" 2745 " int array[10];\n" 2746 "public:\n" 2747 " Foo() { ::memset(array, 0, sizeof(array)); }\n" 2748 "};"); 2749 ASSERT_EQUALS("", errout.str()); 2750 } 2751 uninitVarArray8()2752 void uninitVarArray8() { 2753 check("class Foo {\n" 2754 " char a[10];\n" 2755 "public:\n" 2756 " Foo() { ::ZeroMemory(a); }\n" 2757 "}"); 2758 ASSERT_EQUALS("", errout.str()); 2759 } 2760 uninitVarArray9()2761 void uninitVarArray9() { // #6957 2762 check("class BaseGDL;\n" 2763 "struct IxExprListT {\n" 2764 "private:\n" 2765 " BaseGDL* eArr[3];\n" 2766 "public:\n" 2767 " IxExprListT() {}\n" 2768 "};"); 2769 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'IxExprListT::eArr' is not initialized in the constructor.\n", errout.str()); 2770 check("struct sRAIUnitDefBL {\n" 2771 " sRAIUnitDefBL();\n" 2772 " ~sRAIUnitDefBL();\n" 2773 "};\n" 2774 "struct sRAIUnitDef {\n" 2775 " sRAIUnitDef() {}\n" 2776 " sRAIUnitDefBL *List[35];\n" 2777 "};"); 2778 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'sRAIUnitDef::List' is not initialized in the constructor.\n", errout.str()); 2779 } 2780 uninitVarArray2D()2781 void uninitVarArray2D() { 2782 check("class John\n" 2783 "{\n" 2784 "public:\n" 2785 " John() { a[0][0] = 0; }\n" 2786 "\n" 2787 "private:\n" 2788 " char a[2][2];\n" 2789 "};"); 2790 ASSERT_EQUALS("", errout.str()); 2791 } 2792 uninitVarArray3D()2793 void uninitVarArray3D() { 2794 check("class John\n" 2795 "{\n" 2796 "private:\n" 2797 " char a[2][2][2];\n" 2798 "public:\n" 2799 " John() { a[0][0][0] = 0; }\n" 2800 "};"); 2801 ASSERT_EQUALS("", errout.str()); 2802 } 2803 uninitVarCpp11Init1()2804 void uninitVarCpp11Init1() { 2805 check("class Foo {\n" 2806 " std::vector<std::string> bar;\n" 2807 "public:\n" 2808 " Foo()\n" 2809 " : bar({\"a\", \"b\"})\n" 2810 " {}\n" 2811 "};"); 2812 ASSERT_EQUALS("", errout.str()); 2813 } 2814 uninitVarCpp11Init2()2815 void uninitVarCpp11Init2() { 2816 check("class Fred {\n" 2817 " struct Foo {\n" 2818 " int a;\n" 2819 " bool b;\n" 2820 " };\n" 2821 " Foo f;\n" 2822 " float g;\n" 2823 "public:\n" 2824 " Fred() : f{0, true} { }\n" 2825 " float get() const;\n" 2826 "};\n" 2827 "float Fred::get() const { return g; }"); 2828 ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Fred::g' is not initialized in the constructor.\n", errout.str()); 2829 } 2830 uninitVarStruct1()2831 void uninitVarStruct1() { // ticket #2172 2832 check("class A\n" 2833 "{\n" 2834 "private:\n" 2835 " struct B {\n" 2836 " std::string str1;\n" 2837 " std::string str2;\n" 2838 " }\n" 2839 " struct B b;\n" 2840 "public:\n" 2841 " A() {\n" 2842 " }\n" 2843 "};"); 2844 ASSERT_EQUALS("", errout.str()); 2845 2846 check("class A\n" 2847 "{\n" 2848 "private:\n" 2849 " struct B {\n" 2850 " char *str1;\n" 2851 " char *str2;\n" 2852 " }\n" 2853 " struct B b;\n" 2854 "public:\n" 2855 " A() {\n" 2856 " }\n" 2857 "};"); 2858 ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'A::b' is not initialized in the constructor.\n", errout.str()); 2859 2860 check("class A\n" 2861 "{\n" 2862 "private:\n" 2863 " struct B {\n" 2864 " char *str1;\n" 2865 " char *str2;\n" 2866 " B() : str1(NULL), str2(NULL) { }\n" 2867 " }\n" 2868 " struct B b;\n" 2869 "public:\n" 2870 " A() {\n" 2871 " }\n" 2872 "};"); 2873 ASSERT_EQUALS("", errout.str()); 2874 } 2875 uninitVarStruct2()2876 void uninitVarStruct2() { // ticket #838 2877 check("struct POINT\n" 2878 "{\n" 2879 " int x;\n" 2880 " int y;\n" 2881 "};\n" 2882 "class Fred\n" 2883 "{\n" 2884 "private:\n" 2885 " POINT p;\n" 2886 "public:\n" 2887 " Fred()\n" 2888 " { }\n" 2889 "};"); 2890 ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Fred::p' is not initialized in the constructor.\n", errout.str()); 2891 2892 check("struct POINT\n" 2893 "{\n" 2894 " int x;\n" 2895 " int y;\n" 2896 " POINT();\n" 2897 "};\n" 2898 "class Fred\n" 2899 "{\n" 2900 "private:\n" 2901 " POINT p;\n" 2902 "public:\n" 2903 " Fred()\n" 2904 " { }\n" 2905 "};"); 2906 ASSERT_EQUALS("", errout.str()); 2907 2908 check("struct POINT\n" 2909 "{\n" 2910 " int x;\n" 2911 " int y;\n" 2912 " POINT() :x(0), y(0) { }\n" 2913 "};\n" 2914 "class Fred\n" 2915 "{\n" 2916 "private:\n" 2917 " POINT p;\n" 2918 "public:\n" 2919 " Fred()\n" 2920 " { }\n" 2921 "};"); 2922 ASSERT_EQUALS("", errout.str()); 2923 2924 // non static data-member initialization 2925 check("struct POINT\n" 2926 "{\n" 2927 " int x=0;\n" 2928 " int y=0;\n" 2929 "};\n" 2930 "class Fred\n" 2931 "{\n" 2932 "private:\n" 2933 " POINT p;\n" 2934 "public:\n" 2935 " Fred()\n" 2936 " { }\n" 2937 "};"); 2938 ASSERT_EQUALS("", errout.str()); 2939 } 2940 uninitVarUnion1()2941 void uninitVarUnion1() { // ticket #3196 2942 check("class Fred\n" 2943 "{\n" 2944 "private:\n" 2945 " union { int a; int b; };\n" 2946 "public:\n" 2947 " Fred()\n" 2948 " { a = 0; }\n" 2949 "};"); 2950 ASSERT_EQUALS("", errout.str()); 2951 } 2952 uninitVarUnion2()2953 void uninitVarUnion2() { 2954 // If the "data_type" is 0 it means union member "data" is invalid. 2955 // So it's ok to not initialize "data". 2956 // related forum: http://sourceforge.net/apps/phpbb/cppcheck/viewtopic.php?f=3&p=1806 2957 check("union Data { int id; int *ptr; };\n" 2958 "\n" 2959 "class Fred {\n" 2960 "private:\n" 2961 " int data_type;\n" 2962 " Data data;\n" 2963 "public:\n" 2964 " Fred() : data_type(0)\n" 2965 " { }\n" 2966 "};"); 2967 ASSERT_EQUALS("", errout.str()); 2968 } 2969 uninitMissingFuncDef()2970 void uninitMissingFuncDef() { 2971 // Unknown member function 2972 check("class Fred\n" 2973 "{\n" 2974 "public:\n" 2975 " Fred() { Init(); }\n" 2976 "private:\n" 2977 " void Init();" 2978 " int i;\n" 2979 "};"); 2980 ASSERT_EQUALS("", errout.str()); 2981 2982 // Unknown non-member function (friend class) 2983 check("class Fred\n" 2984 "{\n" 2985 "public:\n" 2986 " Fred() { Init(); }\n" 2987 "private:\n" 2988 " friend ABC;\n" 2989 " int i;\n" 2990 "};"); 2991 ASSERT_EQUALS("", errout.str()); 2992 2993 // Unknown non-member function (is Init a virtual function?) 2994 check("class Fred : private ABC\n" 2995 "{\n" 2996 "public:\n" 2997 " Fred() { Init(); }\n" 2998 "private:\n" 2999 " int i;\n" 3000 "};"); 3001 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 3002 3003 // Unknown non-member function 3004 check("class Fred\n" 3005 "{\n" 3006 "public:\n" 3007 " Fred() { Init(); }\n" 3008 "private:\n" 3009 " int i;\n" 3010 "};"); 3011 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 3012 3013 // Unknown non-member function 3014 check("class ABC { };\n" 3015 "class Fred : private ABC\n" 3016 "{\n" 3017 "public:\n" 3018 " Fred() { Init(); }\n" 3019 "private:\n" 3020 " int i;\n" 3021 "};"); 3022 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 3023 3024 } 3025 uninitVarEnum1()3026 void uninitVarEnum1() { 3027 check("class Fred\n" 3028 "{\n" 3029 "public:\n" 3030 " enum abc {a,b,c};\n" 3031 " Fred() {}\n" 3032 "private:\n" 3033 " unsigned int i;\n" 3034 "};"); 3035 3036 ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str()); 3037 } 3038 uninitVarEnum2()3039 void uninitVarEnum2() { // ticket #8146 3040 check("enum E { E1 };\n" 3041 "struct X { E e = E1; };\n" 3042 "struct Y {\n" 3043 " Y() {}\n" 3044 " X x;\n" 3045 "};"); 3046 3047 ASSERT_EQUALS("", errout.str()); 3048 } 3049 uninitVarStream()3050 void uninitVarStream() { 3051 check("class Foo\n" 3052 "{\n" 3053 "private:\n" 3054 " int foo;\n" 3055 "public:\n" 3056 " explicit Foo(std::istream &in)\n" 3057 " {\n" 3058 " if(!(in >> foo))\n" 3059 " throw 0;\n" 3060 " }\n" 3061 "};"); 3062 3063 ASSERT_EQUALS("", errout.str()); 3064 } 3065 uninitVarTypedef()3066 void uninitVarTypedef() { 3067 check("class Foo\n" 3068 "{\n" 3069 "public:\n" 3070 " typedef int * pointer;\n" 3071 " Foo() : a(0) {}\n" 3072 " pointer a;\n" 3073 "};"); 3074 3075 ASSERT_EQUALS("", errout.str()); 3076 } 3077 uninitVarMemset()3078 void uninitVarMemset() { 3079 check("class Foo\n" 3080 "{\n" 3081 "public:\n" 3082 " int * pointer;\n" 3083 " Foo() { memset(this, 0, sizeof(*this)); }\n" 3084 "};"); 3085 3086 ASSERT_EQUALS("", errout.str()); 3087 3088 check("class Foo\n" 3089 "{\n" 3090 "public:\n" 3091 " int * pointer;\n" 3092 " Foo() { ::memset(this, 0, sizeof(*this)); }\n" 3093 "};"); 3094 3095 ASSERT_EQUALS("", errout.str()); 3096 3097 // Ticket #7068 3098 check("struct Foo {\n" 3099 " int * p;\n" 3100 " char c;\n" 3101 " Foo() { memset(p, 0, sizeof(int)); }\n" 3102 "};"); 3103 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::c' is not initialized in the constructor.\n", errout.str()); 3104 check("struct Foo {\n" 3105 " int i;\n" 3106 " char c;\n" 3107 " Foo() { memset(&i, 0, sizeof(int)); }\n" 3108 "};"); 3109 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::c' is not initialized in the constructor.\n", errout.str()); 3110 check("struct Foo { int f; };\n" 3111 "struct Bar { int b; };\n" 3112 "struct FooBar {\n" 3113 " FooBar() {\n" 3114 " memset(&foo, 0, sizeof(foo));\n" 3115 " }\n" 3116 " Foo foo;\n" 3117 " Bar bar;\n" 3118 "};\n" 3119 "int main() {\n" 3120 " FooBar foobar;\n" 3121 " return foobar.foo.f + foobar.bar.b;\n" 3122 "}"); 3123 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor.\n", errout.str()); 3124 check("struct Foo { int f; };\n" 3125 "struct Bar { int b; };\n" 3126 "struct FooBar {\n" 3127 " FooBar() {\n" 3128 " memset(&this->foo, 0, sizeof(this->foo));\n" 3129 " }\n" 3130 " Foo foo;\n" 3131 " Bar bar;\n" 3132 "};\n" 3133 "int main() {\n" 3134 " FooBar foobar;\n" 3135 " return foobar.foo.f + foobar.bar.b;\n" 3136 "}"); 3137 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor.\n", errout.str()); 3138 3139 // #7755 3140 check("struct A {\n" 3141 " A() {\n" 3142 " memset(this->data, 0, 42);\n" 3143 " }\n" 3144 " char data[42];\n" 3145 "};"); 3146 ASSERT_EQUALS("", errout.str()); 3147 } 3148 privateCtor1()3149 void privateCtor1() { 3150 settings.standards.cpp = Standards::CPP03; 3151 check("class Foo {\n" 3152 " int foo;\n" 3153 " Foo() { }\n" 3154 "};"); 3155 ASSERT_EQUALS("", errout.str()); 3156 3157 settings.standards.cpp = Standards::CPP11; 3158 check("class Foo {\n" 3159 " int foo;\n" 3160 " Foo() { }\n" 3161 "};"); 3162 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Foo::foo' is not initialized in the constructor.\n", errout.str()); 3163 } 3164 privateCtor2()3165 void privateCtor2() { 3166 check("class Foo\n" 3167 "{\n" 3168 "private:\n" 3169 " int foo;\n" 3170 " Foo() { }\n" 3171 "public:\n" 3172 " explicit Foo(int _i) { }\n" 3173 "};"); 3174 3175 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Foo::foo' is not initialized in the constructor.\n", errout.str()); 3176 } 3177 3178 function()3179 void function() { 3180 check("class A\n" 3181 "{\n" 3182 "public:\n" 3183 " A();\n" 3184 " int* f(int*);\n" 3185 "};\n" 3186 "\n" 3187 "A::A()\n" 3188 "{\n" 3189 "}\n" 3190 "\n" 3191 "int* A::f(int* p)\n" 3192 "{\n" 3193 " return p;\n" 3194 "}"); 3195 3196 ASSERT_EQUALS("", errout.str()); 3197 } 3198 3199 3200 // Borland C++: No FP for published pointers - they are automatically initialized uninitVarPublished()3201 void uninitVarPublished() { 3202 check("class Fred\n" 3203 "{\n" 3204 "__published:\n" 3205 " int *i;\n" 3206 "public:\n" 3207 " Fred() { }\n" 3208 "};"); 3209 ASSERT_EQUALS("", errout.str()); 3210 } 3211 uninitVarInheritClassInit()3212 void uninitVarInheritClassInit() { 3213 Settings s; 3214 s.libraries.emplace_back("vcl"); 3215 3216 check("class Fred: public TObject\n" 3217 "{\n" 3218 "public:\n" 3219 " Fred() { }\n" 3220 "private:\n" 3221 " int x;\n" 3222 "};", s); 3223 ASSERT_EQUALS("", errout.str()); 3224 } 3225 uninitOperator()3226 void uninitOperator() { 3227 check("class Fred\n" 3228 "{\n" 3229 "public:\n" 3230 " Fred() { }\n" 3231 " int *operator [] (int index) { return 0; }\n" 3232 "};"); 3233 ASSERT_EQUALS("", errout.str()); 3234 } 3235 uninitFunction1()3236 void uninitFunction1() { 3237 check("class Fred\n" 3238 "{\n" 3239 "public:\n" 3240 " Fred() { init(*this); }\n" 3241 "\n" 3242 " static void init(Fred &f)\n" 3243 " { f.d = 0; }\n" 3244 "\n" 3245 " double d;\n" 3246 "};"); 3247 ASSERT_EQUALS("", errout.str()); 3248 3249 check("class Fred\n" 3250 "{\n" 3251 "public:\n" 3252 " Fred() { init(*this); }\n" 3253 "\n" 3254 " static void init(Fred &f)\n" 3255 " { }\n" 3256 "\n" 3257 " double d;\n" 3258 "};"); 3259 TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "", errout.str()); 3260 } 3261 uninitFunction2()3262 void uninitFunction2() { 3263 check("class Fred\n" 3264 "{\n" 3265 "public:\n" 3266 " Fred() { if (!init(*this)); }\n" 3267 "\n" 3268 " static bool init(Fred &f)\n" 3269 " { f.d = 0; return true; }\n" 3270 "\n" 3271 " double d;\n" 3272 "};"); 3273 ASSERT_EQUALS("", errout.str()); 3274 3275 check("class Fred\n" 3276 "{\n" 3277 "public:\n" 3278 " Fred() { if (!init(*this)); }\n" 3279 "\n" 3280 " static bool init(Fred &f)\n" 3281 " { return true; }\n" 3282 "\n" 3283 " double d;\n" 3284 "};"); 3285 TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "", errout.str()); 3286 } 3287 uninitFunction3()3288 void uninitFunction3() { 3289 check("class Fred\n" 3290 "{\n" 3291 "public:\n" 3292 " Fred() { if (!init()); }\n" 3293 "\n" 3294 " bool init()\n" 3295 " { d = 0; return true; }\n" 3296 "\n" 3297 " double d;\n" 3298 "};"); 3299 ASSERT_EQUALS("", errout.str()); 3300 3301 check("class Fred\n" 3302 "{\n" 3303 "public:\n" 3304 " Fred() { if (!init()); }\n" 3305 "\n" 3306 " bool init()\n" 3307 " { return true; }\n" 3308 "\n" 3309 " double d;\n" 3310 "};"); 3311 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", errout.str()); 3312 } 3313 uninitFunction4()3314 void uninitFunction4() { 3315 check("class Fred\n" 3316 "{\n" 3317 "public:\n" 3318 " Fred() { init(this); }\n" 3319 "\n" 3320 " init(Fred *f)\n" 3321 " { f.d = 0; }\n" 3322 "\n" 3323 " double d;\n" 3324 "};"); 3325 ASSERT_EQUALS("", errout.str()); 3326 3327 check("class Fred\n" 3328 "{\n" 3329 "public:\n" 3330 " Fred() { init(this); }\n" 3331 "\n" 3332 " init(Fred *f)\n" 3333 " { }\n" 3334 "\n" 3335 " double d;\n" 3336 "};"); 3337 TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "", errout.str()); 3338 } 3339 uninitFunction5()3340 void uninitFunction5() { // #4072 - FP about struct that is initialized in function 3341 check("struct Structure {\n" 3342 " int C;\n" 3343 "};\n" 3344 "\n" 3345 "class A {\n" 3346 " Structure B;\n" 3347 "public:\n" 3348 " A() { Init( B ); };\n" 3349 " void Init( Structure& S ) { S.C = 0; };\n" 3350 "};"); 3351 ASSERT_EQUALS("", errout.str()); 3352 } 3353 uninitSameClassName()3354 void uninitSameClassName() { 3355 check("class B\n" 3356 "{\n" 3357 "public:\n" 3358 " B();\n" 3359 " int j;\n" 3360 "};\n" 3361 "\n" 3362 "class A\n" 3363 "{\n" 3364 " class B\n" 3365 " {\n" 3366 " public:\n" 3367 " B();\n" 3368 " int i;\n" 3369 " };\n" 3370 "};\n" 3371 "\n" 3372 "A::B::B()\n" 3373 "{\n" 3374 " i = 0;\n" 3375 "}"); 3376 ASSERT_EQUALS("", errout.str()); 3377 3378 check("class B\n" 3379 "{\n" 3380 "public:\n" 3381 " B();\n" 3382 " int j;\n" 3383 "};\n" 3384 "\n" 3385 "class A\n" 3386 "{\n" 3387 " class B\n" 3388 " {\n" 3389 " public:\n" 3390 " B();\n" 3391 " int i;\n" 3392 " };\n" 3393 "};\n" 3394 "\n" 3395 "B::B()\n" 3396 "{\n" 3397 "}\n" 3398 "\n" 3399 "A::B::B()\n" 3400 "{\n" 3401 "}"); 3402 ASSERT_EQUALS("[test.cpp:18]: (warning) Member variable 'B::j' is not initialized in the constructor.\n" 3403 "[test.cpp:22]: (warning) Member variable 'B::i' is not initialized in the constructor.\n", errout.str()); 3404 3405 // Ticket #1700 3406 check("namespace n1\n" 3407 "{\n" 3408 "class Foo {" 3409 "public:\n" 3410 " Foo() : i(0) { }\n" 3411 "private:\n" 3412 " int i;\n" 3413 "};\n" 3414 "}\n" 3415 "\n" 3416 "namespace n2\n" 3417 "{\n" 3418 "class Foo {" 3419 "public:\n" 3420 " Foo() { }\n" 3421 "};\n" 3422 "}"); 3423 ASSERT_EQUALS("", errout.str()); 3424 3425 check("namespace n1\n" 3426 "{\n" 3427 "class Foo {\n" 3428 "public:\n" 3429 " Foo();\n" 3430 "private:\n" 3431 " int i;\n" 3432 "};\n" 3433 "}\n" 3434 "\n" 3435 "n1::Foo::Foo()\n" 3436 "{ }\n" 3437 "\n" 3438 "namespace n2\n" 3439 "{\n" 3440 "class Foo {\n" 3441 "public:\n" 3442 " Foo() { }\n" 3443 "};\n" 3444 "}"); 3445 ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Foo::i' is not initialized in the constructor.\n", errout.str()); 3446 3447 check("namespace n1\n" 3448 "{\n" 3449 "class Foo {" 3450 "public:\n" 3451 " Foo();\n" 3452 "private:\n" 3453 " int i;\n" 3454 "};\n" 3455 "}\n" 3456 "\n" 3457 "n1::Foo::Foo() : i(0)\n" 3458 "{ }\n" 3459 "\n" 3460 "namespace n2\n" 3461 "{\n" 3462 "class Foo {" 3463 "public:\n" 3464 " Foo() { }\n" 3465 "};\n" 3466 "}"); 3467 ASSERT_EQUALS("", errout.str()); 3468 } 3469 uninitFunctionOverload()3470 void uninitFunctionOverload() { 3471 // Ticket #1783 - overloaded "init" functions 3472 check("class A\n" 3473 "{\n" 3474 "private:\n" 3475 " int i;\n" 3476 "\n" 3477 "public:\n" 3478 " A()\n" 3479 " {\n" 3480 " init();\n" 3481 " }\n" 3482 "\n" 3483 " void init() { init(0); }\n" 3484 "\n" 3485 " void init(int value)\n" 3486 " { i = value; }\n" 3487 "};"); 3488 ASSERT_EQUALS("", errout.str()); 3489 3490 check("class A\n" 3491 "{\n" 3492 "private:\n" 3493 " int i;\n" 3494 "\n" 3495 "public:\n" 3496 " A()\n" 3497 " {\n" 3498 " init();\n" 3499 " }\n" 3500 "\n" 3501 " void init() { init(0); }\n" 3502 "\n" 3503 " void init(int value)\n" 3504 " { }\n" 3505 "};"); 3506 ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::i' is not initialized in the constructor.\n", errout.str()); 3507 } 3508 uninitVarOperatorEqual()3509 void uninitVarOperatorEqual() { // ticket #2415 3510 check("struct A {\n" 3511 " int a;\n" 3512 " A() { a=0; }\n" 3513 " A(A const &a) { operator=(a); }\n" 3514 "};"); 3515 ASSERT_EQUALS("", errout.str()); 3516 3517 check("struct A {\n" 3518 " int a;\n" 3519 " A() { a=0; }\n" 3520 " A(A const &a) { operator=(a); }\n" 3521 " A & operator = (const A & rhs) {\n" 3522 " a = rhs.a;\n" 3523 " return *this;\n" 3524 " }\n" 3525 "};"); 3526 ASSERT_EQUALS("", errout.str()); 3527 3528 check("struct A {\n" 3529 " int a;\n" 3530 " A() { a=0; }\n" 3531 " A(A const &a) { operator=(a); }\n" 3532 " A & operator = (const A & rhs) {\n" 3533 " return *this;\n" 3534 " }\n" 3535 "};"); 3536 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::a' is not initialized in the constructor.\n" 3537 "[test.cpp:5]: (warning) Member variable 'A::a' is not assigned a value in 'A::operator='.\n", errout.str()); 3538 } 3539 uninitVarPointer()3540 void uninitVarPointer() { // #3801 3541 check("struct A {\n" 3542 " int a;\n" 3543 "};\n" 3544 "struct B {\n" 3545 " A* a;\n" 3546 " B() { }\n" 3547 "};"); 3548 ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3549 3550 check("struct A;\n" 3551 "struct B {\n" 3552 " A* a;\n" 3553 " B() { }\n" 3554 "};"); 3555 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3556 3557 check("struct A;\n" 3558 "struct B {\n" 3559 " const A* a;\n" 3560 " B() { }\n" 3561 "};"); 3562 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3563 3564 check("struct A;\n" 3565 "struct B {\n" 3566 " A* const a;\n" 3567 " B() { }\n" 3568 "};"); 3569 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3570 } 3571 uninitConstVar()3572 void uninitConstVar() { 3573 check("struct A;\n" 3574 "struct B {\n" 3575 " A* const a;\n" 3576 " B() { }\n" 3577 " B(B& b) { }\n" 3578 "};"); 3579 ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n" 3580 "[test.cpp:5]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3581 3582 check("struct A;\n" 3583 "struct B {\n" 3584 " A* const a;\n" 3585 " B& operator=(const B& r) { }\n" 3586 "};"); 3587 ASSERT_EQUALS("", errout.str()); // #3804 3588 3589 check("struct B {\n" 3590 " const int a;\n" 3591 " B() { }\n" 3592 " B(B& b) { }\n" 3593 "};"); 3594 ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'B::a' is not initialized in the constructor.\n" 3595 "[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str()); 3596 3597 check("struct B {\n" 3598 " const int a;\n" 3599 " B& operator=(const B& r) { }\n" 3600 "};"); 3601 ASSERT_EQUALS("", errout.str()); 3602 } 3603 3604 // Ticket #5641 "Regression. Crash for 'C() _STLP_NOTHROW {}'" constructors_crash1()3605 void constructors_crash1() { 3606 check("class C {\n" 3607 "public:\n" 3608 " C() _STLP_NOTHROW {}\n" 3609 " C(const C&) _STLP_NOTHROW {}\n" 3610 "};"); 3611 ASSERT_EQUALS("", errout.str()); 3612 } 3613 classWithOperatorInName()3614 void classWithOperatorInName() { // ticket #2827 3615 check("class operatorX {\n" 3616 " int mValue;\n" 3617 "public:\n" 3618 " operatorX() : mValue(0) {}\n" 3619 "};"); 3620 ASSERT_EQUALS("", errout.str()); 3621 } 3622 templateConstructor()3623 void templateConstructor() { // ticket #7942 3624 check("template <class T> struct Container {\n" 3625 " Container();\n" 3626 " T* mElements;\n" 3627 "};\n" 3628 "template <class T> Container<T>::Container() : mElements(nullptr) {}\n" 3629 "Container<int> intContainer;"); 3630 ASSERT_EQUALS("", errout.str()); 3631 } 3632 typedefArray()3633 void typedefArray() { // ticket #5766 3634 check("typedef float rvec[3];\n" 3635 "class SelectionPosition {\n" 3636 "public:\n" 3637 " SelectionPosition() {}\n" 3638 " const rvec &x() const;\n" 3639 "};"); 3640 ASSERT_EQUALS("", errout.str()); 3641 } 3642 uninitAssignmentWithOperator()3643 void uninitAssignmentWithOperator() { 3644 check("struct C {\n" 3645 " int x;\n" 3646 " C() {\n" 3647 " bool b = false;\n" 3648 " b = b && SetValue();\n" 3649 " }\n" 3650 " bool SetValue() {\n" 3651 " x = 1;\n" 3652 " return true;\n" 3653 " }\n" 3654 "};", true); 3655 TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n", 3656 "[test.cpp:3]: (warning) Member variable 'C::x' is not initialized in the constructor.\n", errout.str()); 3657 3658 check("struct C {\n" 3659 " int x;\n" 3660 " C() {\n" 3661 " bool b = false;\n" 3662 " b = true || SetValue();\n" 3663 " }\n" 3664 " bool SetValue() {\n" 3665 " x = 1;\n" 3666 " return true;\n" 3667 " }\n" 3668 "};", true); 3669 TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n", 3670 "[test.cpp:3]: (warning) Member variable 'C::x' is not initialized in the constructor.\n", errout.str()); 3671 3672 check("struct C {\n" 3673 " int x;\n" 3674 " C() {\n" 3675 " bool b = true;\n" 3676 " b = b & SetValue();\n" 3677 " }\n" 3678 " bool SetValue() {\n" 3679 " x = 1;\n" 3680 " return true;\n" 3681 " }\n" 3682 "};"); 3683 ASSERT_EQUALS("", errout.str()); 3684 3685 check("struct C {\n" 3686 " int x;\n" 3687 " C() {\n" 3688 " bool b = false;\n" 3689 " b = true | SetValue();\n" 3690 " }\n" 3691 " bool SetValue() {\n" 3692 " x = 1;\n" 3693 " return true;\n" 3694 " }\n" 3695 "};"); 3696 ASSERT_EQUALS("", errout.str()); 3697 3698 check("struct C {\n" 3699 " int x;\n" 3700 " C() {\n" 3701 " int i = 0;\n" 3702 " i = i * SetValue();\n" 3703 " }\n" 3704 " int SetValue() { return x = 1; }\n" 3705 "};"); 3706 ASSERT_EQUALS("", errout.str()); 3707 3708 check("struct C {\n" 3709 " int x;\n" 3710 " C() {\n" 3711 " int i = 0;\n" 3712 " i = i / SetValue();\n" 3713 " }\n" 3714 " int SetValue() { return x = 1; }\n" 3715 "};"); 3716 ASSERT_EQUALS("", errout.str()); 3717 3718 check("struct C {\n" 3719 " int x;\n" 3720 " C() {\n" 3721 " int i = 0;\n" 3722 " i = i % SetValue();\n" 3723 " }\n" 3724 " int SetValue() { return x = 1; }\n" 3725 "};"); 3726 ASSERT_EQUALS("", errout.str()); 3727 3728 check("struct C {\n" 3729 " int x;\n" 3730 " C() {\n" 3731 " int i = 0;\n" 3732 " i = i + SetValue();\n" 3733 " }\n" 3734 " int SetValue() { return x = 1; }\n" 3735 "};"); 3736 ASSERT_EQUALS("", errout.str()); 3737 3738 check("struct C {\n" 3739 " int x;\n" 3740 " C() {\n" 3741 " int i = 0;\n" 3742 " i = i - SetValue();\n" 3743 " }\n" 3744 " int SetValue() { return x = 1; }\n" 3745 "};"); 3746 ASSERT_EQUALS("", errout.str()); 3747 3748 check("struct C {\n" 3749 " int x;\n" 3750 " C() {\n" 3751 " int i = 0;\n" 3752 " i = i << SetValue();\n" 3753 " }\n" 3754 " int SetValue() { return x = 1; }\n" 3755 "};"); 3756 ASSERT_EQUALS("", errout.str()); 3757 3758 check("struct C {\n" 3759 " int x;\n" 3760 " C() {\n" 3761 " int i = 0;\n" 3762 " i = i >> SetValue();\n" 3763 " }\n" 3764 " int SetValue() { return x = 1; }\n" 3765 "};"); 3766 ASSERT_EQUALS("", errout.str()); 3767 3768 check("struct C {\n" 3769 " int x;\n" 3770 " C() {\n" 3771 " int i = 0;\n" 3772 " i = i ^ SetValue();\n" 3773 " }\n" 3774 " int SetValue() { return x = 1; }\n" 3775 "};"); 3776 ASSERT_EQUALS("", errout.str()); 3777 } 3778 uninitCompoundAssignment()3779 void uninitCompoundAssignment() { 3780 check("struct C {\n" 3781 " int x;\n" 3782 " C() {\n" 3783 " bool b = true;\n" 3784 " b &= SetValue();\n" 3785 " }\n" 3786 " bool SetValue() {\n" 3787 " x = 1;\n" 3788 " return true;\n" 3789 " }\n" 3790 "};"); 3791 ASSERT_EQUALS("", errout.str()); 3792 3793 check("struct C {\n" 3794 " int x;\n" 3795 " C() {\n" 3796 " bool b = false;\n" 3797 " b |= SetValue();\n" 3798 " }\n" 3799 " bool SetValue() {\n" 3800 " x = 1;\n" 3801 " return true;\n" 3802 " }\n" 3803 "};"); 3804 ASSERT_EQUALS("", errout.str()); 3805 3806 check("struct C {\n" 3807 " int x;\n" 3808 " C() {\n" 3809 " int i = 0;\n" 3810 " i *= SetValue();\n" 3811 " }\n" 3812 " int SetValue() { return x = 1; }\n" 3813 "};"); 3814 ASSERT_EQUALS("", errout.str()); 3815 3816 check("struct C {\n" 3817 " int x;\n" 3818 " C() {\n" 3819 " int i = 0;\n" 3820 " i /= SetValue();\n" 3821 " }\n" 3822 " int SetValue() { return x = 1; }\n" 3823 "};"); 3824 ASSERT_EQUALS("", errout.str()); 3825 3826 check("struct C {\n" 3827 " int x;\n" 3828 " C() {\n" 3829 " int i = 0;\n" 3830 " i %= SetValue();\n" 3831 " }\n" 3832 " int SetValue() { return x = 1; }\n" 3833 "};"); 3834 ASSERT_EQUALS("", errout.str()); 3835 3836 check("struct C {\n" 3837 " int x;\n" 3838 " C() {\n" 3839 " int i = 0;\n" 3840 " i += SetValue();\n" 3841 " }\n" 3842 " int SetValue() { return x = 1; }\n" 3843 "};"); 3844 ASSERT_EQUALS("", errout.str()); 3845 3846 check("struct C {\n" 3847 " int x;\n" 3848 " C() {\n" 3849 " int i = 0;\n" 3850 " i -= SetValue();\n" 3851 " }\n" 3852 " int SetValue() { return x = 1; }\n" 3853 "};"); 3854 ASSERT_EQUALS("", errout.str()); 3855 3856 check("struct C {\n" 3857 " int x;\n" 3858 " C() {\n" 3859 " int i = 0;\n" 3860 " i <<= SetValue();\n" 3861 " }\n" 3862 " int SetValue() { return x = 1; }\n" 3863 "};"); 3864 ASSERT_EQUALS("", errout.str()); 3865 3866 check("struct C {\n" 3867 " int x;\n" 3868 " C() {\n" 3869 " int i = 0;\n" 3870 " i >>= SetValue();\n" 3871 " }\n" 3872 " int SetValue() { return x = 1; }\n" 3873 "};"); 3874 ASSERT_EQUALS("", errout.str()); 3875 3876 check("struct C {\n" 3877 " int x;\n" 3878 " C() {\n" 3879 " int i = 0;\n" 3880 " i ^= SetValue();\n" 3881 " }\n" 3882 " int SetValue() { return x = 1; }\n" 3883 "};"); 3884 ASSERT_EQUALS("", errout.str()); 3885 } 3886 uninitComparisonAssignment()3887 void uninitComparisonAssignment() { 3888 check("struct C {\n" 3889 " int x;\n" 3890 " C() {\n" 3891 " bool b = true;\n" 3892 " b = (true == SetValue());\n" 3893 " }\n" 3894 " bool SetValue() {\n" 3895 " x = 1;\n" 3896 " return true;\n" 3897 " }\n" 3898 "};"); 3899 ASSERT_EQUALS("", errout.str()); 3900 3901 check("struct C {\n" 3902 " int x;\n" 3903 " C() {\n" 3904 " bool b = false;\n" 3905 " b |= (true != SetValue());\n" 3906 " }\n" 3907 " bool SetValue() {\n" 3908 " x = 1;\n" 3909 " return true;\n" 3910 " }\n" 3911 "};"); 3912 ASSERT_EQUALS("", errout.str()); 3913 3914 check("struct C {\n" 3915 " int x;\n" 3916 " C() {\n" 3917 " bool b = (0 < SetValue());\n" 3918 " }\n" 3919 " int SetValue() { return x = 1; }\n" 3920 "};"); 3921 ASSERT_EQUALS("", errout.str()); 3922 3923 check("struct C {\n" 3924 " int x;\n" 3925 " C() {\n" 3926 " bool b = (0 <= SetValue());\n" 3927 " }\n" 3928 " int SetValue() { return x = 1; }\n" 3929 "};"); 3930 ASSERT_EQUALS("", errout.str()); 3931 3932 check("struct C {\n" 3933 " int x;\n" 3934 " C() {\n" 3935 " bool b = (0 > SetValue());\n" 3936 " }\n" 3937 " int SetValue() { return x = 1; }\n" 3938 "};"); 3939 ASSERT_EQUALS("", errout.str()); 3940 3941 check("struct C {\n" 3942 " int x;\n" 3943 " C() {\n" 3944 " bool b = (0 >= SetValue());\n" 3945 " }\n" 3946 " int SetValue() { return x = 1; }\n" 3947 "};"); 3948 ASSERT_EQUALS("", errout.str()); 3949 } 3950 uninitTemplate1()3951 void uninitTemplate1() { 3952 check("template <class A, class T> class C;\n" 3953 "template <class A>\n" 3954 "class C<A, void> {\n" 3955 " public:\n" 3956 " C() : b(0) { }\n" 3957 " C(A* a) : b(a) { }\n" 3958 " private:\n" 3959 " A* b;\n" 3960 "};\n" 3961 "template <class A, class T>\n" 3962 "class C {\n" 3963 " private:\n" 3964 " A* b;\n" 3965 "};"); 3966 ASSERT_EQUALS("", errout.str()); 3967 3968 check("template<class T> class A{};\n" 3969 "template<class T1, class T2> class B{};\n" 3970 "template<class T1, class T2>\n" 3971 "class A<B<T1, T2>> {\n" 3972 " public:\n" 3973 " A();\n" 3974 " bool m_value;\n" 3975 "};\n" 3976 "template<class T1, class T2>\n" 3977 "A<B<T1, T2>>::A() : m_value(false) {}"); 3978 ASSERT_EQUALS("", errout.str()); 3979 } 3980 unknownTemplateType()3981 void unknownTemplateType() { 3982 check("template <typename T> class A {\n" 3983 "private:\n" 3984 " T m;\n" 3985 "public:\n" 3986 " A& operator=() { return *this; }\n" 3987 "};\n" 3988 "A<decltype(SOMETHING)> a;"); 3989 ASSERT_EQUALS("", errout.str()); 3990 } 3991 3992 }; 3993 3994 REGISTER_TEST(TestConstructors) 3995