Erreurs et avertissements du compilateur (C++) - Index

Remonter à Référence C++

Cette section décrit les messages d'erreur et d'avertissement du compilateur C++ de RAD Studio.

Messages sans nombres

• Fin de programme anormale (C++)
• Application en cours d'exécution (C++)
• Erreur de division (C++)
• Exemple pour les messages d'erreur d'"utilisation temporaire..." (C++)
• Erreur de calcul à virgule flottante : Erreur de division par 0 OU de calcul à virgule flottante : Erreur de domaine ou de calcul à virgule flottante : Dépassement de capacité (C++)
• Erreur de calcul à virgule flottante : Perte de précision partielle OU Erreur de calcul à virgule flottante : Débordement inférieur (C++)
• Erreur de calcul à virgule flottante : Faute de pile (C++)
• Messages d'information (C++)
• Initialisation d'une énumération avec un type (C++)
• nom n'est pas un identificateur correct (C++)
• Affectation de pointeur Null (C++)
• O2237: Les programmes DPMI doivent utiliser le modèle de mémoire large (C++)
• Formats en virgule flottante Printf/Scanf non liés (C++)
• Fonction virtuelle pure appelée (C++)
• Débordement de pile (C++)
• Impossible d'effectuer le lien (C++)
• Erreur inattendue détectée durant le lien (C++)
• Fin anattendue pendant la compilation Module Seg:offset OU Fin inattendue pendant la liaison Module Seg:offset (C++)

Rubriques d'aide des messages d'erreur

• E2000: Instructions 286/287 non activées (C++)
• E2001: Constructeurs et destructeurs non autorisés dans la section __automated (C++)
• E2002: Seules les fonctions __fastcall sont autorisées dans la section __automated (C++)
• E2003: Définition de données membre non autorisée dans la section __automated (C++)
• E2004: Seule la clause read (lecture) ou write (écriture) est autorisée dans la déclaration de propriété de la section __automated (C++)
• E2005: Redéclaration de propriété non autorisée dans la section __automated (C++)
• E2006: Les programmes protégés par CodeGuard doivent utiliser le modèle de mémoire large et être prévus pour Windows (C++)
• E2007: Dispid n'est autorisé que dans les sections __automated (C++)
• E2008: Les fonctions d'accès à la propriété publiée doivent utiliser la convention d'appel __fastcall (C++)
• E2009: Tentative d'accorder ou de réduire l'accès à 'identificateur' (C++)
• E2010: Impossible d'ajouter ou de soustraire des symboles relogeables (C++)
• E2011: Il est incorrect de prendre l'adresse d'un champ de bits (C++)
• E2012: Impossible de prendre l'adresse de 'main' (C++)
• E2013: 'fonction1' ne peut pas être distinguée de 'fonction2' (C++)
• E2014: Membre ambigu : 'membre1' et 'membre2' (C++)
• E2015: Ambiguïté entre 'fonction1' et 'fonction2' (C++)
• E2016: Redéfinition ambiguë du membre de base virtuel 'fonction_de_base': 'fonction_dérivée' (C++)
• E2017: Nom de membre 'nom' ambigu (C++)
• E2018 : Impossible d'intercepter 'identificateur' -- 'identificateur' de classe de base ambigu (C++)
• E2019: 'identificateur' ne peut pas être déclaré dans une union anonyme (C++)
• E2020: Union anonyme globale non statique (C++)
• E2021: Un tableau doit avoir au moins un élément (C++)
• E2022: Taille de tableau trop grande (C++)
• E2023: Tableau de références non autorisé (C++)
• E2024: Impossible de modifier un objet const (C++)
• E2025: Affectation de 'this' non autorisée, utilisez plutôt l'opérateur X:: new (C++)
• E2026: Instruction d'assembleur trop longue (C++)
• E2027: L'adresse d'un emplacement mémoire est obligatoire (C++)
• E2028: L'opérateur -> doit renvoyer un pointeur ou une classe (C++)
• E2029: 'identificateur' doit être une classe ou une structure précédemment définie (C++)
• E2030: Caractère de fin de ligne mal placé (C++)
• E2031: Transtypage impossible de 'type1' en 'type2' (C++)
• E2032: Utilisation incorrecte d'un pointeur de clôture (closure) (C++)
• E2033: Instruction continue mal placée (C++)
• E2034: Impossible de convertir 'type1' en 'type2' (C++)
• E2035: Les conversions d'une classe en elle-même ou en classe de base ne sont pas autorisées (C++)
• E2036: L'opérateur de conversion ne peut pas avoir de spécification de type de retour (C++)
• E2037: Le constructeur 'constructeur' n'est pas autorisé (C++)
• E2038: Impossible de déclarer ou de définir 'identificateur' ici : espace de nommage incorrect (C++)
• E2039: Séparateur décimal mal placé (C++)
• E2040: Terminaison de déclaration incorrecte (C++)
• E2041: Utilisation incorrecte du mot clé default (C++)
• E2042: Déclarer l'opérateur delete (void*) ou (void*, size_t) (C++)
• E2044: L'opérateur delete doit retourner void (C++)
• E2045: Le nom du destructeur doit correspondre au nom de la classe (C++)
• E2046: Format de nom de fichier incorrect dans la directive include OU format de nom de fichier incorrect dans la directive line (C++)
• E2047: Syntaxe de la directive 'directive' incorrecte (C++)
• E2048: Directive de préprocesseur inconnue : 'identificateur' (C++)
• E2049: Le type de classe 'type' ne peut pas être marqué comme __declspec(delphireturn) (C++)
• E2050: La classe __declspec(delphireturn) 'classe' doit avoir exactement une donnée membre (C++)
• E2051: Utilisation incorrecte du point (C++)
• E2052: Conflits de la fonction dynamique 'fonction' avec la classe de base 'classe' (C++)
• E2053: Directive elif mal placée (C++)
• E2054: Instruction else mal placée (C++)
• E2055: Directive else mal placée (C++)
• E2056: Directive endif mal placée (C++)
• E2057: Spécification d'exception non autorisée ici (C++)
• E2058: La variable de gestion des exceptions ne peut pas être utilisée ici (C++)
• E2059: Langage inconnu, doit être du C ou du C++ (C++)
• E2060: Utilisation incorrecte de la virgule flottante (C++)
• E2061: Les amis doivent être des fonctions ou des classes (C++)
• E2062: Indirection incorrecte (C++)
• E2063: Initialisation incorrecte (C++)
• E2064: Impossible d'initialiser 'type1' avec 'type2' (C++)
• E2065: L'utilisation du symbole d'espace de nommage 'symbole' crée un conflit avec un intrinsèque du même nom (C++)
• E2066: Information non disponible (C++)
• E2066: Héritage MOM invalide (C++)
• E2067: Le type renvoyé par 'main' doit être int (C++)
• E2068: 'identificateur' n'est pas une donnée membre non statique et ne peut pas être initialisé ici (C++)
• E2069 : Utilisation incorrecte du pointeur de membre (C++)
• E2070: Utilisation incorrecte de l'espace de nommage 'identificateur' (C++)
• E2071: L'opérateur new doit avoir un paramètre initial de type size_t (C++)
• E2072: L'opérateur new doit renvoyer un objet de type void (C++)
• E2073: Rien n'est autorisé après l'option pragma pop (C++)
• E2074: La valeur après -g ou -j doit être comprise entre 0 et 255 inclus (C++)
• E2075: Option 'type' incorrecte : option (C++)
• E2076: Opérateur surchargeable attendu (C++)
• E2077: 'opérateur' doit être déclaré avec un ou sans paramètre (C++)
• E2078: 'opérateur' doit être déclaré avec un ou deux paramètres (C++)
• E2079: 'fonction' doit être déclarée sans paramètres (C++)
• E2080: La fonction 'fonction' doit être déclarée avec un paramètre (C++)
• E2081: 'fonction' doit être déclarée avec deux paramètres (C++)
• E2082: 'identificateur' doit être une fonction membre ou avoir un paramètre de type classe (C++)
• E2083: Le dernier paramètre de 'opérateur' doit être de type 'int' (C++)
• E2084: Les noms de paramètres sont utilisés seulement avec un corps de fonction (C++)
• E2085: Addition de pointeurs incorrecte (C++)
• E2086: Soustraction de pointeurs incorrecte (C++)
• E2087: Utilisation incorrecte du pointeur (C++)
• E2088: Syntaxe incorrecte pour la définition de fonctions pures (C++)
• E2089: L'identificateur 'identificateur' ne peut pas avoir un qualificateur de type (C++)
• E2090: Le qualificateur 'identificateur' n'est pas un nom de classe ou d'espace de nommage (C++)
• E2091: Les fonctions ne peuvent pas renvoyer des tableaux ou des fonctions (C++)
• E2092: La classe de stockage 'classe de stockage' n'est pas autorisée ici (C++)
• E2093: Opérateur 'opérateur' non implémenté dans le type 'type' pour les arguments du même type (C++)
• E2094: Opérateur 'opérateur' non implémenté dans le type 'type' pour les arguments de type 'type' (C++)
• E2095: Littéral chaîne non autorisé dans ce contexte (C++)
• E2096: Opération de structure incorrecte (C++)
• E2097: Instanciation explicite uniquement autorisée dans les fichiers ou les espaces de nommage (C++)
• E2098: Un déclarateur de spécialisation explicite "template<>" est maintenant nécessaire (C++)
• E2099: Spécialisation explicite uniquement autorisée dans les fichiers ou les espaces de nommage (C++)
• E2100: Liste de déclarateurs de modèles incorrecte (C++)
• E2101: Le mot clé 'export' doit précéder une déclaration de modèle (C++)
• E2102: Impossible d'utiliser le modèle 'modèle' sans spécifier des paramètres de spécialisation (C++)
• E2103: Une instanciation explicite doit être utilisée avec une classe ou une fonction modèle (C++)
• E2104: Utilisation incorrecte du mot clé template (C++)
• E2105: Le qualificateur 'modèle' doit spécifier un nom de modèle membre (C++)
• E2106: Une spécialisation explicite doit être utilisée avec une classe ou une fonction modèle (C++)
• E2107: Utilisation incorrecte du modèle 'modèle' (C++)
• E2108: Utilisation incorrecte de typedef 'identificateur' (C++)
• E2109: Type non autorisé (C++)
• E2110: Conversion de type incompatible (C++)
• E2111: Le type 'nomtype' ne peut pas être défini ici (C++)
• E2112: Directive d'unité inconnue : 'directive' (C++)
• E2113 : Conflits de fonction virtuelle 'fonction1' avec la classe de base 'base' (C++)
• E2114: Plusieurs classes de base nécessitent des noms de classes explicites (C++)
• E2115: Champ de bits trop grand (C++)
• E2116: Les champs de bits doivent contenir au moins un bit (C++)
• E2117: Les champs de bits doivent être des entiers signés ou non signés (C++)
• E2118: Les champs de bits doivent être de type entier (C++)
• E2119: Pause utilisateur (C++)
• E2120: Impossible d'appeler 'main' depuis le programme (C++)
• E2121: ) manquante dans l'appel de fonction (C++)
• E2122: L'appel de fonction s'est terminé par une exception non gérée 'valeur' à l'adresse 'adresse' (C++)
• E2123: La classe 'classe' ne doit pas contenir des fonctions pures (C++)
• E2124: Appel de fonction incorrect (C++)
• E2125: Le compilateur n'a pas pu générer de constructeur de copie pour la classe 'classe' OU Le compilateur n'a pas pu générer de constructeur par défaut pour la classe 'classe' OU Le compilateur n'a pas pu générer d'opérateur = pour la classe 'classe' (C++)
• E2126: Case a contourné l'initialisation d'une variable locale (C++)
• E2127: Instruction case manquante : (C++)
• E2128: Case en dehors du switch (C++)
• E2129: Constante caractère trop longue (ou vide) (C++)
• E2130: Définition de propriété circulaire (C++)
• E2131: Les objets de type 'type' ne peuvent pas être initialisés avec des { } (C++)
• E2132: Les modèles et les opérateurs surchargés ne peuvent pas avoir de lien C (C++)
• E2133: Impossible d'exécuter la commande 'commande' (C++)
• E2134: Accolade fermante manquante dans une instruction composée (C++)
• E2135: Un constructeur/destructeur ne peut pas être déclaré 'const' ou 'volatile' (C++)
• E2136: Un constructeur ne peut pas avoir de spécification de type de retour (C++)
• E2137: Un destructeur pour 'classe' est nécessaire dans l'expression conditionnelle (C++)
• E2138: Conflit de modificateurs de type (C++)
• E2139: ; manquant dans la déclaration (C++)
• E2140: La déclaration n'est pas autorisée ici (C++)
• E2141: Erreur de syntaxe de déclaration (C++)
• E2142: La classe de base 'classe' contient des fonctions qui peuvent être réparties de façon dynamique (C++)
• E2143: La fonction 'fonction' de classe de base correspondante a un numéro de répartition différent (C++)
• E2144: La fonction de classe de base correspondante 'fonction' n'est pas dynamique (C++)
• E2145: Les fonctions 'fonction1' et 'fonction2' utilisent le même numéro de répartition (C++)
• E2146: Vous devez fournir un identificateur à déclarer (C++)
• E2147: 'identificateur' ne peut pas démarrer une déclaration de paramètre (C++)
• E2148: La valeur de l'argument par défaut a été redéclarée pour le paramètre 'paramètre' (C++)
• E2149: La valeur de l'argument par défaut a été redéclarée (C++)
• E2150: Mauvaise correspondance de type dans la valeur de l'argument par défaut (C++)
• E2151: Mauvaise correspondance de type dans la valeur par défaut pour le paramètre 'paramètre' (C++)
• E2152: L'expression par défaut ne doit pas utiliser des variables locales (C++)
• E2153: La directive define nécessite un identificateur (C++)
• E2154: Impossible de définir 'identificateur' en utilisant un alias d'espace de nommage (C++)
• E2155: Trop d'instructions default (C++)
• E2156: Default en dehors du switch (C++)
• E2157: La suppression d'un objet nécessite exactement une conversion en opérateur de pointeur (C++)
• E2158: L'opérande de 'delete' doit être un pointeur non-const (C++)
• E2159: Tentative de dériver une classe far depuis la base huge 'base' (C++)
• E2160: Tentative de dériver une classe far depuis la base near 'base' (C++)
• E2161: Tentative de dériver une classe huge depuis la base far 'base' (C++)
• E2162: Tentative de dériver une classe huge depuis la base near 'base' (C++)
• E2163: Tentative de dériver une classe near depuis la base far 'base' (C++)
• E2164: Tentative de dériver une classe near depuis la base huge 'base' (C++)
• E2165: Un destructeur ne peut pas avoir de spécification de type de retour (C++)
• E2166: Le destructeur de 'classe' n'est pas accessible (C++)
• E2167: 'fonction' a été précédemment déclarée avec le langage 'langage' (C++)
• E2168: Division par zéro (C++)
• E2169: 'identificateur' spécifie des accès multiples ou dupliqués (C++)
• E2170: La classe de base 'classe' est incluse plusieurs fois (C++)
• E2171: Le corps a déjà été défini pour la fonction 'fonction' (C++)
• E2172: Case dupliqué (C++)
• E2173: Le gestionnaire dupliqué pour 'type1' avait déjà 'type2' (C++)
• E2174: Le gestionnaire spécifié doit être le dernier (C++)
• E2175: Trop de classes de stockage dans la déclaration (C++)
• E2176: Trop de types dans la déclaration (C++)
• E2177: Redéclaration de #pragma package avec différents arguments (C++)
• E2178: Conflit de nom VIRDEF pour 'fonction' (C++)
• E2179: virtual spécifié plusieurs fois (C++)
• E2180: Numéro dispid déjà utilisé par l'identificateur (C++)
• E2181: Impossible de redéfinir une fonction 'dynamique/virtuelle' avec une fonction 'dynamique/virtuelle' (C++)
• E2182: Paramètre incorrect pour __emit__ (C++)
• E2183: Le fichier doit contenir au moins une déclaration externe (C++)
• E2184: Erreur de syntaxe pour une énumération (C++)
• E2185 : La valeur de 'identificateur' n'est pas comprise dans la plage de 'nom-type' (C++)
• E2186: Fin de fichier inattendue dans le commentaire qui commence à la ligne 'numéro de ligne' (C++)
• E2187: Fin de fichier inattendue dans l'instruction conditionnelle qui commence à la ligne 'numéro de ligne' (C++)
• E2188: Syntaxe de l'expression (C++)
• E2189: La variable extern ne peut pas être initialisée (C++)
• E2190: Accolade fermante inattendue (C++)
• E2191: '__far16' ne peut être utilisé qu'avec '__pascal' ou '__cdecl' (C++)
• E2192: Trop peu de paramètres dans l'appel (C++)
• E2193: Trop peu de paramètres dans l'appel à 'fonction' (C++)
• E2194: Impossible de trouver le fichier 'nomfichier' (C++)
• E2195: Impossible d'évaluer l'appel de fonction (C++)
• E2196: Impossible de prendre l'adresse de la fonction membre 'fonction' (C++)
• E2197: Nom de fichier trop long (C++)
• E2198: Ce n'est pas un type de format d'expression correct (C++)
• E2199: La fonction amie modèle 'fonction' doit être préalablement déclarée (C++)
• E2200: Les fonctions ne peuvent pas faire partie d'une structure ou d'une union (C++)
• E2201: Trop de données globales définies dans le fichier (C++)
• E2202: Goto est interdit dans un gestionnaire d'exception (C++)
• E2203: Goto évite l'initialisation d'une variable locale (C++)
• E2204: Le groupe a dépassé la taille maximum : 'nom' (C++)
• E2205: Type 'type' incorrect dans la section __automated (C++)
• E2206: Caractère 'caractère' (0x'valeur') incorrect (C++)
• E2207: Conversion implicite de 'type1' en 'type2' non autorisée (C++)
• E2208: Impossible d'accéder à une portée inactive (C++)
• E2209: Impossible d'ouvrir le fichier include 'nomfichier' (C++)
• E2210: Le membre de référence 'membre' n'est pas initialisé (C++)
• E2211: L'assemblage en ligne n'est pas autorisé dans les fonctions inline et template (C++)
• E2212: La fonction a été définie inline après avoir été utilisée comme extern (C++)
• E2213: 'expression' incorrecte dans la redéfinition de portée (C++)
• E2214: Impossible d'avoir des 'données fonction/statique non inline' dans une classe locale (C++)
• E2215: Spécification de lien non autorisée (C++)
• E2216: Impossible de créer turboc.$ln (C++)
• E2217: Les données locales dépassent la limite de taille du segment (C++)
• E2218: Les modèles ne peuvent être déclarés qu'au niveau d'un espace de nommage ou d'une classe (C++)
• E2219: Nombre incorrect d'arguments dans l'appel de la macro 'macro' (C++)
• E2220: Séparateur d'arguments de macro incorrect (C++)
• E2221: Erreur de syntaxe dans l'argument de macro (C++)
• E2222: Développement de macro trop long (C++)
• E2223: Trop de séparateurs décimaux (C++)
• E2224: Trop d'exposants (C++)
• E2225: Trop d'initialiseurs (C++)
• E2226: Paramètre supplémentaire dans l'appel (C++)
• E2227: Paramètre supplémentaire dans l'appel de fonction (C++)
• E2228: Trop de messages d'erreur ou d'avertissement (C++)
• E2229: Le membre 'membre' a le même nom que sa classe (C++)
• E2230: L'initialisation de données membre en ligne nécessite une expression constante intégrale (C++)
• E2231: Le membre 'membre' ne peut pas être utilisé sans objet (C++)
• E2232: Membre 'membre' constante/référence dans la classe sans constructeur (C++)
• E2233: Impossible d'initialiser un membre de classe ici (C++)
• E2234: Référence mémoire attendue (C++)
• E2235: Une fonction membre doit être appelée ou son adresse prise (C++)
• E2236: 'identificateur' manquant dans la redéfinition de portée (C++)
• E2238: Plusieurs déclarations pour 'identificateur' (C++)
• E2239: 'identificateur' doit être une fonction membre (C++)
• E2240: Conversion de pointeur near non autorisée (C++)
• E2241: Les classes de style VCL ont besoin de destructeurs virtuels (C++)
• E2242: Le spécificateur a besoin d'un type de classe de style Delphi (C++)
• E2243: Un tableau alloué avec 'new' ne peut pas avoir d'initialisateur (C++)
• E2244: 'new' et 'delete' ne sont pas gérés (C++)
• E2245: Impossible d'allouer une référence (C++)
• E2246: x n'est pas une hiérarchie de classes d'héritage simples, publiques, abstraites sans données (C++)
• E2247: 'membre' n'est pas accessible (C++)
• E2248: Impossible de trouver un constructeur par défaut pour initialiser un élément de tableau de type 'classe' (C++)
• E2249: = attendu (C++)
• E2250: Aucune classe de base à initialiser (C++)
• E2251: Impossible de trouver un constructeur par défaut pour initialiser la classe de base 'classe' (C++)
• E2252: 'catch' attendu (C++)
• E2253: La convention d'appel doit être attribuée au type de fonction, non au closure (C++)
• E2254: : attendu après private/protected/private (C++)
• E2255: Utiliser :: pour prendre l'adresse d'une fonction membre (C++)
• E2256: Pas de : qui suit le ? (C++)
• E2257: , attendue (C++)
• E2258: Une déclaration était attendue (C++)
• E2259: Valeur par défaut manquante (C++)
• E2260: Une valeur par défaut manque après le paramètre 'paramètre' (C++)
• E2261: L'utilisation d'un dispid avec une propriété nécessite un getter ou un setter (C++)
• E2262: '__except' ou '__finally' attendu après '__try' (C++)
• E2263: La gestion des exceptions n'est pas activée (C++)
• E2264: Expression attendue (C++)
• E2265: Aucun signe de fin dans le nom de fichier (C++)
• E2266: Aucun nom de fichier donné (C++)
• E2267: La première base doit être une classe VCL (C++)
• E2268: Appel à une fonction 'fonction' non définie (C++)
• E2269: La fonction 'fonction' n'est pas disponible (C++)
• E2270: > attendu (C++)
• E2271: Il manque un libellé à l'instruction goto (C++)
• E2272: Identificateur attendu (C++)
• E2273: 'main' ne peut pas être déclaré comme statique ou en ligne (C++)
• E2274: < attendu (C++)
• E2275: Accolade ouvrante attendue (C++)
• E2276: ( attendue (C++)
• E2277: Lvalue nécessaire (C++)
• E2278: Les classes de base multiples ne sont pas gérées pour les classes Delphi (C++)
• E2279: Impossible de trouver le constructeur par défaut pour initialiser le membre 'identificateur' (C++)
• E2280: Identificateur de membre attendu (C++)
• E2281: Identificateur1 nécessite la définition de Identificateur2 comme type pointeur (C++)
• E2282: Nom d'espace de nommage attendu (C++)
• E2283: Utilisez . ou -> pour appeler 'fonction' (C++)
• E2284: Utilisez . ou -> pour appeler 'membre', ou & pour prendre son adresse (C++)
• E2285: Impossible de trouver une correspondance pour le(s) 'argument(s)' (C++)
• E2286: Résolution de fonction surchargée non gérée (C++)
• E2287: Nom manquant dans le paramètre 'numéro' (C++)
• E2288: Pointeur sur structure nécessaire du côté gauche de -> ou ->* (C++)
• E2289: Les sections __published ou __automated ne sont gérées que par les classes Delphi (C++)
• E2290: ] manquant dans 'code' (C++)
• E2291: Accolade attendue (C++)
• E2292: La fonction doit renvoyer une valeur (C++)
• E2293: ) attendue (C++)
• E2294: Structure nécessaire sur le côté gauche de . ou .* (C++)
• E2295: Trop de spécialisations de modèle candidat depuis 'spécificateur' (C++)
• E2296: Modèles non gérés (C++)
• E2297: 'this' ne peut être utilisé que dans une fonction membre (C++)
• E2298: Impossible de créer 'fonction' à partir de la fonction modèle 'modèle' (C++)
• E2299: Impossible de créer une spécialisation de modèle à partir de 'spécificateur' (C++)
• E2300: Impossible de générer un type correspondant de spécialisation pour 'spécificateur' (C++)
• E2301: Impossible d'utiliser des modèles dans les arguments closure ; utilisez un typedef (C++)
• E2302: Pas d'informations de type (C++)
• E2303: Nom de type attendu (C++)
• E2304: La variable 'variable' Constant/Reference doit être initialisée (C++)
• E2305: Impossible de trouver 'class::class' ('class' &) pour copier un vecteur OU Impossible de trouver 'class'::operator=('class'&) pour copier un vecteur (C++)
• E2306: Les classes de base virtuelles ne sont pas gérées par les classes Delphi (C++)
• E2307: Le type 'type' n'est pas une classe définie avec des fonctions virtuelles (C++)
• E2308: L'instruction 'do' doit avoir un 'while' (C++)
• E2309: Assembleur Inline non autorisé (C++)
• E2310: Seules les fonctions membre peuvent être 'const' ou 'volatile' (C++)
• E2311: La fonction non-virtuelle 'fonction' est déclarée pure (C++)
• E2312: 'constructeur' n'est pas une classe de base non ambiguë de 'classe' (C++)
• E2313: Expression constante nécessaire (C++)
• E2314: Appel d'une non fonction (C++)
• E2315: 'Membre' n'est pas un membre de 'classe', car le type n'est pas encore défini (C++)
• E2316: 'identificateur' n'est pas un membre de 'structure' (C++)
• E2317: 'identificateur' n'est pas un paramètre (C++)
• E2318: 'type' n'est pas un type de classe polymorphe (C++)
• E2319: 'identificateur' n'est pas une classe de base publique de 'type de classe' (C++)
• E2320: Expression de type scalaire attendue (C++)
• E2321: La déclaration ne spécifie pas un repère ou un identificateur (C++)
• E2322: Format numérique incorrect (C++)
• E2323: Suffixe numérique incorrect (C++)
• E2324: Constante numérique trop grande (C++)
• E2325: Chiffre octal incorrect (C++)
• E2326: Utilisez __declspec(spec1[, spec2]) pour combiner plusieurs __declspecs (C++)
• E2327: Les opérateurs ne doivent pas avoir de valeurs d'argument par défaut (C++)
• E2328: Les classes avec des propriétés ne peuvent pas être copiées par valeur (C++)
• E2329: Combinaison incorrecte d'instruction et d'opérandes (C++)
• E2330: Un opérateur doit être déclaré comme une fonction (C++)
• E2331: Nombre de contextes d'option admissibles dépassé (C++)
• E2332: La variable 'variable' a été optimisée et n'est pas disponible (C++)
• E2333: Le membre de classe 'membre' a été déclaré en dehors de sa classe (C++)
• E2334: Le membre de l'espace de nommage 'identificateur' a été déclaré en dehors de son espace de nommage (C++)
• E2335: 'fonction' surchargée ambiguë dans ce contexte (C++)
• E2336: Le pointeur sur la fonction surchargée 'fonction' ne correspond pas à 'type' (C++)
• E2337: Seule une fonction d'un ensemble de fonctions surchargées peut être "C" (C++)
• E2338: Les overlays ne sont supportés que dans les modèles mémoire medium, large et huge (C++)
• E2339: Impossible de surcharger 'main' (C++)
• E2340: Non concordance de type dans le paramètre 'nombre' (C++)
• E2341: Non concordance de type dans le paramètre 'numéro' dans l'appel à 'fonction' (C++)
• E2342: Non concordance de type dans le paramètre 'paramètre' (C++)
• E2343: Non concordance de type dans le paramètre 'paramètre' dans l'appel à 'fonction' (C++)
• E2344: Déclaration précédente de 'identificateur' (C++)
• E2345: L'accès peut seulement être changé en public ou protected (C++)
• E2346: Le spécificateur d'accès 'x' de la propriété 'propriété' doit être une fonction membre (C++)
• E2347: Non concordance de paramètre dans le spécificateur d'accès 'spécificateur' de la propriété 'propriété' (C++)
• E2348: Spécificateur de stockage non autorisé pour les propriétés de tableau (C++)
• E2349: Conversion de pointeur non portable (C++)
• E2350: Impossible de définir un pointeur ou une référence sur une référence (C++)
• E2351: Membres de données statiques non autorisés dans les sections __published ou __automated (C++)
• E2352: Impossible de créer une instance de la classe abstraite 'classe' (C++)
• E2353: La classe 'classe' est abstraite car 'membre = 0' (C++)
• E2354: Deux opérandes doivent être évalués de même type (C++)
• E2355: Fonction modèle récursive : 'x' a instancié 'y' (C++)
• E2356: Non concordance de type dans la redéclaration de 'identificateur' (C++)
• E2357: Référence initialisée avec 'type1', nécessite lvalue de type 'type2' (C++)
• E2358: Le membre référence 'membre' a besoin d'un temporaire pour l'initialisation (C++)
• E2359: Le membre référence 'membre' a été initialisé avec un paramètre non-référence (C++)
• E2360: Combinaison de registre incorrecte (ex : [BP+BX]) (C++)
• E2361: 'spécificateur' a déjà été inclus (C++)
• E2362: Le nombre de répétitions a besoin d'une lvalue (C++)
• E2363: Tentative de renvoyer une référence à la variable locale 'identificateur' (C++)
• E2364: Tentative de renvoyer une référence à un objet local (C++)
• E2365: Un pointeur membre est nécessaire à droite de .* ou ->* (C++)
• E2366: Impossible d'hériter une classe non-RTTI depuis la base RTTI (E2367) OU Impossible d'hériter une classe RTTI depuis la base non-RTTI (C++)
• E2368: RTTI non disponible pour une évaluation d'expression (C++)
• E2369: Impossible d'utiliser le résultat d'une affectation de propriété comme une rvalue (C++)
• E2370: Nom de type simple attendu (C++)
• E2371: sizeof ne peut pas être appliqué à un champ de bits (C++)
• E2372: sizeof ne peut pas être appliqué à une fonction (C++)
• E2373: Un champ de bits ne peut pas être statique (C++)
• E2374: La fonction 'fonction' ne peut pas être statique (C++)
• E2375: Débordement de pile assembleur (C++)
• E2376: manquante dans l'instruction (C++)
• E2377: ) manquante dans l'instruction (C++)
• E2378: ; manquant dans l'instruction do-while ou for (C++)
• E2379: ; manquante dans l'instruction (C++)
• E2380: Constante chaîne ou caractère non terminée (C++)
• E2381: Taille de la structure trop grande (C++)
• E2382: Les effets de bord ne sont pas autorisés (C++)
• E2383: L'expression de sélection switch doit être de type entier (C++)
• E2384: Impossible d'appeler une fonction membre de classe near avec un pointeur de type 'type' (C++)
• E2386: Impossible d'impliquer le paramètre 'paramètre' dans une expression de spécialisation partielle complexe (C++)
• E2387: Les spécialisations partielles ne peuvent pas spécialiser les paramètres dépendants non-typés ('paramètre') (C++)
• E2388: La liste d'arguments de spécialisation ne peut pas être identique à la liste de paramètres de modèle primaire (C++)
• E2389: Non concordance dans le type d'argument de substitution et le paramètre modèle 'paramètre' (C++)
• E2390: Non concordance de type dans le paramètre 'numéro' du nom de classe modèle 'modèle' (C++)
• E2391: Non concordance de type dans le paramètre 'paramètre' du nom de classe modèle 'modèle' (C++)
• E2392: L'instance du modèle 'template' est déjà instanciée (C++)
• E2393: Impossible de prendre l'adresse du paramètre modèle non-typé, non-référencé 'paramètre' (C++)
• E2394: Trop peu d'arguments passés au modèle 'modèle' (C++)
• E2395: Trop d'arguments passés au modèle 'modèle' (C++)
• E2396: L'argument du modèle doit être une expression constante (C++)
• E2397: L'argument du modèle ne peut pas avoir une liaison statique ou locale (C++)
• E2398: L'argument 'argument' de la fonction modèle n'est pas utilisé dans les types d'argument (C++)
• E2399: Impossible de référencer de cette façon l'argument 'arg' du modèle dans la classe modèle 'classe' (C++)
• E2400: L'argument de modèle non typé doit être de type scalaire (C++)
• E2401: Liste des arguments de modèles incorrecte (C++)
• E2402: Type de classe de base incorrect : type formel 'type' résolu en 'type' (C++)
• E2403: Le spécificateur d'appel dépendant produit une non-fonction 'nom' (C++)
• E2404: Le qualificateur de type dépendant 'qualificateur' n'a aucun type membre nommé 'nom' (C++)
• E2405: La référence de modèle dépendante 'identificateur' fournit un symbole non modèle (C++)
• E2406: Le qualificateur de type dépendant 'qualificateur' n'est pas un type class ou struct (C++)
• E2407: Le qualificateur de type dépendant 'qualificateur' n'a aucun symbole membre nommé 'nom' (C++)
• E2408: Les valeurs par défaut doivent être spécifiées seulement dans les déclarations de modèle de classe primaire (C++)
• E2409: Impossible de trouver une spécialisation correcte pour 'spécificateur' (C++)
• E2410: Paramètres de modèle manquants pour le modèle ami 'modèle' (C++)
• E2411: La déclaration des paramètres par défaut d'une fonction membre après une spécialisation a déjà été développée (C++)
• E2412: Tentative de lier une référence membre à un type dépendant (C++)
• E2413: Déclaration de modèle incorrecte (C++)
• E2414: Les destructeurs ne peuvent pas être déclarés comme fonctions modèles (C++)
• E2415: Les fonctions modèle doivent avoir seulement des 'arguments de type' (C++)
• E2416: Déclaration de fonction modèle incorrecte (C++)
• E2417: Impossible de spécifier des paramètres de modèle dans la spécialisation explicite de 'spécificateur' (C++)
• E2418: Profondeur d'instanciation maximum dépassée ; vérifiez la récursivité (C++)
• E2419: Erreur pendant l'instanciation du modèle 'modèle' (C++)
• E2420: Une instanciation explicite ne peut être utilisée que sur l'étendue globale (C++)
• E2421: Impossible d'utiliser le type local 'identificateur' comme argument modèle (C++)
• E2422: Le type d'argument ne correspond pas dans la redéclaration du paramètre modèle 'paramètre' (C++)
• E2423: Spécialisation ou instanciation explicite d'un modèle non existant 'modèle' (C++)
• E2424: Classe modèle imbriquée trop profondément : 'class' (C++)
• E2425: 'membre' n'est pas un membre de type modèle correct (C++)
• E2426: La spécialisation explicite de 'spécificateur' nécessite une déclaration 'template<>' (C++)
• E2427: 'main' ne peut pas être une fonction modèle (C++)
• E2428: Les modèles doivent être des classes ou des fonctions (C++)
• E2429: Ce n'est pas une spécialisation partielle correcte de 'spécificateur' (C++)
• E2430: Le nombre de paramètres de modèles ne correspond pas dans la redéclaration de 'spécificateur' (C++)
• E2431: Les paramètres de modèle non-typé ne peuvent pas être de type virgule flottante, classe ou void (C++)
• E2432: Le qualificateur 'template' doit nommer une classe modèle ou une instance de fonction (C++)
• E2433: Spécialisation après la première utilisation du modèle (C++)
• E2434: Les paramètres de modèle manquent dans la déclaration de modèle ('template<...>') (C++)
• E2435: Trop d'ensembles de paramètres de modèles ont été spécifiés (C++)
• E2436: Le type par défaut de l'argument modèle 'arg' ne nomme pas une classe modèle primaire (C++)
• E2437: 'typename' doit être suivi par un nom de type dépendant qualifié (C++)
• E2438: Les arguments du modèle template doivent nommer une classe (C++)
• E2439: 'typename' n'est autorisé que dans les déclarations modèle (C++)
• E2440: Impossible de créer une spécialisation depuis 'spécificateur' car ce type n'est pas encore défini (C++)
• E2441: Instanciation de 'spécificateur' (C++)
• E2442: Deux points consécutifs (C++)
• E2443: La classe de base 'classe' est initialisée plus d'une fois (C++)
• E2444: Le membre 'membre' est initialisé plus d'une fois (C++)
• E2445: La variable 'identificateur' est initialisée plus d'une fois (C++)
• E2446: La définition de fonction ne peut pas être une déclaration typedef (C++)
• E2447: 'identificateur' doit être un repère d'énumération précédemment défini (C++)
• E2448: Etiquette non définie 'identificateur' (C++)
• E2449: La taille de 'identificateur' est inconnue ou zéro (C++)
• E2450: Structure 'structure' non définie (C++)
• E2451: Symbole 'identificateur' non défini (C++)
• E2452: La taille du type est inconnue ou zéro (C++)
• E2453: La taille du type 'identificateur' est inconnue ou égale à zéro (C++)
• E2454: Une union ne peut pas être un type de base (C++)
• E2455: Une union ne peut pas avoir un type de base (C++)
• E2456: Le membre de l'union 'membre' est de classe type avec 'constructeur' (ou destructeur ou opérateur =) (C++)
• E2457: Les classes de style Delphi doivent être prises par référence (C++)
• E2458: Les classes Delphi doivent être dérivées de classes Delphi (C++)
• E2459: Les classes de style Delphi doivent être construites en utilisant l'opérateur new (C++)
• E2460: Les classes de style Delphi nécessitent que la gestion d'exception soit activée (C++)
• E2461: '%s' nécessite une initialisation/finalisation d'exécution (C++)
• E2462: 'virtual' ne peut être utilisé qu'avec des fonctions membre non modèle (C++)
• E2463: 'base' est une classe de base virtuelle indirecte de 'classe' (C++)
• E2464: 'virtual' ne peut être utilisé qu'avec des fonctions membre (C++)
• E2465: Les unions ne peuvent pas avoir de fonctions membre virtuelles (C++)
• E2466: void & n'est pas un type correct (C++)
• E2467: Une fonction Void ne peut pas renvoyer une valeur (C++)
• E2468: Une valeur de type void n'est pas autorisée (C++)
• E2469: Impossible d'utiliser le modèle mémoire tiny ou huge avec Windows (C++)
• E2470: Il faut inclure l'en-tête <typeinfo> pour utiliser typeid (C++)
• E2471: pragma checkoption a échoué : les options ne sont pas celles attendues (C++)
• E2472: Impossible de déclarer une fonction membre via une instanciation (C++)
• E2473: Spécialisation explicite de 'spécificateur' incorrecte (C++)
• E2474: 'fonction' ne peut pas être déclarée comme static ou inline (C++)
• E2475: 'fonction' ne peut pas être une fonction modèle (C++)
• E2476: Impossible de surcharger 'fonction' (C++)
• E2477: Trop peu de paramètres de modèle ont été déclarés pour le modèle 'modèle' (C++)
• E2478: Trop de paramètres de modèle ont été déclarés pour le modèle 'modèle' (C++)
• E2479: Impossible d'avoir à la fois une classe modèle et une fonction appelée 'nom' (C++)
• E2480: Impossible d'impliquer des paramètres de modèle dans les arguments de spécialisation partielle complexe (C++)
• E2481: Constante chaîne inattendue (C++)
• E2482: Constante chaîne attendue (C++)
• E2483: La dimension du tableau 'spécificateur' n'a pas pu être déterminée (C++)
• E2484: Le nom de la classe modèle 'classe' ne peut pas être surchargé (C++)
• E2485: Impossible d'utiliser l'élément adresse de tableau comme un argument de modèle non typé (C++)
• E2486: Impossible d'utiliser l'adresse du membre de classe comme un argument de modèle non typé (C++)
• E2487: Impossible de spécifier des arguments de fonction par défaut pour des spécialisations explicites (C++)
• E2488: Profondeur maximum de réponse dépassée ; vérifiez la récursivité (C++)
• E2489: Profondeur maximum de répétitions d'options dépassée ; vérifiez la récursivité (C++)
• E2490: Spécialisation dans des classes modèle non encore implémentées (C++)
• E2491: Compte VIRDEF maximum dépassé ; vérifiez la récursivité (C++)
• E2492: Les propriétés peuvent uniquement être affectées en utilisant une instruction simple, par exemple \"prop = valeur;\" (C++)
• E2493: Chaîne GUID incorrecte (C++)
• E2494: Modificateur __declspec non reconnu (C++)
• E2495: Redéfinition de uuid non identique (C++)
• E2496: Appel non valide à uuidof(struct type | variable)
• E2497: Aucun GUID associé au type 'type' (C++)
• E2498: Définition préalable de la structure du GUID requise (C++)
• E2499: Format __declspec(uuid(GuidString)) non valide (C++)
• E2500: __declspec(selectany) ne s'adresse qu'aux variables initialisées et visibles de façon externe (C++)
• E2501: Impossible d'ouvrir le fichier d'importation 'nom_fichier' (C++)
• E2502: Erreur de résolution de #import : problème (C++)
• E2503: Version manquante ou incorrecte de TypeLibImport.dll (C++)
• E2504: 'dynamic' ne peut être utilisé qu'avec des fonctions membre non modèle (C++)
• E2505: L'instanciation explicite requiert un spécificateur de type élaboré (par exemple, "class foo<int>") (C++)
• E2506: La spécialisation explicite de 'spécificateur' est ambiguë : des arguments modèles doivent être spécifiés (C++)
• E2507: 'classe' n'est pas une classe de base directe de 'classe' (C++)
• E2508: 'using' ne peut pas faire référence à une spécialisation de modèle (C++)
• E2509: Valeur hors limites (C++)
• E2510: Non concordance de taille d'opérande (C++)
• E2511: Argument de macro non terminé (C++)
• E2512: Impossible d'émettre des informations RTTI pour le type renvoyé par 'fonction' (C++)
• E2513: Impossible d'émettre des informations RTTI pour 'paramètre' dans 'fonction' (C++)
• E2514: Impossible (pour le moment) d'utiliser la résolution des surcharges de membre pendant l'instanciation de modèle (C++)
• E2515: Impossible de spécialiser explicitement un membre d'une classe modèle générique (C++)
• E2522: Fonction non const 'fonction' appelée pour un objet const (C++)
• E2523: Fonction non volatile 'nom' appelée pour un objet volatile (C++)
• E2524: Les unions/structs anonymes ne sont pas autorisées à avoir des membres anonymes en C++ (C++)
• E2525: Vous devez définir _PCH_STATIC_CONST avant d'inclure xstring afin d'utiliser cette fonctionnalité (C++)
• E2526: La propriété 'nom' utilise une autre propriété comme getter/setter ; non autorisé (C++)
• E2527: L'option 'nom' ne peut pas être définie via 'nom' (C++)
• E2528: L'option 'nom' doit être définie avant la compilation (C++)
• E2529: Le chemin 'chemin' dépasse la taille maximale 'n' (C++)
• E2530: Option non reconnue ou aide indisponible (C++)
• E2531 : Le paramètre est un type incomplet (C++)
• E2532 : La constante de la nouvelle expression nécessite un initialiseur (C++)
• E2533 : Non concordance du paramètre (nom de type voulu) (C++)
• E2534 : Expression constante intégrale attendue (C++)
• E2535 : Un type incomplet ne peut pas faire partie d'une spécification throw (C++)
• E2536 : Un type incomplet ne peut pas faire partie d'une déclaration d'exception (C++)
• E2537 : Impossible de créer une instance d'une classe abstraite (C++)
• E2538 : L'assertion statique a échoué : '%s' (C++)
• E2539 : Expression constante attendue (C++)
• E2540 : Littéral chaîne attendu (C++)
• E2541 : Impossible de définir l'attribut '%s' (C++)
• E2542 : '%s' est marqué comme 'final' et ne peut pas être redéfini (C++)
• E2543 : La combinaison des options 'options' n'est pas autorisée (C++)
• E2544 : Les spécifications d'exception de fonction ne correspondent pas (C++)
• E2545 : Le type sous-jacent enum doit être un intégral (C++)
• E2546 : La redéclaration de enum n'est pas identique (C++)
• E2547 : ... attendu (C++)
• E2548 : ... était inattendu ; l'expression n'est pas un pattern de template variadic (C++)
• E2549 : L'opérande n'est pas un pack de paramètres (C++)
• E2550 : Aucun argument ne peut suivre un template variadic dans une liste d'arguments (C++)
• E2551 : L'instruction return n'est pas autorisée dans un bloc __finally (C++)
• E2552 : Cette fonctionnalité n'est pas encore supportée. (C++)
• E2553 : Non concordance de %s dans la redéclaration de '%s' (C++)
• E2554 : La fonction pure '%s' ne peut pas être déclarée 'final' (C++)

Rubriques des messages d'échec

• F1000: Limite de la table du compilateur dépassée (C++)
• F1001: Erreur du générateur de code interne (C++)
• F1002: Impossible de créer le fichier de sortie 'nomfichier' (C++)
• F1003: Erreur de directive : 'message' (C++)
• F1004: Erreur interne du compilateur (C++)
• F1005: Fichiers d'inclusion imbriqués trop profondément (C++)
• F1006: Appel incorrect d'une fonction intrinsèque (C++)
• F1007: Arborescence d'expression irréductible (C++)
• F1008: Plus de mémoire (C++)
• F1009: Impossible d'ouvrir le fichier d'entrée 'nomfichier' (C++)
• F1010: Impossible d'ouvrir 'nomfichier' (C++)
• F1011: Echec d'allocation de registre (C++)
• F1012: Débordement de pile du compilateur (C++)
• F1013: Erreur d'écriture du fichier de sortie (C++)

Rubriques d'aide des messages d'avertissement

• W8000: Les opérateurs ambigus requièrent des parenthèses (C++)
• W8001: & superflu avec une fonction (C++)
• W8002: Redémarrage de la compilation avec l'assembleur (C++)
• W8003: Instruction assembleur inconnue (C++)
• W8004: 'identificateur' a une valeur qui n'est jamais utilisée (C++)
• W8005: Les champs de bits doivent être des entiers signés ou non signés (C++)
• W8006: Initialisation de 'identificateur' avec 'identificateur' (C++)
• W8007: La valeur hexadécimale contient plus de trois chiffres (C++)
• W8008: La condition est toujours vraie OU W8008 La condition est toujours fausse (C++)
• W8009: La constante est longue (C++)
• W8010: Caractère de continuation \ trouvé dans un commentaire // (C++)
• W8011: Comparaison de pointeur non portable (C++)
• W8012: Comparaison de valeurs signées et non signées (C++)
• W8013: Utilisation possible de 'identificateur' avant sa définition (C++)
• W8014: Déclaration ignorée (C++)
• W8015: Déclarez 'type' avant de l'utiliser dans le prototype (C++)
• W8016: Taille de tableau ignorée pour 'delete' (C++)
• W8017: La redéfinition de 'x' n'est pas identique (C++)
• W8018: Affectation de 'type' à 'énumération' (C++)
• W8019: Le code n'a pas d'effet (C++)
• W8020: 'identificateur' est déclaré à la fois externe et statique (C++)
• W8021: Le gestionnaire de 'type1' est caché par le gestionnaire précédent de 'type2' (C++)
• W8022: 'fonction1' cache la fonction virtuelle 'fonction2' (C++)
• W8023: La variable tableau 'identificateur' est near (C++)
• W8024: La classe de base 'classe1' est aussi une classe de base de 'classe2' (C++)
• W8025: Pragma mal formé (C++)
• W8026: Les fonctions avec des spécifications d'exception ne sont pas développées en ligne (C++)
• W8027: Les fonctions contenant 'instruction' ne sont pas développées en ligne (C++)
• W8028: Variable temporaire utilisée pour initialiser 'identificateur' (C++)
• W8029: Un temporaire a été utilisé pour le paramètre '???' (C++)
• W8031: Temporaire utilisé pour le paramètre 'paramètre' OU W8029 Temporaire utilisé pour le paramètre 'numéro' OU W8030 Temporaire utilisé pour le paramètre 'paramètre' dans l'appel à 'fonction' OU W8032 Temporaire utilisé pour le paramètre 'numéro' dans l'appel à 'fonction' (C++)
• W8032: Un temporaire a été utilisé pour le paramètre 2 dans l'appel à '???' (C++)
• W8033: La conversion en 'type' échouera pour les membres de la base virtuelle 'classe' (C++)
• W8034: Précision maximum utilisée pour le type pointeur membre 'type' (C++)
• W8035: Message défini par l'utilisateur (C++)
• W8036: Mot clé non ANSI utilisé : 'mot clé' (C++)
• W8037: Fonction non const 'fonction' appelée pour un objet const (C++)
• W8038: Le membre constante 'identificateur' n'est pas initialisé (C++)
• W8039: Liste d'initialiseurs de constructeurs ignorée (C++)
• W8040: Corps de fonction ignoré (C++)
• W8041: Valeur non signée rendue négative (C++)
• W8042: Initialiseur pour l'objet 'x' ignoré (C++)
• W8043: Définition de macro ignorée (C++)
• W8044: Directive #undef ignorée (C++)
• 8045: Pas de déclaration pour la fonction 'fonction' (C++)
• W8046: Option pragma pop sans option push correspondante (C++)
• W8047: Déclaration de la fonction statique function ignorée (C++)
• W8048: Utilisez un nom qualifié pour accéder au type membre 'identificateur' (C++)
• W8049: Utilisez '> >' pour les modèles imbriqués au lieu de '>>' (C%2B%2B)
• W8050 : Aucun fichier OBJ présent ; désactivation de l'option types externes. (C++)
• W8051: Fonction non volatile 'fonction' appelée pour un objet volatile (C++)
• W8052: Initialisation de base sans nom de classe maintenant obsolète (C++)
• W8053: 'identificateur' obsolète (C++)
• W8054: Ce style de définition de fonction est maintenant obsolète (C++)
• W8055: Débordement possible dans une opération shift (C++)
• W8056 : Débordement arithmétique d'entiers (C++)
• W8057: Paramètre 'paramètre' jamais utilisé (C++)
• W8058: Impossible de créer un en-tête précompilé : 'raison' (C++)
• W8059: La taille de la structure a changé (C++)
• W8060: Affectation peut-être incorrecte (C++)
• W8061: L'initialisation est partiellement entre accolades (C++)
• W8062: Options et avertissements précédents non restaurés (C++)
• W8063: Opérateur de préfixe surchargé 'opérateur' utilisé comme un opérateur de suffixe (C++)
• W8064: Appel à une fonction sans prototype (C++)
• W8065: Appel à la fonction 'fonction' sans prototype (C++)
• W8066: Code inatteignable (C++)
• W8067: Instructions de retour avec et sans valeur utilisées (C++)
• W8068: Constante hors limites dans la comparaison (C++)
• W8069: Conversion de pointeur non portable (C++)
• W8070: La fonction doit renvoyer une valeur (C++)
• W8071: La conversion peut perdre des chiffres significatifs (C++)
• W8072: Arithmétique de pointeur suspecte (C++)
• W8073: Structure 'structure' non définie (C++)
• W8074: Structure transmise par valeur (C++)
• W8075: Conversion de pointeur suspecte (C++)
• W8076: L'instance du modèle 'spécificateur' est déjà instanciée (C++)
• W8077: La spécialisation explicite d'un membre de classe explicitement spécialisé n'a pas de sens (C++)
• W8078: L'expression throw viole la spécification d'exception (C++)
• W8079: Mélange de pointeurs de plusieurs types 'char' (C++)
• W8080: 'identificateur' est déclaré mais jamais utilisé (C++)
• W8081: Les fonctions void ne peuvent pas renvoyer de valeur (C++)
• W8082: Division par zéro (C++)
• W8083: Pragma pack pop sans pack push correspondant (C++)
• W8084: Nous suggérons des parenthèses pour clarifier la priorité (C++)
• W8085: Fonction 'fonction' redéfinie comme non-en ligne (C++)
• W8086: Utilisation incorrecte de l'alias #pragma "NomAlias"="NomSubstitué" (C++)
• W8087: 'opérateur::opérateur==' doit être publiquement visible pour être contenu par un 'type' (C++)
• W8089: 'type::opérateur<' doit être publiquement visible pour être contenu par un 'type' (C++)
• W8090: 'type::opérateur<' doit être publiquement visible pour être utilisé avec 'type' (C++)
• W8091: L'argument 'type' 'spécificateur' transmis à 'fonction' est un itérateur 'catégorie d'itérateur' : itérateur 'catégorie d'itérateur' requis (C++)
• W8092: L'argument 'type' 'spécificateur' transmis à 'fonction' n'est pas un itérateur : itérateur 'type' requis (C++)
• W8093: Utilisation incorrecte de #pragma codeseg [nom_seg] ["classe_seg"] [groupe] (C++)
• W8094: Utilisation incorrecte de #pragma comment( <type> [,"chaîne"] ) (C++)
• W8095: Utilisation incorrecte de #pragma message( "chaîne" ) (C++)
• W8096: Utilisation incorrecte de #pragma code_seg(["nom_seg"[,"classe_seg"]]) (C++)
• W8097: Toutes les options ne peuvent pas être restaurées pour l'instant (C++)
• W8098: Constante caractère multicaractère (C++)
• W8099: main statique n'est pas traité comme un point d'entrée (C++)
• W8100: Directive d'attribut %s ignorée (C++)
• W8103: Le chemin 'chemin' et le nom de fichier 'nomfichier' dépassent la taille maximale 'n' (C++)
• W8104 : Local Statique avec constructeur, dangereux pour les applications multithreads (C++)*
• W8105: Membre %s '%s' dans la classe sans constructeur (C++)
• W8106 : %s sont dépréciés (C++)
• W8107 : Nom de type attendu (C++)
• W8108 : La constante de la nouvelle expression nécessite un initialiseur (C++)
• W8109 : Le paramètre '%s' est un type dépendant (C++)
• W8110 : Directive d'attribut '%s' en double ignorée (C++)
• W8111 Accès à l'entité %s désapprouvée (C++)
• W8112 : Dépendances non résolues dans l'expression (C++)
• W8113 : La fonction inline était déclarée avec 'extern template' (C++)
• W8115: Expression constante attendue ; instruction ignorée (C++)
• W8116: Renvoi du pointeur sur un objet local (C++)
• W8117 : La taille SAVEMEM maximale doit être comprise entre %d et %d (C++)