Avertissement du compilateur (niveau 1) C4930

« prototype » : fonction prototypée non appelée (était-ce la définition de variable souhaitée ?)

Le compilateur a détecté un prototype de fonction inutilisé. Si le prototype était destiné à une déclaration de variable, supprimez les parenthèses ouvertes/fermées.

L’exemple suivant génère l’erreur C4930 :

// C4930.cpp
// compile with: /W1
class Lock {
public:
   int i;
};

void f() {
   Lock theLock();   // C4930
   // try the following line instead
   // Lock theLock;
}

int main() {
}

C4930 peut également se produire lorsque le compilateur ne peut pas faire la distinction entre une déclaration de prototype de fonction et un appel de fonction.

L’exemple suivant génère l’erreur C4930 :

// C4930b.cpp
// compile with: /EHsc /W1

class BooleanException
{
   bool _result;

public:
   BooleanException(bool result)
      : _result(result)
   {
   }

   bool GetResult() const
   {
      return _result;
   }
};

template<class T = BooleanException>
class IfFailedThrow
{
public:
   IfFailedThrow(bool result)
   {
      if (!result)
      {
         throw T(result);
      }
   }
};

class MyClass
{
public:
   bool MyFunc()
   {
      try
      {
         IfFailedThrow<>(MyMethod()); // C4930

         // try one of the following lines instead
         // IfFailedThrow<> ift(MyMethod());
         // IfFailedThrow<>(this->MyMethod());
         // IfFailedThrow<>((*this).MyMethod());

         return true;
      }
      catch (BooleanException e)
      {
         return e.GetResult();
      }
   }

private:
   bool MyMethod()
   {
      return true;
   }
};

int main()
{
   MyClass myClass;
   myClass.MyFunc();
}

Dans l’exemple ci-dessus, le résultat d’une méthode qui accepte zéro arguments est passé en tant qu’argument au constructeur d’une variable de classe locale sans nom. L’appel peut être ambiguïté en nommant la variable locale ou en préfixant l’appel de méthode avec une instance d’objet, ainsi que l’opérateur pointeur vers membre approprié.