# V2593\. MISRA\. Single\-bit bit fields should not be declared as signed type\.

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

Do not declare single\-bit bit fields as a signed type\. According to the standard C99 §6\.2\.6\.2C99 § 6\.2\.6\.2, a single\-bit bit field of a signed type has one bit for the sign and zero for values\. With any representation of integers, zero significant bits cannot specialize any significant number\. Although C90 has no such description, the rule applies also for this version of the standard\.

In C\+\+, assigning the `1` value to a one\-bit signed bit\-field is implementation\-defined\.

The example:

```cpp
struct S
{
  int a : 1;
};

void foo()
{
  struct S s;
  s.a = 1;

  if (s.a > 0)
  {
    DoWork();
  }
}
```

The bit field is explicitly assigned `1` and must be positive\. But the check for this will fail—`1` in the `s.a` field may be interpreted differently\. It depends on the compiler implementation\. To compare types, they will be cast to the `int` type\. The result is `-1` \(0xFFFFFFFF\)\. So, the `DoWork()` function will not be executed because the condition `-1 > 0` is false\. 

The fixed code:

```cpp
struct S
{
  unsigned a : 1;
};

void foo()
{
  struct S s;
  s.a = 1u;

  if (s.a > 0u)
  {
    DoWork();
  }
}
```

The exception is unnamed bit fields, because one cannot use a value from such a field:

```cpp
struct S
{
  int a : 31;
  int : 1;    // ok
};
```