# V3001\. There are identical sub\-expressions to the left and to the right of the 'foo' operator\.

The analyzer has detected a code fragment that is very likely to have a logical error in it\. The program text contains an operator \(<, \>, <\=, \>\=, \=\=, \!\=, &&, \|\|, \-, /, &, \|, ^\) whose both operands are identical subexpressions\. 

Consider this example: 

```cpp
if (a.x != 0 && a.x != 0)
```

In this case, the '&&' operator is surrounded by identical subexpressions "a\.x \!\= 0", which enables the analyzer to detect a mistake made through carelessness\. A correct version of this code, which won't trigger the diagnostic, should look as follows:

```cpp
if (a.x != 0 && a.y != 0)
```

Here's another example of a mistake detected by the analyzer in an application's code:

```cpp
class Foo {
  List<int> Childs { get; set; }
  ...
  public bool hasChilds() { return(Childs[0] > 0 || Childs[0] > 0); }
  ...
}
```

In this case, although the code compiles well and without any warnings, it just doesn't make sense\. Its correct version should look like this:

```cpp
public bool hasChilds(){ return(Childs[0] > 0 || Childs[1] > 0);}
```

The analyzer compares the code blocks, taking into account inversion of the expression's parts in relation to the operator\. For example, it will detect the error in the following code:

```cpp
if (Name.Length > maxLength && maxLength < Name.Length)
```