Partager via

/RTC (Vérifications des erreurs au moment de l’exécution)

  • Article

Permet d’activer et de désactiver la fonctionnalité de vérification des erreurs au moment de l’exécution, conjointement avec le pragma runtime_checks .

Syntaxe

/RTC1
/RTCc
/RTCs
/RTCu

Arguments

/RTC1
Équivaut à /RTCsu.

/RTCc
Signale lorsqu’une valeur est affectée à un type de données plus petit et entraîne une perte de données. Par exemple, il signale si une short valeur de type est 0x0101 affectée à une variable de type char.

Cette option peut signaler des situations dans lesquelles vous envisagez de tronquer. Par exemple, lorsque vous souhaitez obtenir les 8 premiers bits d’un int charretour en tant que . Étant donné que /RTCc provoque une erreur d’exécution si une affectation provoque une perte d’informations, masquez d’abord les informations dont vous avez besoin pour éviter l’erreur d’exécution. Par exemple :

#include <crtdbg.h>

char get8bits(unsigned value, int position) {
   _ASSERT(position < 32);
   return (char)(value >> position);
   // Try the following line instead:
   // return (char)((value >> position) & 0xff);
}

int main() {
   get8bits(12341235,3);
}

Étant donné que /RTCc rejette le code conforme à la norme, il n’est pas pris en charge par la bibliothèque C++ Standard. Le code qui utilise /RTCc et la bibliothèque standard C++ peut entraîner l’erreur du compilateur C1189. Vous pouvez définir _ALLOW_RTCc_IN_STL pour désactiver le silence de l’avertissement et utiliser l’option /RTCc .

/RTCs
Active la vérification des erreurs au moment de l’exécution de la pile, comme suit :

  • Initialisation de variables locales à une valeur différente de zéro. Cette option permet d’identifier les bogues qui n’apparaissent pas lors de l’exécution en mode débogage. Il est plus possible que les variables de pile aient toujours une valeur nulle dans une build de débogage par rapport à une build de mise en production. Cela est dû aux optimisations du compilateur des variables de pile dans une build de mise en production. Une fois qu’un programme a utilisé une zone de sa pile, il n’est jamais réinitialisé à 0 par le compilateur. Cela signifie que toutes les variables de pile non initialisées qui se produisent pour utiliser la même zone de pile ultérieurement peuvent retourner les valeurs laissées à partir de l’utilisation antérieure de cette mémoire de pile.

  • Détection des dépassements et des sous-exécutions de variables locales telles que des tableaux. /RTCs ne détecte pas les dépassements lors de l’accès à la mémoire résultant du remplissage du compilateur dans une structure. Le remplissage peut se produire à l’aide alignde , /Zp (alignement des membres de struct) ou pack, ou si vous commandez des éléments de structure de telle façon que le compilateur puisse ajouter du remplissage.

  • Vérification du pointeur de pile, qui détecte l’altération du pointeur de pile. L’altération du pointeur de pile peut être due à une incompatibilité de convention d’appel. Par exemple, à l’aide d’un pointeur de fonction, vous appelez une fonction dans une DLL exportée comme __stdcall mais vous déclarez le pointeur vers la fonction en tant que __cdecl.

/RTCu
Signale lorsqu’une variable est utilisée sans avoir été initialisée. Par exemple, une instruction qui génère l’avertissement C4701 peut également générer une erreur d’exécution sous /RTCu. Toute instruction qui génère l’avertissement du compilateur (niveau 1 et niveau 4) C4700 génère une erreur d’exécution sous /RTCu.

Toutefois, tenez compte du fragment de code suivant :

int a, *b, c;
if ( 1 )
b = &a;
c = a;  // No run-time error with /RTCu

Si une variable a pu être initialisée, elle n’est pas signalée au moment de l’exécution par /RTCu. Par exemple, une fois qu’une variable est alias par le biais d’un pointeur, le compilateur ne suit pas les utilisations non initialisées de la variable et du rapport. En effet, vous pouvez initialiser une variable en prenant son adresse. L’opérateur & fonctionne comme un opérateur d’affectation dans cette situation.

Notes

Les vérifications d’erreur au moment de l’exécution permettent de trouver des problèmes dans votre code en cours d’exécution ; pour plus d’informations, consultez Guide pratique pour utiliser des vérifications d’exécution natives.

Vous pouvez spécifier plusieurs /RTC options sur la ligne de commande. Les arguments d’option peuvent être combinés ; par exemple, /RTCcu est identique à /RTCc /RTCu.

Si vous compilez votre programme sur la ligne de commande à l’aide de l’une /RTC des options du compilateur, toutes les instructions pragma optimize de votre code échouent silencieusement. Cela est dû au fait que les vérifications d’erreur au moment de l’exécution ne sont pas valides dans une build de mise en production (optimisée).

Utiliser /RTC pour les builds de développement ; N’utilisez /RTC pas pour une build de mise en production. /RTC ne peut pas être utilisé avec les optimisations du compilateur (/O Options (Optimiser le code)). Une image de programme créée avec /RTC est légèrement plus grande et légèrement plus lente qu’une image générée avec /Od (jusqu’à 5 pour cent plus lent qu’une /Od build).

La __MSVC_RUNTIME_CHECKS directive de préprocesseur est définie lorsque vous utilisez n’importe quelle /RTC option ou /GZ.

Pour définir cette option du compilateur dans l'environnement de développement Visual Studio

  1. Ouvrez la boîte de dialogue Pages de propriété du projet. Pour plus d’informations, consultez Définir le compilateur C++ et les propriétés de build dans Visual Studio.

  2. Sélectionnez la page de propriétés De configuration>C/C++>Génération de code.

  3. Modifiez l’une ou l’autre des propriétés suivantes : Vérifications du runtime de base ou Vérification de type plus petite.

Pour définir cette option du compilateur par programmation

Voir aussi

Options du compilateur MSVC
Syntaxe de ligne de commande du compilateur MSVC
Guide pratique pour utiliser les vérifications natives à l’exécution