# V685\. The expression contains a comma\. Consider inspecting the return statement\.

The analyzer has found that a value returned by a function might be incorrect as it contains the comma operator ','\. This is not necessarily an error, but this code should be checked\.

Here is an example of suspicious code:

```cpp
int Foo()
{
  return 1, 2;
}
```

The function will return the value 2\. The number 1 is redundant in this code and won't affect the program behavior in any way\.

If it is just a typo, the redundant value should be eliminated:

```cpp
int Foo()
{
  return 2;
}
```

But it may be possible sometimes that such a return value contains a genuine error\. That's why the analyzer tracks such constructs\. For example, a function call may have been accidentally removed during refactoring\.

If this is the case, the code can be fixed in the following way:

```cpp
int Foo()
{
  return X(1, 2);
}
```

Comma is sometimes useful when working with the 'return' operator\. For example, the following code can be shortened by using a comma\.

The lengthy code:

```cpp
if (A)
{
  printf("hello");
  return X;
}
```

The shorter code:

```cpp
if (A)
  return printf("hello"), X; // No warning triggered
```

We do not find the shorter code version smart and do not recommend using it\. However, this is a frequent practice and such code does have sense, so the analyzer doesn't generate the warning if the expression to the left of the comma affects the program behavior\.