# V2658\. MISRA\. Dead code should not be used in a project\.

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

This diagnostic rule is relevant only for C\.

Programs should not contain dead code, the removal of which does not affect the program behavior\.

The presence of dead code can indicate an error in the program logic\.

**Exceptions:**

* unreachable code, since it cannot be executed;
* unused initialized variables, since initialization is not an assignment operation;
* casting to `void` when the result is not used, since it points to a value that is intentionally not used;
* a type conversion operator whose result is used\.

**Note\. **Compilers can remove dead code, as this does not affect the program behavior\.

The example of redundant operations:

```cpp
int func( int input )
{
  short var;
  int *ptr = &input;

  var = 11;     // <=
  (int)var;     // <=
  var + input;  // <=
  *ptr++;       // <=
  return input + input;
}
```

There are several operations: assignment \(`=`\), type casting \(`(int)`\), addition \(`+`\), the `ptr` pointer increment and dereference \(`*`\)\. They are redundant because the result of these operations is not used and does not affect the program execution\.

The fixed code:

```cpp
int func( int input )
{
  short var;
  int *ptr;

  ptr = &input;
  var = 11;
  input += (int)var;
  (*ptr)++;
  return input;
}
```

The example of a redundant function call:

```cpp
void funcToCall ( int input )
{
  return;
  for(size_t i = 0; i < 13; ++i)
  {
    input += i;
  }
}

int funcBase ( int input ) 
{
  funcToCall(input);
  return input + input;
}
```

The `funcToCall` function is not dead code, since it contains operations in unreachable code\. However, calling the function is dead code, since its removal does not change the program behavior\.

The fixed code:

```cpp
unsigned int funcToCall ( unsigned int x )
{
  for(size_t i = 0; i < 13; ++i)
  {
    x += i;
  }
  return x;
}

unsigned int funcBase ( unsigned int x )
{
  return funcToCall(x);
}
```