Présentation de SALUnderstanding SAL

Le langage d’annotation du code source Microsoft (SAL) fournit un ensemble d’annotations que vous pouvez utiliser pour décrire la façon dont une fonction utilise ses paramètres, les hypothèses qu’elle fait sur eux et les garanties qu’elle apporte quand elle est terminée.The Microsoft source-code annotation language (SAL) provides a set of annotations that you can use to describe how a function uses its parameters, the assumptions that it makes about them, and the guarantees that it makes when it finishes. Les annotations sont définies dans le fichier d’en-tête <sal.h>.The annotations are defined in the header file <sal.h>. Visual Studio analyse du code pour C++ utilise les annotations SAL pour modifier son analyse de fonctions.Visual Studio code analysis for C++ uses SAL annotations to modify its analysis of functions. Pour plus d’informations sur SAL 2.0 pour le développement de pilotes Windows, consultez Annotations SAL 2.0 pour Windows pilotes.For more information about SAL 2.0 for Windows driver development, see SAL 2.0 Annotations for Windows Drivers.

En mode natif, C et C++ permettent uniquement limité pour les développeurs à exprimer de façon cohérente intention et l’invariance.Natively, C and C++ provide only limited ways for developers to consistently express intent and invariance. À l’aide des annotations SAL, vous pouvez décrire vos fonctions de façon plus détaillée afin que les développeurs qui les consomment peuvent mieux comprendre comment les utiliser.By using SAL annotations, you can describe your functions in greater detail so that developers who are consuming them can better understand how to use them.

What ' s SAL et pourquoi l’utiliser ?What Is SAL and Why Should You Use It?

En termes simples, SAL est une méthode peu onéreuse pour permettre au compilateur de vérifier votre code pour vous.Simply stated, SAL is an inexpensive way to let the compiler check your code for you.

SAL permet de coder plus précieuxSAL Makes Code More Valuable

SAL peut vous aider à rendre la conception de votre code plus compréhensible, pour les humains et les outils d’analyse de code.SAL can help you make your code design more understandable, both for humans and for code analysis tools. Prenons l’exemple suivant qui illustre la fonction C runtime memcpy:Consider this example that shows the C runtime function memcpy:


void * memcpy(
   void *dest,
   const void *src,
   size_t count
);

Vous pouvez indiquer ce que fait cette fonction ?Can you tell what this function does? Lorsqu’une fonction est implémentée ou appelée, certaines propriétés doivent être maintenues pour assurer l’exactitude du programme.When a function is implemented or called, certain properties must be maintained to ensure program correctness. Simplement en examinant une déclaration telle que celle dans l’exemple, vous ne connaissez pas ce qu’ils sont.Just by looking at a declaration such as the one in the example, you don't know what they are. Sans annotations SAL, vous seriez obligé de s’appuient sur la documentation ou des commentaires de code.Without SAL annotations, you'd have to rely on documentation or code comments. Voici la la documentation MSDN pour memcpy indique :Here's what the MSDN documentation for memcpy says:

« Copies comptent les octets de src vers la destination."Copies count bytes of src to dest. Si la source et la destination se chevauchent, le comportement de memcpy est indéfini.If the source and destination overlap, the behavior of memcpy is undefined. Memmove permet de gérer les régions qui se chevauchent.Use memmove to handle overlapping regions. Note de sécurité : vous assurer que la mémoire tampon de destination est la même taille ou supérieure à la mémoire tampon source.Security Note: Make sure that the destination buffer is the same size or larger than the source buffer. Pour plus d’informations, consultez dépassements de mémoire tampon. »For more information, see Avoiding Buffer Overruns."

La documentation contient deux éléments d’information qui suggèrent que votre code doit conserver certaines propriétés pour assurer l’exactitude du programme :The documentation contains a couple of bits of information that suggest that your code has to maintain certain properties to ensure program correctness:

  • memcpy copie le count d’octets à partir de la mémoire tampon source à la mémoire tampon de destination.memcpy copies the count of bytes from the source buffer to the destination buffer.

  • La mémoire tampon de destination doit être au moins aussi grande que la mémoire tampon source.The destination buffer must be at least as large as the source buffer.

    Toutefois, le compilateur ne peut pas lire la documentation ou les commentaires informelles.However, the compiler can't read the documentation or informal comments. Il ne sait pas qu’il existe une relation entre deux mémoires tampons et count, et il également ne peut pas efficacement deviner à propos d’une relation.It doesn't know that there is a relationship between the two buffers and count, and it also can't effectively guess about a relationship. SAL peut fournir plus d’explications sur les propriétés et l’implémentation de la fonction, comme illustré ici :SAL could provide more clarity about the properties and implementation of the function, as shown here:


void * memcpy(
   _Out_writes_bytes_all_(count) void *dest,
   _In_reads_bytes_(count) const void *src,
   size_t count
);

Notez que ces annotations ressemble aux informations dans la documentation MSDN, mais ils sont plus concis et ils suivent un modèle sémantique.Notice that these annotations resemble the information in the MSDN documentation, but they are more concise and they follow a semantic pattern. Lorsque vous lisez ce code, vous pouvez rapidement comprendre les propriétés de cette fonction et comment éviter les problèmes de sécurité de dépassement de mémoire tampon.When you read this code, you can quickly understand the properties of this function and how to avoid buffer overrun security issues. Mieux encore, les modèles sémantiques SAL fournit peuvent améliorer l’efficacité et l’efficacité des outils d’analyse de code automatisé de la détection anticipée des bogues potentiels.Even better, the semantic patterns that SAL provides can improve the efficiency and effectiveness of automated code analysis tools in the early discovery of potential bugs. Imaginez que quelqu'un écrit cette implémentation boguée de wmemcpy:Imagine that someone writes this buggy implementation of wmemcpy:


wchar_t * wmemcpy(
   _Out_writes_all_(count) wchar_t *dest,
   _In_reads_(count) const wchar_t *src,
   size_t count)
{
   size_t i;
   for (i = 0; i <= count; i++) { // BUG: off-by-one error
      dest[i] = src[i];
   }
   return dest;
}

Cette implémentation contient une erreur d’off-en-un courants.This implementation contains a common off-by-one error. Heureusement, l’auteur du code inclus l’annotation SAL la taille mémoire tampon, un outil d’analyse de code pourrait intercepter le bogue en analysant cette fonction uniquement.Fortunately, the code author included the SAL buffer size annotation—a code analysis tool could catch the bug by analyzing this function alone.

Principes fondamentaux SALSAL Basics

SAL définit quatre types de base de paramètres qui sont classés par le modèle d’utilisation.SAL defines four basic kinds of parameters, which are categorized by usage pattern.

CategoryCategory Annotation de paramètreParameter Annotation DescriptionDescription
Entrée appelée (fonction)Input to called function _In_ Données sont passées à la fonction appelée et sont considérées comme étant en lecture seule.Data is passed to the called function, and is treated as read-only.
Entrée à appelé fonction et de sortie à l’appelantInput to called function, and output to caller _Inout_ Données utilisables sont transmies à la fonction et potentiellement sont modifiées.Usable data is passed into the function and potentially is modified.
Sortie vers l’appelantOutput to caller _Out_ L’appelant fournit uniquement l’espace pour la fonction appelée écrire dans.The caller only provides space for the called function to write to. La fonction appelée écrit des données dans cet espace.The called function writes data into that space.
Sortie de pointeur vers l’appelantOutput of pointer to caller _Outptr_ Comme de sortie à appelant.Like Output to caller. La valeur retournée par la fonction appelée est un pointeur.The value that's returned by the called function is a pointer.

Ces quatre annotations de base peuvent être effectuées plus explicites de différentes manières.These four basic annotations can be made more explicit in various ways. Par défaut, les paramètres de pointeur annotés sont supposés pour être requis, ils doivent être non NULL pour la fonction réussisse.By default, annotated pointer parameters are assumed to be required—they must be non-NULL for the function to succeed. La plus couramment utilisée variation des annotations base indique qu’un paramètre de pointeur est facultatif, si sa valeur est NULL, la fonction peut encore réussir dans faire son travail.The most commonly used variation of the basic annotations indicates that a pointer parameter is optional—if it's NULL, the function can still succeed in doing its work.

Ce tableau montre comment faire la distinction entre les paramètres obligatoires et facultatifs :This table shows how to distinguish between required and optional parameters:

Paramètres sont obligatoiresParameters are required Les paramètres sont facultatifsParameters are optional
Entrée appelée (fonction)Input to called function _In_ _In_opt_
Entrée à appelé fonction et de sortie à l’appelantInput to called function, and output to caller _Inout_ _Inout_opt_
Sortie vers l’appelantOutput to caller _Out_ _Out_opt_
Sortie de pointeur vers l’appelantOutput of pointer to caller _Outptr_ _Outptr_opt_

Ces annotations vous aider à identifier les valeurs possibles non initialisées et un pointeur null non valide utilise de manière formelle et précise.These annotations help identify possible uninitialized values and invalid null pointer uses in a formal and accurate manner. Passage de NULL à un paramètre obligatoire peut provoquer un incident, ou il peut entraîner un code d’erreur « Échec » doit être retourné.Passing NULL to a required parameter might cause a crash, or it might cause a "failed" error code to be returned. Dans les deux cas, la fonction ne peut pas réussir à bien son travail.Either way, the function cannot succeed in doing its job.

Exemples SALSAL Examples

Cette section présente des exemples de code pour les annotations SAL de base.This section shows code examples for the basic SAL annotations.

À l’aide de l’outil d’analyse de Code Visual Studio pour détecter des erreursUsing the Visual Studio Code Analysis Tool to Find Defects

Dans les exemples, l’outil d’analyse de Code Visual Studio est utilisé avec les annotations SAL pour rechercher les erreurs de code.In the examples, the Visual Studio Code Analysis tool is used together with SAL annotations to find code defects. Voici comment procéder.Here's how to do that.

Pour utiliser les outils d’analyse de code de Visual Studio et SALTo use Visual Studio code analysis tools and SAL
  1. Dans Visual Studio, ouvrez un projet C++ qui contient les annotations SAL.In Visual Studio, open a C++ project that contains SAL annotations.

  2. Dans la barre de menus, choisissez Build, exécuter l’analyse du Code sur la Solution.On the menu bar, choose Build, Run Code Analysis on Solution.

    Prendre en compte la _dans_ exemple dans cette section.Consider the _In_ example in this section. Si vous exécutez l’analyse du code sur celui-ci, cet avertissement s’affiche :If you run code analysis on it, this warning is displayed:

    Valeur de paramètre non valide C6387 « que » peut être '0' : Ceci n’est pas conforme à la spécification de la fonction 'InCallee'.C6387 Invalid Parameter Value 'pInt' could be '0': this does not adhere to the specification for the function 'InCallee'.

Exemple : Le _dans_ AnnotationExample: The _In_ Annotation

Le _In_ annotation indique que :The _In_ annotation indicates that:

  • Le paramètre doit être valide et ne sera pas modifié.The parameter must be valid and will not be modified.

  • La fonction lit uniquement à partir de la mémoire tampon seul élément.The function will only read from the single-element buffer.

  • L’appelant doit fournir la mémoire tampon et l’initialiser.The caller must provide the buffer and initialize it.

  • _In_ Spécifie « read-only »._In_ specifies "read-only". Une erreur courante consiste à appliquer _In_ à un paramètre qui doit avoir le _Inout_ annotation à la place.A common mistake is to apply _In_ to a parameter that should have the _Inout_ annotation instead.

  • _In_ est autorisé mais ignoré par l’Analyseur de valeurs scalaires non pointeur._In_ is allowed but ignored by the analyzer on non-pointer scalars.

void InCallee(_In_ int *pInt)
{
   int i = *pInt;
}

void GoodInCaller()
{
   int *pInt = new int;
   *pInt = 5;

   InCallee(pInt);
   delete pInt;
}

void BadInCaller()
{
   int *pInt = NULL;
   InCallee(pInt); // pInt should not be NULL
}

Si vous utilisez Visual Studio Code Analysis sur cet exemple, il valide le fait que les appelants passer un pointeur non Null à une mémoire tampon initialisé pour pInt.If you use Visual Studio Code Analysis on this example, it validates that the callers pass a non-Null pointer to an initialized buffer for pInt. Dans ce cas, pInt pointeur ne peut pas être NULL.In this case, pInt pointer cannot be NULL.

Exemple : Le _dans_opt_ AnnotationExample: The _In_opt_ Annotation

_In_opt_ est identique à _In_, sauf que le paramètre d’entrée est autorisé à avoir la valeur NULL et, par conséquent, la fonction doit vérifier cela._In_opt_ is the same as _In_, except that the input parameter is allowed to be NULL and, therefore, the function should check for this.


void GoodInOptCallee(_In_opt_ int *pInt)
{
   if(pInt != NULL) {
      int i = *pInt;
   }
}

void BadInOptCallee(_In_opt_ int *pInt)
{
   int i = *pInt; // Dereferencing NULL pointer 'pInt'
}

void InOptCaller()
{
   int *pInt = NULL;
   GoodInOptCallee(pInt);
   BadInOptCallee(pInt);
}

Analyse du Code Visual Studio valide le fait que la fonction vérifie les valeurs NULL avant d’accéder à la mémoire tampon.Visual Studio Code Analysis validates that the function checks for NULL before it accesses the buffer.

Exemple : Le _Out_ AnnotationExample: The _Out_ Annotation

_Out_ prend en charge un scénario courant dans lequel un pointeur non NULL qui pointe vers une mémoire tampon d’élément est transmis et la fonction initialise l’élément._Out_ supports a common scenario in which a non-NULL pointer that points to an element buffer is passed in and the function initializes the element. L’appelant ne possède pas d’initialiser la mémoire tampon avant l’appel ; la fonction appelée promet d’initialiser avant de retourner.The caller doesn't have to initialize the buffer before the call; the called function promises to initialize it before it returns.


void GoodOutCallee(_Out_ int *pInt)
{
   *pInt = 5;
}

void BadOutCallee(_Out_ int *pInt)
{
   // Did not initialize pInt buffer before returning!
}

void OutCaller()
{
   int *pInt = new int;
   GoodOutCallee(pInt);
   BadOutCallee(pInt);
   delete pInt;
}

L’outil analyse de Code Visual Studio valide le fait que l’appelant passe un pointeur non NULL dans une mémoire tampon pour pInt et que la mémoire tampon est initialisée par la fonction avant de retourner.Visual Studio Code Analysis Tool validates that the caller passes a non-NULL pointer to a buffer for pInt and that the buffer is initialized by the function before it returns.

Exemple : Le _Out_opt_ AnnotationExample: The _Out_opt_ Annotation

_Out_opt_ est identique à _Out_, sauf que le paramètre ne peut pas être NULL et, par conséquent, la fonction doit vérifier cela._Out_opt_ is the same as _Out_, except that the parameter is allowed to be NULL and, therefore, the function should check for this.


void GoodOutOptCallee(_Out_opt_ int *pInt)
{
   if (pInt != NULL) {
      *pInt = 5;
   }
}

void BadOutOptCallee(_Out_opt_ int *pInt)
{
   *pInt = 5; // Dereferencing NULL pointer 'pInt'
}

void OutOptCaller()
{
   int *pInt = NULL;
   GoodOutOptCallee(pInt);
   BadOutOptCallee(pInt);
}

Analyse du Code Visual Studio valide le fait que cette fonction vérifie les valeurs NULL avant pInt est déréférencé et si pInt n’est pas NULL, que la mémoire tampon est initialisée par la fonction avant de retourner.Visual Studio Code Analysis validates that this function checks for NULL before pInt is dereferenced, and if pInt is not NULL, that the buffer is initialized by the function before it returns.

Exemple : Le _Inout_ AnnotationExample: The _Inout_ Annotation

_Inout_ est utilisé pour annoter un paramètre de pointeur qui peut être modifié par la fonction._Inout_ is used to annotate a pointer parameter that may be changed by the function. Le pointeur doit pointer vers les données initialisées valides avant l’appel, et même si elle est modifiée, elle doit toujours avoir une valeur valide en retour.The pointer must point to valid initialized data before the call, and even if it changes, it must still have a valid value on return. L’annotation Spécifie que la fonction peut librement lire et écrire dans la mémoire tampon d’un élément.The annotation specifies that the function may freely read from and write to the one-element buffer. L’appelant doit fournir la mémoire tampon et l’initialiser.The caller must provide the buffer and initialize it.

Note

Comme _Out_, _Inout_ doivent s’appliquer à une valeur modifiable.Like _Out_, _Inout_ must apply to a modifiable value.


void InOutCallee(_Inout_ int *pInt)
{
   int i = *pInt;
   *pInt = 6;
}

void InOutCaller()
{
   int *pInt = new int;
   *pInt = 5;
   InOutCallee(pInt);
   delete pInt;
}

void BadInOutCaller()
{
   int *pInt = NULL;
   InOutCallee(pInt); // 'pInt' should not be NULL
}

Analyse du Code Visual Studio valide le fait que les appelants passer un pointeur non NULL à une mémoire tampon initialisé pour pIntet que, avant le retour, pInt est toujours non NULL et la mémoire tampon est initialisée.Visual Studio Code Analysis validates that callers pass a non-NULL pointer to an initialized buffer for pInt, and that, before return, pInt is still non-NULL and the buffer is initialized.

Exemple : Le _Inout_opt_ AnnotationExample: The _Inout_opt_ Annotation

_Inout_opt_ est identique à _Inout_, sauf que le paramètre d’entrée est autorisé à avoir la valeur NULL et, par conséquent, la fonction doit vérifier cela._Inout_opt_ is the same as _Inout_, except that the input parameter is allowed to be NULL and, therefore, the function should check for this.


void GoodInOutOptCallee(_Inout_opt_ int *pInt)
{
   if(pInt != NULL) {
      int i = *pInt;
      *pInt = 6;
   }
}

void BadInOutOptCallee(_Inout_opt_ int *pInt)
{
   int i = *pInt; // Dereferencing NULL pointer 'pInt'
   *pInt = 6;
}

void InOutOptCaller()
{
   int *pInt = NULL;
   GoodInOutOptCallee(pInt);
   BadInOutOptCallee(pInt);
}

Analyse du Code Visual Studio valide le fait que cette fonction vérifie les valeurs NULL avant d’accéder à la mémoire tampon et si pInt n’est pas NULL, que la mémoire tampon est initialisée par la fonction avant de retourner.Visual Studio Code Analysis validates that this function checks for NULL before it accesses the buffer, and if pInt is not NULL, that the buffer is initialized by the function before it returns.

Exemple : Le _Outptr_ AnnotationExample: The _Outptr_ Annotation

_Outptr_ est utilisé pour annoter un paramètre destiné à retourner un pointeur._Outptr_ is used to annotate a parameter that's intended to return a pointer. Le paramètre lui-même ne doit pas être NULL et la fonction appelée retourne un pointeur non NULL qu’il contient et ce pointeur pointe vers les données initialisées.The parameter itself should not be NULL, and the called function returns a non-NULL pointer in it and that pointer points to initialized data.


void GoodOutPtrCallee(_Outptr_ int **pInt)
{
   int *pInt2 = new int;
   *pInt2 = 5;

   *pInt = pInt2;
}

void BadOutPtrCallee(_Outptr_ int **pInt)
{
   int *pInt2 = new int;
   // Did not initialize pInt buffer before returning!
   *pInt = pInt2;
}

void OutPtrCaller()
{
   int *pInt = NULL;
   GoodOutPtrCallee(&pInt);
   BadOutPtrCallee(&pInt);
}

Analyse du Code Visual Studio valide le fait que l’appelant passe un pointeur non NULL *pInt, et que la mémoire tampon est initialisée par la fonction avant de retourner.Visual Studio Code Analysis validates that the caller passes a non-NULL pointer for *pInt, and that the buffer is initialized by the function before it returns.

Exemple : Le _Outptr_opt_ AnnotationExample: The _Outptr_opt_ Annotation

_Outptr_opt_ est identique à _Outptr_, sauf que le paramètre est facultatif, l’appelant peut passer un pointeur NULL pour le paramètre._Outptr_opt_ is the same as _Outptr_, except that the parameter is optional—the caller can pass in a NULL pointer for the parameter.


void GoodOutPtrOptCallee(_Outptr_opt_ int **pInt)
{
   int *pInt2 = new int;
   *pInt2 = 6;

   if(pInt != NULL) {
      *pInt = pInt2;
   }
}

void BadOutPtrOptCallee(_Outptr_opt_ int **pInt)
{
   int *pInt2 = new int;
   *pInt2 = 6;
   *pInt = pInt2; // Dereferencing NULL pointer 'pInt'
}

void OutPtrOptCaller()
{
   int **ppInt = NULL;
   GoodOutPtrOptCallee(ppInt);
   BadOutPtrOptCallee(ppInt);
}

Analyse du Code Visual Studio valide le fait que cette fonction vérifie les valeurs NULL avant *pInt est déréférencé, et que la mémoire tampon est initialisée par la fonction avant de retourner.Visual Studio Code Analysis validates that this function checks for NULL before *pInt is dereferenced, and that the buffer is initialized by the function before it returns.

Exemple : Le _réussite_ Annotation en association avec _Out_Example: The _Success_ Annotation in Combination with _Out_

Annotations peuvent être appliquées à la plupart des objets.Annotations can be applied to most objects. En particulier, vous pouvez annoter une fonction entière.In particular, you can annotate a whole function. L’une des caractéristiques d’une fonction plus évidents est qu’elle peut réussir ou échouer.One of the most obvious characteristics of a function is that it can succeed or fail. Mais comme l’association entre une mémoire tampon et sa taille, C/C++ ne peut pas exprimer fonction réussite ou l’échec.But like the association between a buffer and its size, C/C++ cannot express function success or failure. À l’aide de la _Success_ annotation, que vous pouvez déterminer la réussite d’une fonction ressemble.By using the _Success_ annotation, you can say what success for a function looks like. Le paramètre à la _Success_ annotation est simplement une expression que lorsqu’il est true indique que la fonction a réussi.The parameter to the _Success_ annotation is just an expression that when it is true indicates that the function has succeeded. L’expression peut être tout ce que l’analyseur d’annotation peut gérer.The expression can be anything that the annotation parser can handle. Les effets des annotations après le retour de la fonction sont appliquent uniquement lorsque la fonction réussit.The effects of the annotations after the function returns are only applicable when the function succeeds. Cet exemple montre comment _Success_ interagit avec _Out_ adoptent l’attitude.This example shows how _Success_ interacts with _Out_ to do the right thing. Vous pouvez utiliser le mot clé return pour représenter la valeur de retour.You can use the keyword return to represent the return value.


_Success_(return != false) // Can also be stated as _Success_(return)
bool GetValue(_Out_ int *pInt, bool flag)
{
   if(flag) {
      *pInt = 5;
      return true;
   } else {
      return false;
   }
}

Le _Out_ annotation provoque Visual Studio Code Analysis pour valider que l’appelant passe un pointeur non NULL dans une mémoire tampon pour pInt, et que la mémoire tampon est initialisée par la fonction avant de retourner.The _Out_ annotation causes Visual Studio Code Analysis to validate that the caller passes a non-NULL pointer to a buffer for pInt, and that the buffer is initialized by the function before it returns.

Meilleure pratique SALSAL Best Practice

Ajout d’Annotations au Code existantAdding Annotations to Existing Code

SAL est une technologie puissante qui vous permet d’améliorer la sécurité et la fiabilité de votre code.SAL is a powerful technology that can help you improve the security and reliability of your code. Une fois que vous allez SAL, vous pouvez appliquer la nouvelle compétence à votre travail quotidien.After you learn SAL, you can apply the new skill to your daily work. Dans le nouveau code, vous pouvez utiliser des spécifications SAL par conception dans l’ensemble ; dans le code plus ancien, vous pouvez ajouter des annotations de façon incrémentielle et augmenter ainsi les avantages chaque fois que vous mettez à jour.In new code, you can use SAL-based specifications by design throughout; in older code, you can add annotations incrementally and thereby increase the benefits every time you update.

En-têtes publics de Microsoft sont annotées déjà.Microsoft public headers are already annotated. Par conséquent, nous vous suggérons que dans vos projets vous tout d’abord annotez des fonctions de nœud feuille et les fonctions qui appellent les API Win32 pour tirer le meilleur parti.Therefore, we suggest that in your projects you first annotate leaf node functions and functions that call Win32 APIs to get the most benefit.

Lorsque annoterWhen Do I Annotate?

Voici quelques indications :Here are some guidelines:

  • Annoter tous les paramètres de pointeur.Annotate all pointer parameters.

  • Annoter des annotations de la plage de valeurs afin que l’analyse du Code peut garantir la sécurité des mémoires tampons et pointeur.Annotate value-range annotations so that Code Analysis can ensure buffer and pointer safety.

  • Annoter des règles de verrouillage et des effets secondaires du verrouillage.Annotate locking rules and locking side effects. Pour plus d’informations, consultez comportement de verrouillage annotant.For more information, see Annotating Locking Behavior.

  • Annoter les propriétés du pilote et autres propriétés spécifiques à un domaine.Annotate driver properties and other domain-specific properties.

    Ou vous pouvez annoter tous les paramètres pour clarifier votre intention tout au long de rendre et pour faciliter le travail vérifier que les annotations ont été effectuées.Or you can annotate all parameters to make your intent clear throughout and to make it easy to check that annotations have been done.

Blog de l’équipe analyse du codeCode Analysis Team Blog

Voir aussiSee Also

Utilisation d’Annotations SAL pour réduire les défauts du Code C/C++ annotation des paramètres de fonction et valeurs de retour annotation du comportement de la fonction annoter des Structs et Classes annotation du comportement de verrouillage spécifiant le moment où une Annotation est applicable et meilleures pratiques et exemplesUsing SAL Annotations to Reduce C/C++ Code Defects Annotating Function Parameters and Return Values Annotating Function Behavior Annotating Structs and Classes Annotating Locking Behavior Specifying When and Where an Annotation Applies Best Practices and Examples