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 comment une fonction utilise ses paramètres, les hypothèses sur lesquelles elle émet à leur sujet et les garanties qu’elle quand elle s’achève.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>. Analyse du code Visual Studio pour C++ utilise des 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 pilote 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++ fournissent uniquement limitée aux développeurs de manière cohérente express 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 plus en détail afin que les développeurs qui utilisent leur peuvent de 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.

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

En termes simples, SAL est un moyen peu coûteux 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 rend le Code plus précieuxSAL Makes Code More Valuable

SAL peut vous aider à rendre la conception de votre code plus compréhensible, pour les utilisateurs et les outils d’analyse du code.SAL can help you make your code design more understandable, both for humans and for code analysis tools. Considérez cet exemple 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  
);  

Savoir 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 assurées pour garantir l’exactitude du programme.When a function is implemented or called, certain properties must be maintained to ensure program correctness. Il suffit à 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 les annotations SAL, vous devrez s’appuient sur la documentation ou des commentaires de code.Without SAL annotations, you'd have to rely on documentation or code comments. Voici quelles 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 chevauche.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, voir éviter les dépassements de mémoire tampon. »For more information, see Avoiding Buffer Overruns."

La documentation contient deux bits d’information qui suggère que votre code doit conserver certaines propriétés pour garantir 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 des commentaires informelles.However, the compiler can't read the documentation or informal comments. Il ne sait pas qu’il existe une relation entre les deux mémoires tampons et count, et elle aussi ne peut pas efficacement deviner sur 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 de clarté sur les propriétés et l’implémentation de la fonction, comme indiqué 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 ressemblent aux informations contenues dans la documentation MSDN, mais ils sont plus concises et elles 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 comprendre rapidement 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 qui fournit des SAL peuvent améliorer l’efficacité et l’efficacité des outils d’analyse de code automatique dans 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 de désactiver par un common.This implementation contains a common off-by-one error. Heureusement, l’auteur du code inclus l’annotation de taille de mémoire tampon SAL, un outil d’analyse du 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 de base SALSAL Basics

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

CategoryCategory Annotation du paramètreParameter Annotation DescriptionDescription
Entrée de la fonction appeléeInput to called function _In_ Données sont passées à la fonction appelée et sont traitées comme étant en lecture seule.Data is passed to the called function, and is treated as read-only.
Entrée à fonction appelée et de sortie à l’appelantInput to called function, and output to caller _Inout_ Données utilisables sont transmises à la fonction et qu’elle sont potentiellement modifiées.Usable data is passed into the function and potentially is modified.
Sortie vers l’appelantOutput to caller _Out_ L’appelant fournit uniquement un 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 appelant que la sortie.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 explicites plus 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 variation couramment utilisée des annotations base indique qu’un paramètre de pointeur est facultatif, s’il est NULL, la fonction peut encore réussir dans 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 effectuer la distinction entre les paramètres obligatoires et facultatifs :This table shows how to distinguish between required and optional parameters:

Les paramètres sont requisParameters are required Les paramètres sont facultatifsParameters are optional
Entrée de la fonction appeléeInput to called function _In_ _In_opt_
Entrée à fonction appelée 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 aider à identifier les valeurs possibles sans être initialisé et utilise de pointeur null non valide 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ée.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 à cette fin de 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 base.This section shows code examples for the basic SAL annotations.

À l’aide de l’outil d’analyse de Code Visual Studio à trouver 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 générer, exécuter l’analyse du Code sur la Solution.On the menu bar, choose Build, Run Code Analysis on Solution.

    Envisagez le In\ 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:

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

Exemple : Le In\ 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 du tampon de l’é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 « en lecture seule »._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 pointeur non scalaires._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 dans cet exemple, il vérifie que les appelants passer un pointeur non Null à un 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 le pointeur ne peut pas être NULL.In this case, pInt pointer cannot be NULL.

Exemple : Le In_opt\ AnnotationExample: The In_opt\ Annotation

_In_opt_ est le même que _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 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’initialisation de la mémoire tampon avant l’appel. la fonction appelée promet initialisez-le avant d’être retournée.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 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 d’être retournée.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 le même que _Out_, sauf que le paramètre peut ê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 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 d’être retournée.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 indique que la fonction peut librement lire et écrire dans le 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 vérifie que les appelants passer un pointeur non NULL à un 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 le même que _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 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 d’être retournée.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 qui est conçue pour 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 dedans, 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 que l’appelant passe un pointeur non NULL *pInt, et que la mémoire tampon est initialisée par la fonction avant d’être retournée.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 le même que _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 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 d’être retournée.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 Success\ Annotation en combinaison avec Out\Example: The Success\ Annotation in Combination with Out\

Les 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 la plus évidentes 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, vous pouvez dire 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 pour le _Success_ annotation est simplement une expression que lorsqu’il a la valeur 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 applicables 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_ pour effectuer l’opération droite.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 l’analyse du Code Visual Studio 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 d’être retournée.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.

Il est recommandé SALSAL Best Practice

Ajout d’Annotations au Code existantAdding Annotations to Existing Code

SAL est une technologie puissante et qui peut vous aider à 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 découvrez SAL, vous pouvez appliquer les nouvelles compétences pour 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 déjà annotés.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 des 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 conseils :Here are some guidelines:

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

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

  • Annoter les règles de verrouillage et les effets secondaires du verrouillage.Annotate locking rules and locking side effects. Pour plus d’informations, consultez annotation du comportement de verrouillage.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 bien, vous pouvez annoter tous les paramètres qui permettent de clarifier votre intention dans l’ensemble 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++ Using SAL Annotations to Reduce C/C++ Code Defects
Annotation de paramètres de fonction et valeurs de retour Annotating Function Parameters and Return Values
Annotation du comportement de la fonction Annotating Function Behavior
Les structures et Classes d’annotation Annotating Structs and Classes
Annotation du comportement de verrouillage Annotating Locking Behavior
Spécification de quand et où une Annotation est applicable Specifying When and Where an Annotation Applies
Meilleures pratiques et exemplesBest Practices and Examples