# V1077. Conditional initialization inside the constructor may leave some members uninitialized.

The analyzer has detected a constructor that may contain potentially uninitialized class fields after execution.

Here's a simple synthetic example:

    struct Cat
    {
      int age;

      Cat(bool isKitten)
      {
        if (isKitten)
        {
          age = 3;
        }
      }
    };

If, when constructing an object of the 'Cat' type, the 'false' value is passed as an actual parameter, the non-static field of the 'age' class will not be initialized. Subsequent access to this field results in undefined behavior:

    #include <iostream>

    void Cat()
    {
      Cat instance { false };
      std::cout << instance.x << std::endl; // UB
    }

The correct version of the constructor should look like this:

    Cat(bool isKitten) : age { 0 }
    {
      if (isKitten)
      {
        age = 3;
      }
    }

If it's allowed that any class member may remain uninitialized after executing the constructor, then you can suppress warnings for these members with the special comment "//-V1077_NOINIT":

    struct Cat
    {
      int age; //-V1077_NOINIT

      Cat(bool isKitten)
      {
        if (isKitten)
        {
          age = 3;       // ok
        }
      }
    };

You can suppress a warning by marking the constructor with the comment "//-V1077". You can also use the mass suppression mechanism to exclude false positives.

There is also a way to disable the diagnostic warnings for all class fields of a certain type. Use the same comment as in the V730 diagnostic (the search for uninitialized class members in constructors).

The format of the comment:

    //+V730:SUPPRESS_FIELD_TYPE, class:className, namespace:nsName

If you specify the class with the 'className' name as the argument of the 'class' parameter, then fields of this type will be considered as exceptions in V1077 and V730 diagnostics. Code example:

    //+V730:SUPPRESS_FIELD_TYPE, class:Field

    struct Field
    {
      int f;
    };

    class Test
    {
      Field someField;

    public:
      Test(bool cond, int someValue)
      {
        if (cond)
        {
          someField.f = someValue; // ok
        }
      }
    };

When using a special comment, the analyzer does not issue a warning for fields that have the 'Field' type (in our case - 'someField').

The following syntax is used for nested classes:

    //+V730:SUPPRESS_FIELD_TYPE, class:className.NestedClassName,
      namespace:nsName

Each nested class is separated by a dot: "className.NestedClassName".

We did not introduce a separate comment for V1077 for the following reasons. If the type is marked with a comment for V730 diagnostic, it is intended that the type instances may not be initialized at all, which means it's pointless to issue V1077 diagnostic for it as well. In addition, if you already have markup for V730, it works for V1077 as well.

This diagnostic is classified as:

CWE-457