# V2624\. MISRA\. The initializer for an aggregate or union should be enclosed in braces\.

This diagnostic rule is based on the software development guidelines of [MISRA](https://misra.org.uk/) \(Motor Industry Software Reliability Association\)\.

This diagnostic rule is relevant only to C\-programs\. It requires initializers for an aggregate or union to be enclosed in braces\. This diagnostic rule can be used for both objects and subobjects\.

Exceptions:

* the initializer of the form '\{ 0 \}' is used to initialize subobjects;
* the array is initialized with a string literal;
* a structure or union with automatic storage duration is initialized with an expression that is compatible with the structure or union;
* the designated initialization is used to initialize a part of a subobject\.

Look at the example:

```cpp
int num[3][2] = { 1, 2, 3, 4, 5, 6 };
```

The code contains array initializers that are not enclosed in braces\. Here is the correct code:

```cpp
int num[3][2] = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
```

Take a look at another example:

```cpp
struct S1
{
  char buf;
  int num[3][2];

} s1[4] = { 
        'a', { 1, 2 }, { 0, 0 }, { 5, 6 },
        'b', { 1, 2 }, { 0, 0 }, { 5, 6 },
        'c', { 1, 2 }, { 0, 0 }, { 5, 6 },
        'd', { 1, 2 }, { 0, 0 }, { 5, 6 }
};
```

The diagnostic rule requires initializers for an aggregate to also be enclosed in braces\. Here is the correct code:

```cpp
struct S1
{
  char buf;
  int num [3][2];

} s1[4] = {
        { 'a', { { 1, 2 }, { 0, 0 }, { 5, 6 } } },
        { 'b', { { 1, 2 }, { 0, 0 }, { 5, 6 } } },
        { 'c', { { 1, 2 }, { 0, 0 }, { 5, 6 } } },
        { 'd', { { 1, 2 }, { 0, 0 }, { 5, 6 } } }
};
```

Let's take a look at the following case:

```cpp
struct S2 {
  char color[8];
  int num;
} s2[3] = {
        { "Red",   1 },
        { "Green", 2 },
        { "Blue",  3 }
};
```

Here, the character literal should also be enclosed in braces\. Here is the correct code:

```cpp
struct S2 {
  char color[8];
  int num;
} s2[3] = {
        { { "Red" },   1 },
        { { "Green" }, 2 },
        { { "Blue" },  3 }
};
```

The example of code with designated initializers looks as follows:

```cpp
int num[2][2] = { [0][1] = 0, { 0, 1 } };
```

Here are the examples of code with the initializer of the form '\{ 0 \}':

```cpp
int num1[3][2]  = { 0 }; 
int num2[3][2] = { { 1, 2 }, { 0 }, { 5, 6 } };
int num3[2][2] = { { 0 }, [1][1] = 1 };
```