Undetected always true condition

Fraser — Fri, 21 Aug 2026 11:10:55 -0000

With the following code when there is failure to allocate memory std::bad_alloc is thrown. The following test of the pointer is useless. This is from C++ Gotchas P172. I think it would be worthwhile to catch this with CPPCheck.

int * ip = new int;
if (ip)
std::cout << "Always executed";
else
std::cout << "Never executed";

Cast to unknown type interpreted as parenthesized variable

Aaron Danen — Wed, 12 Aug 2026 19:07:58 -0000

this sort of code is analyzed properly and throws no errors

typedef char ** STR;
void f() {
   void *buf;
   STR s = (STR) &buf;
}

however, if the typedefs are not present and cppcheck doesn't know what STR is

void f() {
   void *buf;
   STR s = (STR) &buf;
}

iscast() in tokenlist.cpp returns false for (STR) and the & is parsed as a bitwise AND, instead of the address-of operator. Because the & is a binary operator on unitialized data, this example throws a false positive:

examples/uninit.c:3:19: error: Uninitialized variable: buf [uninitvar]
STR s = (STR) &buf;

False positive assertWithSideEffect with function pointer comparison

CHR — Wed, 12 Aug 2026 06:38:13 -0000

Thanks for reporting, ticket is here: https://trac.cppcheck.net/ticket/14973

False positive assertWithSideEffect with function pointer comparison

correctmost — Wed, 12 Aug 2026 05:46:47 -0000

I am seeing a false positive assertWithSideEffect warning when an assert contains a function pointer comparison.

Here is sample code based on code from glib-networking:

#include <assert.h>

typedef struct
{
  bool field;
} st;

static bool handshake ()
{
  st *priv;
  priv->field = true;
  return true;
}

int main()
{
  bool (*fptr)() = handshake;
  assert (handshake == fptr);  # warning: Assert statement calls a function which may have desired side effects: 'handshake'. [assertWithSideEffect]
  return 0;
}

I don't think a function call is actually being made in this case.

Versions tested:
dfcec18902 and 2.21.1 (Arch Linux)

Non existing source files are silenctly ignored

Aaron Danen — Wed, 12 Aug 2026 01:04:12 -0000

in cli/filelister.cpp:addFiles2 there is

    struct stat file_stat;
    if (stat(path.c_str(), &file_stat) == -1)
        return ""; // TODO: return error?

if we returned an error here we could help users who are in this situation. I don't know what situation there would be for a user to specify the analysis of a nonexistent file. The most common thing would probably be people mistyping the name of a file or something similar, in which case proceeding as usual is probably an annoying behavior.

User C++11's instead of unmaintained PCRE

CHR — Wed, 05 Aug 2026 12:53:28 -0000

See https://github.com/cppcheck-opensource/cppcheck/pull/7893

False positive: containerOutOfBounds flags container accesses gated by a same-named constant from a different namespace

Aaron Danen — Tue, 04 Aug 2026 23:10:48 -0000

What version of cppcheck did you use to create this bug? I tried to reproduce this using the current master branch and this issue you describe didn't happen, even with --library=qt

with --debug it looks like its working properly now:

using the first namespace

Checking examples/namespace.cpp ...

##file examples/namespace.cpp
3: namespace TetheringState
4: {
5: constexpr int NUMBER_OF_RESPONSE_FIELDS@var1 = 2 ;
6: }
7:
8: namespace TetheringStateV2
9: {
10: constexpr int NUMBER_OF_RESPONSE_FIELDS@var2 = 5 ;
11: }
12:
13: void Parse ( const QStringList & message@var3 )
14: {
15: using namespace TetheringState ;
16: if ( NUMBER_OF_RESPONSE_FIELDS@var1 ==@exprUNIQUE message@var3 .@exprUNIQUE count (@exprUNIQUE ) )
17: {
18: auto a@var4 ; a@var4 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 0 ) ;
19: auto b@var5 ; b@var5 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 1 ) ;
20: auto c@var6 ; c@var6 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 2 ) ;
21: auto d@var7 ; d@var7 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 3 ) ;
22: auto e@var8 ; e@var8 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 4 ) ;
23: }
24: }



##Value flow
File examples/namespace.cpp
Line 5
  NUMBER_OF_RESPONSE_FIELDS always 2
  = always 2
  2 always 2
Line 10
  NUMBER_OF_RESPONSE_FIELDS always 5
  = always 5
  5 always 5
Line 16
  NUMBER_OF_RESPONSE_FIELDS always 2 // correct!
  == always {!<=-1,!>=2}
Line 18
  0 always 0
Line 19
  1 always 1
Line 20
  2 always 2
Line 21
  3 always 3
Line 22
  4 always 4

and using the second namespace

Checking examples/namespace.cpp ...


##file examples/namespace.cpp
3: namespace TetheringState
4: {
5: constexpr int NUMBER_OF_RESPONSE_FIELDS@var1 = 2 ;
6: }
7:
8: namespace TetheringStateV2
9: {
10: constexpr int NUMBER_OF_RESPONSE_FIELDS@var2 = 5 ;
11: }
12:
13: void Parse ( const QStringList & message@var3 )
14: {
15: using namespace TetheringStateV2 ;
16: if ( NUMBER_OF_RESPONSE_FIELDS@var2 ==@exprUNIQUE message@var3 .@exprUNIQUE count (@exprUNIQUE ) )
17: {
18: auto a@var4 ; a@var4 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 0 ) ;
19: auto b@var5 ; b@var5 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 1 ) ;
20: auto c@var6 ; c@var6 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 2 ) ;
21: auto d@var7 ; d@var7 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 3 ) ;
22: auto e@var8 ; e@var8 =@exprUNIQUE message@var3 .@expr14 at (@exprUNIQUE 4 ) ;
23: }
24: }



##Value flow
File examples/namespace.cpp
Line 5
  NUMBER_OF_RESPONSE_FIELDS always 2
  = always 2
  2 always 2
Line 10
  NUMBER_OF_RESPONSE_FIELDS always 5
  = always 5
  5 always 5
Line 16
  NUMBER_OF_RESPONSE_FIELDS always 5 // correct!
  == always {!<=-1,!>=2}
Line 18
  0 always 0
Line 19
  1 always 1
Line 20
  2 always 2
Line 21
  3 always 3
Line 22
  4 always 4

it might be related to#14859, and #14948

Compilation of cppcheck false positives (functionStatic, virtualCallInConstructor, knownConditionTrueFalse, duplicateExpression)

CHR — Tue, 04 Aug 2026 20:39:45 -0000

10) functionStatic doesn't detect that a member function requires an instance when its only "member use" is an unqualified call to a non-static sibling overload

The provided example does not compile.

False positive: containerOutOfBounds flags container accesses gated by a same-named constant from a different namespace

Long Huang — Tue, 04 Aug 2026 20:37:56 -0000

containerOutOfBounds flags container accesses gated by a same-named constant from a different namespace, pulled in via using namespace

Minimal reproduction:

#include <QStringList>

namespace TetheringState
{
   constexpr int NUMBER_OF_RESPONSE_FIELDS = 2;
}

namespace TetheringStateV2
{
   constexpr int NUMBER_OF_RESPONSE_FIELDS = 5;
}

void Parse(const QStringList& message)
{
   using namespace TetheringStateV2;
   if(NUMBER_OF_RESPONSE_FIELDS == message.count())
   {
      auto a = message.at(0);
      auto b = message.at(1);
      auto c = message.at(2);
      auto d = message.at(3);
      auto e = message.at(4);
   }
}

TetheringState and TetheringStateV2 each declare a NUMBER_OF_RESPONSE_FIELDS constant. Inside Parse, using namespace TetheringStateV2 brings the value 5 into scope, so the guarded block only runs when message.count() == 5, making at(0)..at(4) all in bounds. cppcheck instead resolves NUMBER_OF_RESPONSE_FIELDS to the unrelated TetheringState::NUMBER_OF_RESPONSE_FIELDS (value 2), so it treats the guard as 2 == message.count() and flags every access past index 1 as out of bounds.

Compilation of cppcheck false positives (functionStatic, virtualCallInConstructor, knownConditionTrueFalse, duplicateExpression)

Long Huang — Tue, 04 Aug 2026 20:35:21 -0000

Thank you, there're a few more in the initial and 2nd posts that are still awaiting sourceforge moderator approval in this thread.

Recent posts to Discussion

Undetected always true condition

Cast to unknown type interpreted as parenthesized variable

False positive assertWithSideEffect with function pointer comparison

False positive assertWithSideEffect with function pointer comparison

Non existing source files are silenctly ignored

User C++11's instead of unmaintained PCRE

False positive: containerOutOfBounds flags container accesses gated by a same-named constant from a different namespace

Compilation of cppcheck false positives (functionStatic, virtualCallInConstructor, knownConditionTrueFalse, duplicateExpression)

False positive: containerOutOfBounds flags container accesses gated by a same-named constant from a different namespace

Compilation of cppcheck false positives (functionStatic, virtualCallInConstructor, knownConditionTrueFalse, duplicateExpression)