/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2025 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "check.h"

#include "checkclass.h"

#include "ctu.h"

#include "errortypes.h"

#include "fixture.h"

#include "helpers.h"

#include "settings.h"

#include "tokenize.h"

#include "tokenlist.h"

#include <cstddef>

#include <list>

#include <sstream>

#include <string>

#include <vector>

class TestClass : public TestFixture {

public:

TestClass() : TestFixture("TestClass") {}

private:

const Settings settings0 = settingsBuilder().severity(Severity::style).library("std.cfg").build();

const Settings settings1 = settingsBuilder().severity(Severity::warning).library("std.cfg").build();

const Settings settings2 = settingsBuilder().severity(Severity::style).library("std.cfg").certainty(Certainty::inconclusive).build();

const Settings settings3 = settingsBuilder().severity(Severity::style).library("std.cfg").severity(Severity::warning).build();

void run() override {

TEST_CASE(virtualDestructor1); // Base class not found => no error

TEST_CASE(virtualDestructor2); // Base class doesn't have a destructor

TEST_CASE(virtualDestructor3); // Base class has a destructor, but it's not virtual

TEST_CASE(virtualDestructor4); // Derived class doesn't have a destructor => no error

TEST_CASE(virtualDestructor5); // Derived class has empty destructor => no error

TEST_CASE(virtualDestructor6); // only report error if base class pointer that points at derived class is deleted

TEST_CASE(virtualDestructorProtected);

TEST_CASE(virtualDestructorInherited);

TEST_CASE(virtualDestructorTemplate);

TEST_CASE(virtualDestructorInconclusive); // ticket # 5807

TEST_CASE(copyConstructor1);

TEST_CASE(copyConstructor2); // ticket #4458

TEST_CASE(copyConstructor3); // defaulted/deleted

TEST_CASE(copyConstructor4); // base class with private constructor

TEST_CASE(copyConstructor5); // multiple inheritance

TEST_CASE(copyConstructor6); // array of pointers

TEST_CASE(noOperatorEq); // class with memory management should have operator eq

TEST_CASE(noDestructor); // class with memory management should have destructor

TEST_CASE(operatorEqRetRefThis1);

TEST_CASE(operatorEqRetRefThis2); // ticket #1323

TEST_CASE(operatorEqRetRefThis3); // ticket #1405

TEST_CASE(operatorEqRetRefThis4); // ticket #1451

TEST_CASE(operatorEqRetRefThis5); // ticket #1550

TEST_CASE(operatorEqRetRefThis6); // ticket #2479

TEST_CASE(operatorEqRetRefThis7); // ticket #5782 endless recursion

TEST_CASE(operatorEqToSelf1); // single class

TEST_CASE(operatorEqToSelf2); // nested class

TEST_CASE(operatorEqToSelf3); // multiple inheritance

TEST_CASE(operatorEqToSelf4); // nested class with multiple inheritance

TEST_CASE(operatorEqToSelf5); // ticket # 1233

TEST_CASE(operatorEqToSelf6); // ticket # 1550

TEST_CASE(operatorEqToSelf7);

TEST_CASE(operatorEqToSelf8); // ticket #2179

TEST_CASE(operatorEqToSelf9); // ticket #2592

TEST_CASE(memsetOnStruct);

TEST_CASE(memsetVector);

TEST_CASE(memsetOnClass);

TEST_CASE(memsetOnInvalid); // Ticket #5425: Crash upon invalid

TEST_CASE(memsetOnStdPodType); // Ticket #5901 - std::uint8_t

TEST_CASE(memsetOnFloat); // Ticket #5421

TEST_CASE(memsetOnUnknown); // Ticket #7183

TEST_CASE(mallocOnClass);

TEST_CASE(this_subtraction); // warn about "this-x"

// can member function be made const

TEST_CASE(const1);

TEST_CASE(const2);

TEST_CASE(const3);

TEST_CASE(const4);

TEST_CASE(const5); // ticket #1482

TEST_CASE(const6); // ticket #1491

TEST_CASE(const7);

TEST_CASE(const8); // ticket #1517

TEST_CASE(const9); // ticket #1515

TEST_CASE(const10); // ticket #1522

TEST_CASE(const11); // ticket #1529

TEST_CASE(const12); // ticket #1552

TEST_CASE(const13); // ticket #1519

TEST_CASE(const14);

TEST_CASE(const15);

TEST_CASE(const16); // ticket #1551

TEST_CASE(const17); // ticket #1552

TEST_CASE(const18);

TEST_CASE(const19); // ticket #1612

TEST_CASE(const20); // ticket #1602

TEST_CASE(const21); // ticket #1683

TEST_CASE(const22);

TEST_CASE(const23); // ticket #1699

TEST_CASE(const24); // ticket #1708

TEST_CASE(const25); // ticket #1724

TEST_CASE(const26); // ticket #1847

TEST_CASE(const27); // ticket #1882

TEST_CASE(const28); // ticket #1883

TEST_CASE(const29); // ticket #1922

TEST_CASE(const30);

TEST_CASE(const31);

TEST_CASE(const32); // ticket #1905 - member array is assigned

TEST_CASE(const33);

TEST_CASE(const34); // ticket #1964

TEST_CASE(const35); // ticket #2001

TEST_CASE(const36); // ticket #2003

TEST_CASE(const37); // ticket #2081 and #2085

TEST_CASE(const38); // ticket #2135

TEST_CASE(const39);

TEST_CASE(const40); // ticket #2228

TEST_CASE(const41); // ticket #2255

TEST_CASE(const42); // ticket #2282

TEST_CASE(const43); // ticket #2377

TEST_CASE(const44); // ticket #2595

TEST_CASE(const45); // ticket #2664

TEST_CASE(const46); // ticket #2636

TEST_CASE(const47); // ticket #2670

TEST_CASE(const48); // ticket #2672

TEST_CASE(const49); // ticket #2795

TEST_CASE(const50); // ticket #2943

TEST_CASE(const51); // ticket #3040

TEST_CASE(const52); // ticket #3048

TEST_CASE(const53); // ticket #3049

TEST_CASE(const54); // ticket #3052

TEST_CASE(const55);

TEST_CASE(const56); // ticket #3149

TEST_CASE(const57); // tickets #2669 and #2477

TEST_CASE(const58); // ticket #2698

TEST_CASE(const59); // ticket #4646

TEST_CASE(const60); // ticket #3322

TEST_CASE(const61); // ticket #5606

TEST_CASE(const62); // ticket #5701

TEST_CASE(const63); // ticket #5983

TEST_CASE(const64); // ticket #6268

TEST_CASE(const65); // ticket #8693

TEST_CASE(const66); // ticket #7714

TEST_CASE(const67); // ticket #9193

TEST_CASE(const68); // ticket #6471

TEST_CASE(const69); // ticket #9806

TEST_CASE(const70); // variadic template can receive more arguments than in its definition

TEST_CASE(const71); // ticket #10146

TEST_CASE(const72); // ticket #10520

TEST_CASE(const73); // ticket #10735

TEST_CASE(const74); // ticket #10671

TEST_CASE(const75); // ticket #10065

TEST_CASE(const76); // ticket #10825

TEST_CASE(const77); // ticket #10307, #10311

TEST_CASE(const78); // ticket #10315

TEST_CASE(const79); // ticket #9861

TEST_CASE(const80); // ticket #11328

TEST_CASE(const81); // ticket #11330

TEST_CASE(const82); // ticket #11513

TEST_CASE(const83);

TEST_CASE(const84);

TEST_CASE(const85);

TEST_CASE(const86);

TEST_CASE(const87);

TEST_CASE(const88);

TEST_CASE(const89);

TEST_CASE(const90);

TEST_CASE(const91);

TEST_CASE(const92);

TEST_CASE(const93);

TEST_CASE(const94);

TEST_CASE(const95); // #13320 - do not warn about r-value ref method

TEST_CASE(const96);

TEST_CASE(const97);

TEST_CASE(const98);

TEST_CASE(const_handleDefaultParameters);

TEST_CASE(const_passThisToMemberOfOtherClass);

TEST_CASE(assigningPointerToPointerIsNotAConstOperation);

TEST_CASE(assigningArrayElementIsNotAConstOperation);

TEST_CASE(constoperator1); // operator< can often be const

TEST_CASE(constoperator2); // operator<<

TEST_CASE(constoperator3);

TEST_CASE(constoperator4);

TEST_CASE(constoperator5); // ticket #3252

TEST_CASE(constoperator6); // ticket #8669

TEST_CASE(constincdec); // increment/decrement => non-const

TEST_CASE(constassign1);

TEST_CASE(constassign2);

TEST_CASE(constincdecarray); // increment/decrement array element => non-const

TEST_CASE(constassignarray);

TEST_CASE(constReturnReference);

TEST_CASE(constDelete); // delete member variable => not const

TEST_CASE(constLPVOID); // a function that returns LPVOID can't be const

TEST_CASE(constFunc); // a function that calls const functions can be const

TEST_CASE(constVirtualFunc);

TEST_CASE(constIfCfg); // ticket #1881 - fp when there are #if

TEST_CASE(constFriend); // ticket #1921 - fp for friend function

TEST_CASE(constUnion); // ticket #2111 - fp when there is a union

TEST_CASE(constArrayOperator); // #4406

TEST_CASE(constRangeBasedFor); // #5514

TEST_CASE(const_shared_ptr);

TEST_CASE(constPtrToConstPtr);

TEST_CASE(constTrailingReturnType);

TEST_CASE(constRefQualified);

TEST_CASE(staticArrayPtrOverload);

TEST_CASE(qualifiedNameMember); // #10872

TEST_CASE(initializerListOrder);

TEST_CASE(initializerListArgument);

TEST_CASE(initializerListUsage);

TEST_CASE(selfInitialization);

TEST_CASE(virtualFunctionCallInConstructor);

TEST_CASE(pureVirtualFunctionCall);

TEST_CASE(pureVirtualFunctionCallOtherClass);

TEST_CASE(pureVirtualFunctionCallWithBody);

TEST_CASE(pureVirtualFunctionCallPrevented);

TEST_CASE(duplInheritedMembers);

TEST_CASE(explicitConstructors);

TEST_CASE(copyCtorAndEqOperator);

TEST_CASE(override1);

TEST_CASE(overrideCVRefQualifiers);

TEST_CASE(uselessOverride);

TEST_CASE(thisUseAfterFree);

TEST_CASE(unsafeClassRefMember);

TEST_CASE(ctuOneDefinitionRule);

TEST_CASE(testGetFileInfo);

TEST_CASE(returnByReference);

}

#define checkCopyCtorAndEqOperator(...) checkCopyCtorAndEqOperator_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkCopyCtorAndEqOperator_(const char* file, int line, const char (&code)[size]) {

const Settings settings = settingsBuilder().severity(Severity::warning).build();

// Tokenize..

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

CheckClass checkClass(&tokenizer, &settings, this);

(checkClass.checkCopyCtorAndEqOperator)();

}

void copyCtorAndEqOperator() {

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A(const A& other) { }\n"

" A& operator=(const A& other) { return *this; }\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyCtorAndEqOperator("class A\n"

"{\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A(const A& other) { }\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A& operator=(const A& other) { return *this; }\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A(const A& other) { }\n"

" int x;\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'copy constructor' but lack of 'operator='.\n", "", errout_str());

// TODO the error message should be clarified. It should say something like 'copy constructor is empty and will not assign i and therefore the behaviour is different to the default assignment operator'

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A& operator=(const A& other) { return *this; }\n"

" int x;\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'operator=' but lack of 'copy constructor'.\n", "", errout_str());

// TODO the error message should be clarified. It should say something like 'assignment operator does not assign i and therefore the behaviour is different to the default copy constructor'

checkCopyCtorAndEqOperator("class A\n"

"{\n"

" A& operator=(const int &x) { this->x = x; return *this; }\n"

" int x;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyCtorAndEqOperator("class A {\n"

"public:\n"

" A() : x(0) { }\n"

" A(const A & a) { x = a.x; }\n"

" A & operator = (const A & a) {\n"

" x = a.x;\n"

" return *this;\n"

" }\n"

"private:\n"

" int x;\n"

"};\n"

"class B : public A {\n"

"public:\n"

" B() { }\n"

" B(const B & b) :A(b) { }\n"

"private:\n"

" static int i;\n"

"};");

ASSERT_EQUALS("", errout_str());

// #7987 - Don't show warning when there is a move constructor

checkCopyCtorAndEqOperator("struct S {\n"

" std::string test;\n"

" S(S&& s) : test(std::move(s.test)) { }\n"

" S& operator = (S &&s) {\n"

" test = std::move(s.test);\n"

" return *this;\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

// #8337 - False positive in copy constructor detection

checkCopyCtorAndEqOperator("struct StaticListNode {\n"

" StaticListNode(StaticListNode*& prev) : m_next(0) {}\n"

" StaticListNode* m_next;\n"

"};");

ASSERT_EQUALS("", errout_str());

}

#define checkExplicitConstructors(...) checkExplicitConstructors_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkExplicitConstructors_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings0, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

CheckClass checkClass(&tokenizer, &settings0, this);

(checkClass.checkExplicitConstructors)();

}

void explicitConstructors() {

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

" Class(const Class& other) { }\n"

" Class(Class&& other) { }\n"

" explicit Class(int i) { }\n"

" explicit Class(const std::string&) { }\n"

" Class(int a, int b) { }\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

" explicit Class(const Class& other) { }\n"

" explicit Class(Class&& other) { }\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Class {\n"

" Class() = delete;\n"

" Class(const Class& other) = delete;\n"

" Class(Class&& other) = delete;\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Class {\n"

" Class(int i) { }\n"

"};");

ASSERT_EQUALS("[test.cpp:2]: (style) Class 'Class' has a constructor with 1 argument that is not explicit.\n", errout_str());

checkExplicitConstructors("class Class {\n"

" Class(const Class& other) { }\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Class {\n"

" Class(Class&& other) { }\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

// #6585

checkExplicitConstructors("class Class {\n"

" private: Class(const Class&);\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Class {\n"

" public: Class(const Class&);\n"

" virtual int i() = 0;\n"

"};");

ASSERT_EQUALS("", errout_str());

// #7465: Error properly reported in templates

checkExplicitConstructors("template <class T> struct Test {\n"

" Test(int) : fData(0) {}\n"

" T fData;\n"

"};\n"

"int main() {\n"

" Test <int> test;\n"

" return 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:2]: (style) Struct 'Test < int >' has a constructor with 1 argument that is not explicit.\n", errout_str());

// #7465: No error for copy or move constructors

checkExplicitConstructors("template <class T> struct Test {\n"

" Test() : fData(0) {}\n"

" Test (const Test<T>& aOther) : fData(aOther.fData) {}\n"

" Test (Test<T>&& aOther) : fData(std::move(aOther.fData)) {}\n"

" T fData;\n"

"};\n"

"int main() {\n"

" Test <int> test;\n"

" return 0;\n"

"}");

ASSERT_EQUALS("", errout_str());

// #8600

checkExplicitConstructors("struct A { struct B; };\n"

"struct A::B {\n"

" B() = default;\n"

" B(const B&) {}\n"

"};");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("struct A{"

" A(int, int y=2) {}"

"};");

ASSERT_EQUALS("[test.cpp:1]: (style) Struct 'A' has a constructor with 1 argument that is not explicit.\n", errout_str());

checkExplicitConstructors("struct Foo {\n" // #10515

" template <typename T>\n"

" explicit constexpr Foo(T) {}\n"

"};\n"

"struct Bar {\n"

" template <typename T>\n"

" constexpr explicit Bar(T) {}\n"

"};\n"

"struct Baz {\n"

" explicit constexpr Baz(int) {}\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Token;\n" // #11126

"struct Branch {\n"

" Branch(Token* tok = nullptr) : endBlock(tok) {}\n"

" Token* endBlock = nullptr;\n"

"};\n");

ASSERT_EQUALS("[test.cpp:3]: (style) Struct 'Branch' has a constructor with 1 argument that is not explicit.\n", errout_str());

checkExplicitConstructors("struct S {\n"

" S(std::initializer_list<int> il) : v(il) {}\n"

" std::vector<int> v;\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("template<class T>\n" // #10977

"struct A {\n"

" template<class... Ts>\n"

" A(Ts&&... ts) {}\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkExplicitConstructors("class Color {\n" // #7176

"public:\n"

" Color(unsigned int rgba);\n"

" Color(std::uint8_t r = 0, std::uint8_t g = 0, std::uint8_t b = 0, std::uint8_t a = 255);\n"

"};\n");

ASSERT_EQUALS("[test.cpp:3]: (style) Class 'Color' has a constructor with 1 argument that is not explicit.\n"

"[test.cpp:4]: (style) Class 'Color' has a constructor with 1 argument that is not explicit.\n",

errout_str());

}

#define checkDuplInheritedMembers(...) checkDuplInheritedMembers_( __FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkDuplInheritedMembers_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings1, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

CheckClass checkClass(&tokenizer, &settings1, this);

(checkClass.checkDuplInheritedMembers)();

}

void duplInheritedMembers() {

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int x;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("class Base {\n"

" protected:\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout_str());

checkDuplInheritedMembers("class Base {\n"

" protected:\n"

" int x;\n"

"};\n"

"struct Derived : public Base {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout_str());

checkDuplInheritedMembers("class Base0 {\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("class Base0 {\n"

" protected:\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:9]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n", errout_str());

checkDuplInheritedMembers("class Base0 {\n"

" protected:\n"

" int x;\n"

"};\n"

"class Base1 {\n"

" public:\n"

" int x;\n"

"};\n"

"struct Derived : Base0, Base1 {\n"

" int x;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n"

"[test.cpp:7] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base1'.\n", errout_str());

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"struct Derived : Base {\n"

" int y;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("class A {\n"

" int x;\n"

"};\n"

"struct B {\n"

" int x;\n"

"};");

ASSERT_EQUALS("", errout_str());

// Unknown 'Base' class

checkDuplInheritedMembers("class Derived : public UnknownBase {\n"

" int x;\n"

"};");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("class Base {\n"

" int x;\n"

"};\n"

"class Derived : public Base {\n"

"};");

ASSERT_EQUALS("", errout_str());

// #6692

checkDuplInheritedMembers("namespace test1 {\n"

" struct SWibble{};\n"

" typedef SWibble wibble;\n"

"}\n"

"namespace test2 {\n"

" struct SWibble : public test1::wibble {\n"

" int Value;\n"

" };\n"

"}");

ASSERT_EQUALS("", errout_str());

// #9957

checkDuplInheritedMembers("class Base {\n"

" public:\n"

" int i;\n"

"};\n"

"class Derived1: public Base {\n"

" public:\n"

" int j;\n"

"};\n"

"class Derived2 : public Derived1 {\n"

" int i;\n"

"};");

ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:10]: (warning) The class 'Derived2' defines member variable with name 'i' also defined in its parent class 'Base'.\n", errout_str());

// don't crash on recursive template

checkDuplInheritedMembers("template<size_t N>\n"

"struct BitInt : public BitInt<N+1> { };");

ASSERT_EQUALS("", errout_str());

// don't crash on recursive template

checkDuplInheritedMembers("namespace _impl {\n"

" template <typename AlwaysVoid, typename>\n"

" struct fn_traits;\n"

"}\n"

"template <typename T>\n"

"struct function_traits\n"

" : public _impl::fn_traits<void, std::remove_reference_t<T>> {};\n"

"namespace _impl {\n"

" template <typename T>\n"

" struct fn_traits<decltype(void(&T::operator())), T>\n"

" : public fn_traits<void, decltype(&T::operator())> {};\n"

"}");

ASSERT_EQUALS("", errout_str());

// #10594

checkDuplInheritedMembers("template<int i> struct A { bool a = true; };\n"

"struct B { bool a; };\n"

"template<> struct A<1> : B {};\n");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("struct B {\n"

" int g() const;\n"

" virtual int f() const { return g(); }\n"

"};\n"

"struct D : B {\n"

" int g() const;\n"

" int f() const override { return g(); }\n"

"};\n");

ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:6]: (warning) The struct 'D' defines member function with name 'g' also defined in its parent struct 'B'.\n",

errout_str());

checkDuplInheritedMembers("struct B {\n"

" int g() const;\n"

"};\n"

"struct D : B {\n"

" int g(int) const;\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("struct S {\n"

" struct T {\n"

" T() {}\n"

" };\n"

"};\n"

"struct T : S::T {\n"

" T() : S::T() {}\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("struct S {};\n" // #11827

"struct SPtr {\n"

" virtual S* operator->() const { return p; }\n"

" S* p = nullptr;\n"

"};\n"

"struct T : public S {};\n"

"struct TPtr : public SPtr {\n"

" T* operator->() const { return (T*)p; }\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("struct B { virtual int& get() = 0; };\n" // #12311

"struct D : B {\n"

" int i{};\n"

" int& get() override { return i; }\n"

" const int& get() const { return i; }\n"

"};\n");

ASSERT_EQUALS("", errout_str());

checkDuplInheritedMembers("class Base {\n" // #12353

" public:\n"

" void One();\n"

" void Two();\n"

"};\n"

"class Derived : public Base {\n"

"public:\n"

" void Two() = delete;\n"

"};\n");

ASSERT_EQUALS("", errout_str());

}

#define checkCopyConstructor(...) checkCopyConstructor_( __FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void checkCopyConstructor_(const char* file, int line, const char (&code)[size]) {

// Tokenize..

SimpleTokenizer tokenizer(settings3, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

CheckClass checkClass(&tokenizer, &settings3, this);

checkClass.copyconstructors();

}

void copyConstructor1() {

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(const F &f) : p(f.p), c(f.c)\n"

" {\n"

" p=(char *)malloc(strlen(f.p)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" F(char *str)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,str);\n"

" }\n"

" F&operator=(const F&);\n"

" ~F();\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n", "", errout_str());

checkCopyConstructor("class F {\n"

" char *p;\n"

" F(const F &f) {\n"

" p = f.p;\n"

" }\n"

" F(char *str) {\n"

" p = malloc(strlen(str)+1);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

"[test.cpp:3] -> [test.cpp:7]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",

"[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

, errout_str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(const F &f) :p(f.p)\n"

" {\n"

" }\n"

" F(char *str)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,str);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"

"[test.cpp:5] -> [test.cpp:10]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",

""

, errout_str());

checkCopyConstructor("class kalci\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" kalci()\n"

" {\n"

" p=(char *)malloc(100);\n"

" strcpy(p,\"hello\");\n"

" c=(char *)malloc(100);\n"

" strcpy(p,\"hello\");\n"

" d=(char *)malloc(100);\n"

" strcpy(p,\"hello\");\n"

" }\n"

" kalci(const kalci &f)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" d=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" ~kalci();\n"

" kalci& operator=(const kalci&kalci);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F(char *str,char *st,char *string)\n"

" {\n"

" p=(char *)malloc(100);\n"

" strcpy(p,str);\n"

" c=(char *)malloc(100);\n"

" strcpy(p,st);\n"

" d=(char *)malloc(100);\n"

" strcpy(p,string);\n"

" }\n"

" F(const F &f)\n"

" {\n"

" p=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(p,f.p);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:14] -> [test.cpp:11]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());

checkCopyConstructor("class F {\n"

" char *c;\n"

" F(char *str,char *st,char *string) {\n"

" p=(char *)malloc(100);\n"

" }\n"

" F(const F &f)\n"

" : p(malloc(size))\n"

" {\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class F {\n"

" char *c;\n"

" F(char *str,char *st,char *string)\n"

" : p(malloc(size))\n"

" {\n"

" }\n"

" F(const F &f)\n"

" {\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c,*p,*d;\n"

" F()\n"

" {\n"

" p=(char *)malloc(100);\n"

" c=(char *)malloc(100);\n"

" d=(char*)malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

TODO_ASSERT_EQUALS("[test.cpp:8]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", "", errout_str());

checkCopyConstructor("class F\n"

"{\n"

" public:\n"

" char *c;\n"

" const char *p,*d;\n"

" F(char *str,char *st,char *string)\n"

" {\n"

" p=str;\n"

" d=st;\n"

" c=(char *)malloc(strlen(string)+1);\n"

" strcpy(d,string);\n"

" }\n"

" F(const F &f)\n"

" {\n"

" p=f.p;\n"

" d=f.d;\n"

" c=(char *)malloc(strlen(str)+1);\n"

" strcpy(d,f.p);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class F : E\n"

"{\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class E { E(E&); };\n" // non-copyable

"class F : E\n"

"{\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class E {};\n"

"class F : E {\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("[test.cpp:5]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout_str());

checkCopyConstructor("class F {\n"

" char *p;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

" F(F& f);\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("", errout_str());

checkCopyConstructor("class F {\n"

" char *p;\n"

" F() : p(malloc(100)) {}\n"

" ~F();\n"

" F& operator=(const F&f);\n"

"};");

ASSERT_EQUALS("[test.cpp:3]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout_str());

// #7198

checkCopyConstructor("struct F {\n"

" static char* c;\n"

" F() {\n"

" p = malloc(100);\n"

" }\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void copyConstructor2() { // ticket #4458

checkCopyConstructor("template <class _Tp>\n"

"class Vector\n"

"{\n"

"public:\n"

" Vector() {\n"

" _M_finish = new _Tp[ 42 ];\n"

" }\n"

" Vector( const Vector<_Tp>& v ) {\n"

" }\n"

" ~Vector();\n"

" Vector& operator=(const Vector&v);\n"

" _Tp* _M_finish;\n"

"};");

ASSERT_EQUALS("", errout_str());

}

void copyConstructor3() {

checkCopyConstructor("struct F {\n"

" char* c;\n"

" F() { c = malloc(100); }\n"

" F(const F &f) = delete;\n"

" F&operator=(const F &f);\n"

" ~F();\n"