# V524. It is suspicious that the body of 'Foo_1' function is fully equivalent to the body of 'Foo_2' function.

This warning is generated when the analyzer detects two functions implemented in the same way. Presence of two identical functions is not an error in itself but you should study them.

The sense of such diagnosis is detecting the following type of errors:

    class Point
    {
      ...
      float GetX() { return m_x; }
      float GetY() { return m_x; }
    };

The misprint in the code causes the two functions different in sense to perform the same actions. This is the correct version:

    float GetX() { return m_x; }
    float GetY() { return m_y; }

Identity of the bodies of functions GetX() and GetY() in this sample obviously signals an error. However, the percentage of false alarms will be too great if the analyzer generates warnings for all identical functions, so it is guided by a range of exceptions when it must not warn the programmer about identical function bodies. Here are some of them:

- The analyzer does not report about identity of functions' bodies if they do not use variables except for arguments. For example: "bool IsXYZ() { return true; }".
- Functions use static objects and therefore have different inner states. For example: "int Get() { static int x = 1; return x++; }"
- Functions are type cast operators.
- Functions with identical bodies are repeated more than twice.
- And so on.

However, in some cases the analyzer cannot understand that identical function bodies are not an error. This is code which is diagnosed as dangerous but really it is not:

    PolynomialMod2 Plus(const PolynomialMod2 &b) const
      {return Xor(b);}
    PolynomialMod2 Minus(const PolynomialMod2 &b) const
      {return Xor(b);}

You can suppress false alarms using several methods. If false alarms refer to files of external libraries, you may add this library (i.e. its path) to exceptions. If false alarms refer to your own code, you may use the comment of the "//-V524" type to suppress false warnings. If there are too many false alarms, you may completely disable this diagnosis in the analyzer's settings. You may also modify the code so that one function calls another with the same code.

The last method is often the best since it, first, reduces the amount of code and, second, makes it easier to support. You need to edit only one function instead of the both functions. This is a sample of real code where the programmer could benefit from calling one function from another:

    static void PreSave(void) {
      int x;
      for(x=0;x<TotalSides;x++) {
        int b;
        for(b=0; b<65500; b++)
          diskdata[x][b] ^= diskdatao[x][b];
      }
    }

    static void PostSave (void) {
      int x;
      for(x=0;x<TotalSides;x++) {
        int b;
        for(b=0; b<65500; b++)
          diskdata[x][b] ^= diskdatao[x][b];
      }
    }

This code should be replaced with the following:

    static void PreSave(void) {
      int x;
      for(x=0;x<TotalSides;x++) {
        int b;
        for(b=0; b<65500; b++)
          diskdata[x][b] ^= diskdatao[x][b];
      }
    }

    static void PostSave (void) {
      PreSave();
    }

We did not fix the error in this sample, but the V524 warning disappeared after refactoring and the code got simpler.

You can look at examples of errors detected by the V524 diagnostic.