Advertencia del compilador (nivel 1) C4930

"prototype": no se ha llamado a la función prototipo (¿se pensó una definición de variable?)

El compilador detectó un prototipo de función sin usar. Si el prototipo estaba pensado como una declaración de variable, quite los paréntesis de apertura y cierre.

El ejemplo siguiente genera la advertencia 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() {
}

La advertencia C4930 también puede producirse cuando el compilador no puede distinguir entre una declaración de prototipo de función y una llamada a función.

El ejemplo siguiente genera la advertencia 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();
}

En el ejemplo anterior, el resultado de un método que toma cero argumentos se pasa como argumento al constructor de una variable de clase local sin nombre. Para desambiguar la llamada, puede asignar un nombre a la variable local o colocar un prefijo a la llamada de método con una instancia de objeto junto con el operador de puntero a miembro correspondiente.