C26100C26100

avertissement C26100 : condition de concurrence.warning C26100: Race condition. Variable <var > doivent être protégées par le verrou <verrou >.Variable <var> should be protected by lock <lock>.

Le _Guarded_by_ annotation dans le code spécifie le verrou à utiliser pour protéger une variable partagée.The _Guarded_by_ annotation in the code specifies the lock to use to guard a shared variable. C26100 d’avertissement est généré lorsque le module de protection du contrat est violé.Warning C26100 is generated when the guard contract is violated.

ExempleExample

L’exemple suivant génère l’avertissement C26100, car il existe une violation de la _Guarded_by_ contrat.The following example generates warning C26100 because there is a violation of the _Guarded_by_ contract.

CRITICAL_SECTION gCS;   

_Guarded_by_(gCS) int gData;   

typedef struct _DATA {   
   _Guarded_by_(cs) int data;   
   CRITICAL_SECTION cs;   
} DATA;   

void Safe(DATA* p) {   
   EnterCriticalSection(&p->cs);   
   p->data = 1; // OK   
   LeaveCriticalSection(&p->cs);   
   EnterCriticalSection(&gCS);   
   gData = 1; // OK   
   LeaveCriticalSection(&gCS);   
}   

void Unsafe(DATA* p) {   
   EnterCriticalSection(&p->cs);   
   gData = 1; // Warning C26100 (wrong lock)   
   LeaveCriticalSection(&p->cs);   
}  

La violation de contrat se produit, car un verrou incorrect est utilisé dans la fonction Unsafe.The contract violation occurs because an incorrect lock is used in the function Unsafe. Dans ce cas, gCS est le verrou approprié à utiliser.In this case, gCS is the correct lock to use.

ExempleExample

Une variable partagée doit parfois être protégés pour un accès en écriture, mais pas pour l’accès en lecture.Occasionally a shared variable only has to be guarded for write access but not for read access. Dans ce cas, utilisez le _Write_guarded_by_ annotation, comme indiqué dans l’exemple suivant.In that case, use the _Write_guarded_by_ annotation, as shown in the following example.


CRITICAL_SECTION gCS;   

_Guarded_by_(gCS) int gData;   

typedef struct _DATA2 {   
   _Write_guarded_by_(cs) int data;   
   CRITICAL_SECTION cs;   
} DATA2;   

int Safe2(DATA2* p) {   
   // OK: read does not have to be guarded   
   int result = p->data;   
   return result;   
}   

void Unsafe2(DATA2* p) {   
   EnterCriticalSection(&gCS);   
   // Warning C26100 (write has to be guarded by p->cs)   
   p->data = 1;   
   LeaveCriticalSection(&gCS);   
}   

Cet exemple génère également l’avertissement C26100, car elle utilise un verrou incorrect dans la fonction Unsafe2.This example also generates warning C26100 because it uses an incorrect lock in the function Unsafe2.