Clang Analyzer在C++17下大括号初始化疑似误报问题咨询

Yes, this is indeed a false positive from the Clang Analyzer. Let’s break down why this happens and confirm your code is perfectly valid.

Why the Analyzer Flags an Error #

The Clang Analyzer appears to misinterpret the braced initialization const DataType type{getDataType()}; as an aggregate initialization attempt, instead of recognizing it should invoke the class’s move (or copy) constructor.

To understand this, let’s reference C++17’s aggregate type rules:

• A type is not an aggregate if it has any user-declared constructors—and DataType has multiple: the constructor taking a Literal, a copy constructor, and a move constructor.
• Even though C++17 allows aggregates to have public base classes, DataType is disqualified from being an aggregate due to its user-defined constructors.

When you use braced syntax here, it should resolve to calling DataType’s move constructor (since getDataType() returns an rvalue). The move constructor properly initializes the base class Enumeration<Literal> using dt.value_, so the value_ member is fully initialized and valid. The analyzer’s mistake lies in assuming the braced syntax is trying to directly initialize base class members without going through the constructor chain, leading it to incorrectly flag value_ as garbage/undefined.

Why Your Code Works as Expected #

As you saw in Compiler Explorer, both braced and parenthesized initialization behave identically at runtime:

1. getDataType() constructs a DataType object with Literal::UndefinedType.
2. The move constructor of DataType is called to initialize type, properly propagating the valid value_ from the temporary object.
3. The comparison type == Literal::UndefinedType correctly evaluates to true.

The parenthesized version doesn’t trigger the error because the analyzer correctly recognizes it as a direct constructor call, not an aggregate initialization attempt.

Workarounds for the False Positive #

If you want to keep using braced initialization without the analyzer warning, you have two simple options:

• Clarify the move constructor: Explicitly use std::move in the move constructor to help the analyzer recognize the valid initialization (your current code is correct, but this nudges the analyzer):

  DataType(DataType&& dt) noexcept : Enumeration<Literal>(std::move(dt.value_)) {
      std::cout << "DataType move ctor" << std::endl;
  }
  

• Suppress the warning locally: Use Clang’s diagnostic pragmas to ignore the specific warning for this line:

  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wanalyzer-garbage-value"
  const DataType type{getDataType()};
  #pragma clang diagnostic pop
  

内容的提问来源于stack exchange，提问作者amfcosta