/Zc:rvalueCast (Exigir reglas de conversión de tipos)

Cuando se especifica la opción /Zc:rvalueCast, el compilador identifica correctamente un tipo de referencia de valor R como resultado de una operación de conversión. Su comportamiento se ajusta al estándar de C++11. Cuando no se especifica la opción, el comportamiento del compilador es el mismo que en Visual Studio 2012.

Sintaxis

/Zc:rvalueCast
/Zc:rvalueCast-

Comentarios

Si se especifica /Zc:rvalueCast, el compilador sigue la sección 5.4 del estándar C++11 y trata únicamente las expresiones de conversión que tienen como resultado tipos sin referencia y las que tienen como resultado referencias de valor R a tipos que no son de función como, por ejemplo, los tipos de valor R. De forma predeterminada o si se especifica /Zc:rvalueCast-, el compilador no es conforme y trata como valores R todas las expresiones de conversión que tienen como resultado referencias de valor R. Por conformidad y para eliminar los errores en el uso de las conversiones, recomendamos utilizar /Zc:rvalueCast.

De manera predeterminada, /Zc:rvalueCast está desactivada (/Zc:rvalueCast-). La opción del compilador /permissive- establece implícitamente esta opción, pero se puede invalidar mediante /Zc:rvalueCast-.

Use /Zc:rvalueCast si pasa una expresión de conversión como argumento a una función que toma un tipo de referencia de valor R. El comportamiento predeterminado genera el error del compilador C2664 cuando el compilador determina incorrectamente el tipo de la expresión de conversión. Este ejemplo muestra un error del compilador en código correcto cuando no se especifica /Zc:rvalueCast:

// Test of /Zc:rvalueCast
// compile by using:
// cl /c /Zc:rvalueCast- make_thing.cpp
// cl /c /Zc:rvalueCast make_thing.cpp

#include <utility>

template <typename T>
struct Thing {
   // Construct a Thing by using two rvalue reference parameters
   Thing(T&& t1, T&& t2)
      : thing1(t1), thing2(t2) {}

   T& thing1;
   T& thing2;
};

// Create a Thing, using move semantics if possible
template <typename T>
Thing<T> make_thing(T&& t1, T&& t2)
{
   return (Thing<T>(std::forward<T>(t1), std::forward<T>(t2)));
}

struct Test1 {
   long a;
   long b;

   Thing<long> test() {
      // Use identity casts to create rvalues as arguments
      return make_thing(static_cast<long>(a), static_cast<long>(b));
   }
};

Puede que el comportamiento predeterminado del compilador no notifique el error C2102 cuando proceda. En este ejemplo, el compilador no notifica un error si se toma la dirección de un valor R creado por una conversión de identidad cuando no se especifica /Zc:rvalueCast:

int main() {
   int a = 1;
   int *p = &a;   // Okay, take address of lvalue
                  // Identity cast creates rvalue from lvalue;
   p = &(int)a;   // problem: should cause C2102: '&' requires l-value
}

Para obtener más información sobre los problemas de conformidad de Visual C++, vea Nonstandard Behavior.

Para establecer esta opción del compilador en el entorno de desarrollo de Visual Studio

1. Abra el cuadro de diálogo Páginas de propiedades del proyecto. Para más información, vea Establecimiento del compilador de C++ y de propiedades de compilación en Visual Studio.

2. Seleccione la página de propiedades Propiedades de configuración>C/C++>Lenguaje.

3. Establezca la propiedad Aplicar reglas de conversión de tipos en /Zc:rvalueCast o /Zc:rvalueCast-. Haga clic en Aceptar o en Aplicar para guardar los cambios.

Consulte también

/Zc (Ajuste)