Compiler-Fehler und -Warnungen (C++) - Index

Nach oben zu C++-Referenz

Dieser Abschnitt enthält die Compiler-Fehlermeldungen und -Warnungen von RAD Studio.

Meldungen ohne Nummer

• Unerwarteter Abbruch bei Compilierung [Module Seg#:offset] oder Unerwarteter Abbruch bei Link-Vorgang [Module Seg#:offset] (C++)

Hilfethemen zu Fehlermeldungen

• E2000: 286/287-Anweisungen nicht aktiviert (C++)
• E2001: In __automated-Abschnitten sind Konstruktoren und Destruktoren nicht zulässig (C++)
• E2002: In __automated-Abschnitten sind nur __fastcall-Funktionen zulässig (C++)
• E2003: In __automated-Abschnitten sind Datenelementfunktionen nicht zulässig (C++)
• E2004: In __automated-Abschnitten sind bei Eigenschaftsdeklarationen nur die Klausel read und write zulässig (C++)
• E2005: In __automated-Abschnitten ist die wiederholte Deklaration von Eigenschaften nicht zulässig (C++)
• E2006: CodeGuard-Programme müssen das Speichermodell large verwenden und für den Einsatz unter Windows konzipiert sein (C++)
• E2007: Die Definition von Dispid-Anweisungen ist nur in __automated Abschnitten zulässig (C++)
• E2008: In __published-Abschnitten deklarierte Zugriffsfunktionen müssen die Aufrufkonvention __fastcall verwenden (C++)
• E2009: Versuch, Zugriffsrechte auf 'bezeichner' zu erhöhen oder zu vermindern (C++)
• E2010: Relozierbare Symbole dürfen nicht addiert oder subtrahiert werden (C++)
• E2011: Verwendung der Adresse eines Bitfeldes nicht zulässig (C++)
• E2012: Zugriff auf die Adresse der Hauptfunktion 'main' nicht zulässig (C++)
• E2013: Unterscheidung von 'funktion1' und 'funktion2' nicht möglich (C++)
• E2014: Element ist mehrdeutig: 'element1' und 'element2' (C++)
• E2015: Mehrdeutigkeit zwischen 'funktion1' und 'funktion2' (C++)
• E2016: Mehrdeutiges Überschreiben einer virtuellen Basisklasse 'basis_funktion': 'abgeleitete_funktion' (C++)
• E2017: Mehrdeutiger Name eines Strukturelementes 'name' (C++)
• E2018: 'bezeichner' kann nicht erstellt werden -- mehrdeutige Basisklasse 'bezeichner' (C++)
• E2019: 'bezeichner' darf in einer anonymen Variante nicht deklariert werden (C++)
• E2020: Globale anonyme Variante nicht static (C++)
• E2021: Array muss mindestens ein Element enthalten (C++)
• E2022: Array zu groß (C++)
• E2023: Array aus Referenzen nicht zulässig (C++)
• E2024: const-Objekt kann nicht modifiziert werden (C++)
• E2025: Zuweisung this nicht zulässig - verwenden Sie den X::Operator new (C++)
• E2026: Assembler-Anweisung zu lang (C++)
• E2027: Eine Speicheradresse muss verwendet werden (C++)
• E2028: Der Operator -> muss einen Zeiger oder eine Klasse zurückgeben (C++)
• E2029: 'bezeichner' muss eine bereits definierte Klasse oder Struktur sein (C++)
• E2030: break-Anweisung an ungültiger Position (C++)
• E2031: Typumwandlung von 'typ1' nach 'typ2' nicht zulässig (C++)
• E2032: closure-Zeigervariable unzulässig verwendet (C++)
• E2033: continue-Anweisung an ungültiger Position (C++)
• E2034: Konvertierung von 'typ1' nach 'typ2' nicht möglich (C++)
• E2035: Umwandlungen in die gleiche Klasse oder Basisklasse nicht zulässig (C++)
• E2036: Umwandlungsoperator darf keinen Rückgabetypen angeben (C++)
• E2037: Konstruktor 'konstruktor' nicht zulässig (C++)
• E2038: Deklaration oder Definition von 'bezeichner' hier nicht zulässig: ungültiger Namespace (C++)
• E2039: Dezimalpunkt an ungültiger Position (C++)
• E2040: Deklaration nicht ordnungsgemäß abgeschlossen (C++)
• E2041: Inkorrekte Verwendung von default (C++)
• E2042: Deklaration des Operators delete (void*) (C++)
• E2043: Deklaration des Operators delete (void*) oder (void*, size_t) (C++)
• E2044: Operator delete muss void zurückliefern (C++)
• E2045: Destruktorname muss mit dem Klassennamen übereinstimmen (C++)
• E2046: Ungültiger Dateiname in include-Anweisung ODER Ungültiger Dateiname in line-Anweisung (C++)
• E2047: Ungültige 'direktive'-Anweisungssyntax (C++)
• E2048: Unbekannte Preprocessor-Anweisung: 'bezeichner' (C++)
• E2049: Klassentyp 'typ' darf nicht als __declspec(delphireturn) ausgezeichnet sein (C++)
• E2050: __declspec(delphireturn)-Klasse 'klasse' darf nur ein Datenelement enthalten (C++)
• E2051: Unzulässige Verwendung des Punkt-Operators (.) (C++)
• E2052: Dynamische Funktion 'funktion' verursacht Konflikte mit der Basisklasse 'klasse' (C++)
• E2053: elif-Anweisung an ungültiger Position (C++)
• E2054: else an ungültiger Position (C++)
• E2055: else-Anweisung an ungültiger Position (C++)
• E2056: endif-Anweisung an ungültiger Position (C++)
• E2057: Exception-Spezifizierung hier nicht zulässig (C++)
• E2058: Exception-Behandlungsvariable hier nicht zulässig (C++)
• E2059: Unbekannte Sprache, C oder C++ erwartet (C++)
• E2060: Unzulässige Verwendung einer Fließkommazahl (C++)
• E2061: Friends müssen Funktionen oder Klassen sein (C++)
• E2062: Unzulässiger Indirektionsoperator (C++)
• E2063: Unzulässig Initialisierung (C++)
• E2064: 'typ1' kann nicht mit 'typ2' initialisiert werden (C++)
• E2065: Bezeichner des Namespace 'symbol' verursacht Konflikte mit der intrinsischen Funktion desselben Namens (C++)
• E2066: Keine Informationen verfügbar (C++)
• E2066: Unzulässige MOM-Vererbung (C++)
• E2067: main muss einen Rückgabewert vom Typen int zurückliefern (C++)
• E2068: 'bezeichner' ist kein nicht-statisches Datenelement und kann hier nicht initialisiert werden (C++)
• E2069: Unzulässige Verwendung eines Zeigers auf ein Klassenelement (C++)
• E2070: Unzulässige Verwendung des Namespace 'bezeichner' (C++)
• Operator new muss als ersten Parameter den Typ size_t haben (C++)
• E2072: Operator new[] muss ein Objekt des Typs void zurückliefern (C++)
• E2073: Nach pragma option pop dürfen nur Kommentare, Leerzeichen oder Zeilenendezeichen stehen (C++)
• E2074: Der Wert nach -g oder -j sollte zwischen 0 und 255 liegen (C++)
• E2075: Ungültige 'typ'-Option: Option (C++)
• E2076: Überladbarer Operator erwartet (C++)
• E2077: 'operator' muss entweder mit einem oder ohne Parameter deklariert werden (C++)
• E2078: 'operator' muss entweder mit einem oder zwei Parametern deklariert werden (C++)
• E2079: 'funktion' muss ohne Parameter deklariert werden (C++)
• E2080: 'funktion' muss mit einem Parameter deklariert werden (C++)
• E2081: 'funktion' muss mit zwei Parametern deklariert werden (C++)
• E2082: 'bezeichner' muss eine Elementfunktion sein oder einen Parameter des Typs class aufweisen (C++)
• E2083: Der letzte Parameter von 'operator' muss mit dem Typ int deklariert sein (C++)
• E2084: Parameternamen werden nur mit einem Funktionsrumpf verwendet (C++)
• E2085: Unzulässige Zeigeraddition (C++)
• E2086: Unzulässige Zeigersubtraktion (C++)
• E2087: Unzulässige Zeigerverwendung (C++)
• E2088: Ungültige Syntax bei einer abstrakten Funktionsdefinition (C++)
• E2089: Bezeichner 'bezeichner' darf keinen Typqualifizierer besitzen (C++)
• E2090: Qualifizierer 'bezeichner' ist kein Name einer Klasse oder einer Struktur (C++)
• E2091: Funktionen können keine Arrays und Funktionen zurückliefern (C++)
• E2092: Speicherklasse 'speicherklasse' ist hier nicht erlaubt (C++)
• E2093: Operator 'operator' ist im Typ 'typ' für Argumente desselben Typs nicht implementiert (C++)
• E2094: Operator 'operator' ist im Typ 'typ' für Argumente des Typs 'typ' nicht implementiert (C++)
• E2095: String-Literale in diesem Kontext nicht zulässig (C++)
• E2096: Ungültige Strukturoperation (C++)
• E2097: Expliziter Instantiierungsoperator nur global oder in Namespaces zulässig (C++)
• E2098: Expliziter Spezifizierungsoperator "template<>" jetzt erforderlich (C++)
• E2099: Expliziter Spezifizierungsoperator nur global oder in Namespace zulässig (C++)
• E2100: Ungültige Deklaratorliste für Template (C++)
• E2101: Schlüsselwort 'export' darf in einer Template-Deklaration nur vor "template" stehen (C++)
• E2102: Template 'template' kann ohne Spezifizierungsparameter nicht verwendet werden (C++)
• E2103: Explizite Instantiierung muss mit einer Template-Klasse oder -Funktion verwendet werden (C++)
• E2104: Ungültige Verwendung des Schlüsselworts template (C++)
• E2105: 'Template'-Qualifizierer muss einen Template-Elementnamen festlegen (C++)
• E2106: Expliziter Spezifizierungsoperator darf nur vor einer Template-Klasse oder -Funktion verwendet werden (C++)
• E2107: Ungültige Verwendung des Template 'template' (C++)
• E2108: Ungültige Verwendung von typedef 'bezeichner' (C++)
• E2109: Kein zulässiger Typ (C++)
• E2110: Inkompatible Typumwandlung (C++)
• E2111: Typ 'typname' darf hier nicht definiert werden (C++)
• E2112: Unbekannte unit-Anweisung: 'direktive' (C++)
• E2113: Virtuelle Funktion 'funktion1' verursacht Konflikte mit der Basisklasse 'basis' (C++)
• E2114: Für mehrere Basisklassen sind explizite Klassennamen erforderlich (C++)
• E2115: Bitfeld zu groß (C++)
• E2116: Bitfelder müssen mindestens ein Bit enthalten (C++)
• E2117: Bitfelder müssen vom Typ signed oder unsigned int sein (C++)
• E2118: Bitfelder müssen vom Typ Integer sein (C++)
• E2119: Abbruch durch Benutzer (C++)
• E2120: 'main' darf nicht vom Programm aus aufgerufen werden (C++)
• E2121: ) fehlt beim Funktionsaufruf (C++)
• E2122: Funktionsaufruf durch unbehandelte Exception 'wert' an Adresse 'adr' beendet (C++)
• E2123: Klasse 'klasse' darf keine abstrakten Funktionen enthalten (C++)
• E2124: Ungültiger Funktionsaufruf (C++)
• E2125: Compiler konnte Kopierkonstruktor nicht für die Klasse 'klasse' generieren ODER Compiler konnte Standardkonstruktor nicht für die Klasse 'klasse' generieren ODER Compiler konnte Operator = nicht für die Klasse 'klasse' generieren (C++)
• E2126: Case umgeht die Initialisierung einer lokalen Variable (C++)
• E2127: case-Anweisung fehlt: (C++)
• E2128: case-Marke außerhalb der switch-Anweisung (C++)
• E2129: char-Konstante zu lang (oder leer) (C++)
• E2130: Zirkuläre Eigenschaftsdefinition (C++)
• E2131: Objekte des Typs 'typ' dürfen nicht mit { } initialisiert werden (C++)
• E2132: C-Einbindungsangabe darf für Schablonen oder überladene Operatoren nicht verwendet werden (C++)
• E2133: Anweisung 'anweisung' kann nicht ausgeführt werden (C++)
• E2134: Abschließendes } fehlt (C++)
• E2135: Konstruktor/Destruktor darf nicht als 'const' oder 'volatile' deklariert werden (C++)
• E2136: Konstruktor darf keine Festlegung des Rückgabetyps enthalten (C++)
• E2137: Für den Destruktor für 'klasse' ist ein bedingter Ausdruck erforderlich (C++)
• E2138: Typmodifizierer verursachen Konflikte (C++)
• E2139: In Deklaration fehlt ; (C++)
• E2140: Deklaration hier nicht zulässig (C++)
• E2141: Fehler in der Deklarationssyntax (C++)
• E2142: Basisklasse 'klasse' enthält DDVT-Funktionen (C++)
• E2143: Zugeordnete Basisklassenfunktion 'funktion' hat eine andere DDVT-Zuordnungsnummer (C++)
• E2144: Zugeordnete Basisklassenfunktion 'funktion' ist nicht dynamisch (C++)
• E2145: Die Funktionen 'funktion1' und 'funktion2' verwenden dieselbe DDVT-Zuordnungsnummer (C++)
• E2146: Bezeichner zur Vervollständigung der Deklaration erforderlich (C++)
• E2147: Parameterdeklaration darf nicht mit 'bezeichner' beginnen (C++)
• E2148: Vorgabewert für Parameter 'parameter' redeklariert (C++)
• E2149: Parameter-Vorgabewert redeklariert (C++)
• E2150: Typ des voreingestellten Parameterwerts stimmt nicht überein (C++)
• E2151: Typ des voreingestellten Werts für Parameter 'parameter' stimmt nicht überein (C++)
• E2152: Voreingestellter Ausdruck darf keine lokalen Variablen verwenden (C++)
• E2153: Für die Define-Anweisung ist ein Bezeichner erforderlich (C++)
• E2154: 'bezeichner' darf nicht mit einem Namespace-Alias definiert werden (C++)
• E2155: Zu viele default-Zweige (C++)
• E2156: default-Anweisung außerhalb der switch-Anweisung (C++)
• E2157: Für das Löschen eines Objekts ist genau eine Umwandlung in einen Zeigeroperator erforderlich (C++)
• E2158: Operand von 'delete' darf kein const-Zeiger sein (C++)
• E2159: far-Klasse darf nicht von huge-Basis 'basis' abgeleitet werden (C++)
• E2160: far-Klasse darf nicht von near-Basis 'basis' abgeleitet werden (C++)
• E2161: huge-Klasse darf nicht von far-Basis 'basis' abgeleitet werden (C++)
• E2162: huge-Klasse darf nicht von near-Basis 'basis' abgeleitet werden (C++)
• E2163: near-Klasse darf nicht von far-Basis 'basis' abgeleitet werden (C++)
• E2164: near-Klasse darf nicht von huge-Basis 'basis' abgeleitet werden (C++)
• E2165: Destruktor darf keine Festlegung des Rückgabetyps enthalten (C++)
• E2166: Zugriff auf Destruktor für 'klasse' nicht möglich (C++)
• E2167: 'funktion' wurde bereits mit dem Sprachmodifizierer 'sprache' deklariert (C++)
• E2168: Division durch Null (C++)
• E2169: 'bezeichner' legt mehrere oder doppelte ZugriffsBezeichner fest (C++)
• E2170: Klasse wurde von Basisklasse 'klasse' mehr als einmal abgeleitet (C++)
• E2171: Für die Funktion 'funktion' existiert bereits ein Funktionsrumpf (C++)
• E2172: Doppelte case-Marke (C++)
• E2173: Doppelte Behandlungsroutine für 'typ1', 'typ2' bereits zugewiesen (C++)
• E2174: 'name'-Behandlungsroutine muss die letzte sein (C++)
• E2175: Zu viele Speicherklassen in der Deklaration (C++)
• E2176: Zu viele Typen in der Deklaration (C++)
• E2177: Redeklaration des #pragma-Package mit verschiedenen Parametern (C++)
• E2178: VIRDEF-Namenskonflikt bei 'funktion' (C++)
• E2179: virtual mehr als einmal angegeben (C++)
• E2180: Dispid-Anweisung nummer bereits von bezeichner verwendet (C++)
• E2181: Eine 'dynamic/virtual'-Funktion darf nicht mit einer 'dynamic/virtual'-Funktion überschrieben werden (C++)
• E2182 Ungültiger Parameter bei __emit__ (C++)
• E2183: Datei muss mindestens eine externe Deklaration enthalten (C++)
• E2184: Syntax-Fehler bei enum-Anweisung (C++)
• E2185: Der Wert von 'bezeichner' liegt nicht innerhalb des Bereichs von 'typname' (C++)
• E2186: Unerwartetes Dateiende im in Zeile 'zeilennummer' beginnenden Kommentar (C++)
• E2187: Unerwartetes Dateiende in in Zeile 'zeilennummer' beginnender Bedingung (C++)
• E2188: Ausdruckssyntax (C++)
• E2189: extern-Variable kann nicht initialisiert werden (C++)
• E2190: Unerwartete } (C++)
• E2191: '__far16' darf nur mit '__pascal' oder '__cdecl' verwendet werden (C++)
• E2192: Zu wenige Parameter im Aufruf (C++)
• E2193: Zu wenige Parameter im Aufruf von 'funktion' (C++)
• E2194: Datei 'dateiname' nicht gefunden (C++)
• E2195: Funktionsaufruf kann nicht ausgewertet werden (C++)
• E2196: Adresse der Elementfunktion 'funktion' nicht gefunden (C++)
• E2197: Dateiname zu lang (C++)
• E2198: Ungültige Formatierungsanweisung für Ausdruck (C++)
• E2199: friend-Funktion 'funktion' der Vorlage muss vorher deklariert werden. (C++)
• E2200: Funktionen dürfen nicht Teil von struct oder union sein (C++)
• E2201: Zu viele globale Variablen in der Datei definiert (C++)
• E2202: Goto zu Exception-Behandlungsroutine nicht zulässig (C++)
• E2203: Goto umgeht die Initialisierung einer lokalen Variable (C++)
• E2204: Maximalgröße der Gruppe überschritten: 'name' (C++)
• E2205: Ungültiger Typ 'typ' in __automated-Abschnitt (C++)
• E2206: Ungültiges char-Zeichen 'zeichen' (0x'Wert') (C++)
• E2207: Implizite Konvertierung von 'typ1' nach 'typ2' nicht zulässig (C++)
• E2208: Auf inaktiven Bereich kann nicht zugegriffen werden (C++)
• E2209 include-Datei 'dateiname' kann nicht geöffnet werden (C++)
• E2210: Referenzelement 'element' ist nicht initialisiert (C++)
• E2211: Assembler-Inline-Ausdrücke in inline- und Template-Funktionen nicht zulässig (C++)
• E2212: Funktion nach externer Verwendung als inline definiert (C++)
• E2213: 'ausdruck' ungültig in Bereichsüberprüfung (C++)
• E2214: In einer lokalen Klasse darf keine inline-Funktion/statische Daten vorhanden sein (C++)
• E2215: Bindungsspezifikationen nicht zulässig (C++)
• E2216: turboc.$ln kann nicht erstellt werden (C++)
• E2217: Lokale Daten überschreiten die Segmentgröße (C++)
• E2218: Templates dürfen nur innerhalb von Klassen oder Namespaces deklariert werden (C++)
• E2219: Inkorrekte Anzahl von Argumenten im Makro-Aufruf 'makro' (C++)
• E2220: Ungültiges Trennzeichen bei Makro-Argumenten (C++)
• E2221: Fehler in der Makro-Argumentsyntax (C++)
• E2222: Makro-Erweiterung zu lang (C++)
• E2223: Zu viele Dezimalzeichen (C++)
• E2224: Zu viele Exponenten (C++)
• E2225: Zu viele Initialisierungswerte (C++)
• E2225: Zu viele Parameter im Aufruf (C++)
• E2227: Zu viele Parameter im Aufruf von 'funktion' (C++)
• E2228: Zu viele Fehlermeldungen oder Warnungen (C++)
• E2229: Element 'element' hat denselben Namen wie seine Klasse (C++)
• E2230: Für die Initialisierung eines Inline-Datenelements ist ein Konstantenausdruck vom Typ Integer erforderlich (C++)
• E2231: Element 'element' kann nicht ohne ein Objekt verwendet werden (C++)
• E2232: Konstante/Referenz-Element 'element' in Klasse ohne Konstruktoren (C++)
• E2233: Klassenelement kann hier nicht initialisiert werden (C++)
• E2234: Speicherreferenz erwartet (C++)
• E2235: Elementfunktion muss aufgerufen oder ihre Adresse übernommen werden (C++)
• E2236: 'bezeichner' fehlt in Gültigkeitsbereichsvorgabe (C++)
• E2238: Bezeichner 'bezeichner' mehrfach deklariert (C++)
• E2239: 'bezeichner' muss eine Elementfunktion sein (C++)
• E2240: Konvertierung eines near-Zeigers nicht zulässig (C++)
• E2241: In Klassen im VCL-Stil definierte Destruktoren müssen virtuell sein (C++)
• E2242: Für 'spezifizierer' ist ein Klassentyp im Delphi-Stil erforderlich (C++)
• E2243: Mit 'new' zugewiesenes Array darf keine Initialisierungswerte besitzen (C++)
• E2244: 'new' und 'delete' nicht unterstützt (C++)
• E2245: Referenz kann nicht zugewiesen werden (C++)
• E2246: 'klasse' ist keine abstrakte, public, einzelne Vererbungs-Klassenhierarchie ohne Daten (C++)
• E2247: Zugriff auf 'element' nicht möglich (C++)
• E2248: Standardkonstruktor zum Initialisieren des Arrayelements vom Typ 'klasse' nicht gefunden (C++)
• E2249: = erwartet (C++)
• E2250: Keine Basisklasse für die Initialisierung (C++)
• E2251: Standardkonstruktor zum Initialisieren der Basisklasse 'klasse' nicht gefunden (C++)
• E2252: 'catch' erwartet (C++)
• E2253: Aufrufkonvention gehört zum Funktionstyp, nicht zu closure (C++)
• E2254: : erwartet nach private/protected/private (C++)
• E2255: Verwenden Sie :: zur Übernahme der Adresse einer Elementfunktion (C++)
• E2256: Kein : nach ? (C++)
• E2257: , erwartet (C++)
• E2258: Deklaration erwartet (C++)
• E2259: Vorgabewert fehlt (C++)
• E2260: Vorgabewerte für nachfolgende Parameter 'parameter' fehlen (C++)
• E2261: Für die Verwendung von dispid mit einer Eigenschaft ist get oder set erforderlich (C++)
• E2262: '__except' oder '__finally' erwartet nach '__try' (C++)
• E2263: Exception-Behandlungsroutine nicht aktiviert (C++)
• E2264: Ausdruck erwartet (C++)
• E2265: Abschluss des Dateinamens fehlt (C++)
• E2266: Keine Dateinamen angegeben (C++)
• E2267: Die erste Basis muss eine VCL-Klasse sein (C++)
• E2268: Aufruf der undefinierten Funktion 'funktion' (C++)
• E2269: Die Funktion 'funktion' steht nicht zur Verfügung (C++)
• E2270: > erwartet (C++)
• E2271: Bezeichner fehlt bei goto-Anweisung (C++)
• E2272: Bezeichner erwartet (C++)
• E2273: 'main' darf nicht mit static oder inline deklariert werden (C++)
• E2274: < erwartet (C++)
• E2275: { erwartet (C++)
• E2276: ( erwartet (C++)
• E2277: L-Wert erwartet (C++)
• E2278: Delphi-Klassen dürfen nicht mehrere Basisklassen haben (C++)
• E2279: Standardkonstruktor zur Initialisierung des Elements 'bezeichner' nicht gefunden (C++)
• E2280: Elementbezeichner erwartet (C++)
• E2281: Für bezeichner1 ist die Definition von bezeichner2 als Zeigertyp erforderlich (Haben Sie #include <%s> verwendet?) (C++)
• E2282: Name eines Namespace erwartet (C++)
• E2283: Verwenden Sie . oder -> zum Aufruf von 'funktion' (C++)
• E2284: Verwenden Sie . oder -> zum Aufruf von 'element', oder & zur Übernahme der Adresse (C++)
• E2285: Keine Übereinstimmung für 'argument(e)' (C++)
• E2286: Auflösung von überladenen Funktionen nicht unterstützt (C++)
• E2287: Parameter 'nummer' hat keinen Namen (C++)
• E2288: Zeiger auf Struktur auf linker Seite von -> oder von ->* erforderlich (C++)
• E2289: __published- oder __automated-Abschnitte werden nur für Delphi-Klassen unterstützt (C++)
• E2290: Bei 'bezeichner' fehlt ] (C++)
• E2291: } erwartet (C++)
• E2292: Funktion sollte einen Wert zurückgeben (C++)
• E2293: ) erwartet (C++)
• E2294: Auf linker Seite der Struktur ist . oder .* erforderlich (C++)
• E2295: Zu viele Template-Spezialisierungen von 'spezifizierer' (C++)
• E2296: Schablonen werden nicht unterstützt (C++)
• E2297: 'this' kann nur für Elementfunktionen verwendet werden (C++)
• E2298: 'funktion' kann aus Template-Funktion 'template' nicht generiert werden (C++)
• E2299: Template-Spezialisierung kann aus 'bezeichner' nicht generiert werden (C++)
• E2300: Spezialisierungs-Übereinstimmungstyp für 'bezeichner' kann nicht generiert werden (C++)
• E2301: Templates dürfen in closure-Argumenten nicht verwendet werden – verwenden Sie typedef (C++)
• E2302: Keine Typinformation (C++)
• E2303: Typname erwartet (C++)
• E2304: Konstante/Referenz-Variable 'variable' muss initialisiert sein (C++)
• E2305: 'klasse::'klasse' (''klasse'&) zum Kopieren eines Vektors nicht gefunden ODER klasse'::operator=('klasse'&) zum Kopieren eines Vektors nicht gefunden (C++)
• E2306: Virtuelle Basisklassen werden bei Delphi-Klassen nicht unterstützt (C++)
• E2307: Typ 'typ' ist keine definierte Klasse bei virtuellen Funktionen (C++)
• E2308: Bei do-Anweisung fehlt das Schlüsselwort while (C++)
• E2309: Inline-Anweisungen im Assembler Code nicht zulässig (C++)
• E2310: Nur Elementfunktionen dürfen mit 'const' oder 'volatile' deklariert werden (C++)
• E2311: Nicht-virtuelle Funktion 'funktion' ist abstrakt deklariert (C++)
• E2312: 'konstruktor' ist keine eindeutige Basisklasse von 'klasse' (C++)
• E2313: Konstantenausdruck erforderlich (C++)
• E2314: Aufruf einer Nicht-Funktion (C++)
• E2315: 'element' ist kein Element von 'klasse', weil der Typ nicht definiert ist (C++)
• E2316: 'bezeichner' ist kein Element von 'struct' (C++)
• E2317: 'bezeichner' ist kein Parameter (C++)
• E2318: 'typ' ist kein polymorpher Klassentyp (C++)
• E2319: 'bezeichner' ist keine public-Basisklasse von 'klassentyp' (C++)
• E2320: Skalarer Ausdruck erwartet (C++)
• E2321: Deklaration deklariert weder ein Tag noch einen Bezeichner (C++)
• E2322: Ungültiges Zahlenformat (C++)
• E2323: Ungültiges Zahlensuffix (C++)
• E2324: Numerische Konstante zu lang (C++)
• E2325: Ungültige oktale Ziffer (C++)
• E2326: Setzen Sie __declspec(spec1[, spec2]) zum Verbinden von mehreren __declspec-Modifizierer ein (C++)
• E2327: Operatoren dürfen keine Argumente mit voreingestellten Werten haben (C++)
• E2328: Klassen mit Eigenschaften dürfen nicht über ihren Wert kopiert werden (C++)
• E2329: Ungültige Kombination von Opcode und Operanden (C++)
• E2330: Operator muss als Funktion deklariert sein (C++)
• E2331: Anzahl der zulässigen Optionsänderungen überschritten (C++)
• E2332: Variable 'variable' wurde optimiert und steht nicht zur Verfügung (C++)
• E2333: Klassenelement 'element' ist außerhalb der Klasse deklariert (C++)
• E2334: Namespace-Element 'bezeichner' ist außerhalb des Namespace deklariert (C++)
• E2335: Überladene Funktion 'funktionsname' ist in diesem Kontext mehrdeutig (C++)
• E2336: Zeiger auf überladene Funktion 'funktion' stimmt nicht mit 'typ' überein (C++)
• E2337: Nur eine aus einer Gruppe von überladenen Funktionen darf "C" sein (C++)
• E2338: Nur Programme, die die Speichermodelle medium, large und huge verwenden, können überlagert werden (C++)
• E2339: 'main' darf nicht überladen werden (C++)
• E2340: Keine Übereinstimmung des Typs beim Parameter 'nummer' (C++)
• E2341: Keine Übereinstimmung des Typs beim Parameter 'nummer' im Aufruf von 'funktion' (C++)
• E2342: Keine Übereinstimmung des Typs beim Parameter 'parameter' (C++)
• E2343: Keine Übereinstimmung des Typs beim Parameter 'parameter' im Aufruf von 'funktion' (C++)
• E2344: 'bezeichner' bereits deklariert (C++)
• E2345: Zugriffsrechte können nur in public oder protected geändert werden (C++)
• E2346: Zugriffsspezifikation von 'eigenschaft' muss Elementfunktion sein (C++)
• E2347: Keine Entsprechung der Parameter in 'spezifizierer' mit Zugriffsspezifikation der Eigenschaft 'eigenschaft' (C++)
• E2348: Speicherbezeichner bei Array-Eigenschaften nicht zulässig (C++)
• E2349: Nicht-übertragbare Zeigerkonvertierung (C++)
• E2350: Ein Zeiger oder eine Referenz auf eine Referenz darf nicht definiert werden (C++)
• E2351: Statische Datenelemente sind in __published oder __automated Abschnitten nicht zulässig (C++)
• E2352 Instanz der abstrakten Klasse 'klasse' kann nicht erzeugt werden (C++)
• E2353: Klasse 'klasse' ist abstrakt, weil 'element = 0' (C++)
• E2354: Die Auswertung zweier Operanden muss denselben Typ ergeben (C++)
• E2355: Rekursive Template-Funktion: 'x' instantiiert 'y' (C++)
• E2356: Redeklaration von 'bezeichner' mit anderem Typ (C++)
• E2357: Eine mit 'typ1', initialisierte Referenz-Variable muss einen L-Wert des Typs 'typ2' haben (C++)
• E2358: Referenzelement 'element' benötigt einen temporären Initialisierungswert (C++)
• E2359: Referenzelement 'element' wurde mit einem Nicht-Referenz-Parameter initialisiert (C++)
• E2360: Ungültige Registerkombination (z.B. [BP+BX]) (C++)
• E2361: 'spezifizierer' wurde bereits einbezogen (C++)
• E2362: Für Wiederholungszähler ist ein L-Wert erforderlich (C++)
• E2363: Versuch, eine Referenz an die lokale Variable 'bezeichner' zurückzugeben (C++)
• E2364: Versuch, eine Referenz an ein lokales Objekt zurückzugeben (C++)
• E2365: Elementzeiger auf rechter Seite von .* oder ->* erforderlich (C++)
• E2366: RTTI-Klasse kann nicht von Nicht--RTTI-Basis abgeleitet werden ODER E2367 Nicht-RTTI-Klasse kann nicht von RTTI-Basis abgeleitet werden (C++)
• E2368: RTTI steht für die Ausdrucksauswertung nicht zur Verfügung (C++)
• E2369: Ergebnis einer Eigenschaftszuweisung kann nicht als R-Wert verwendet werden (C++)
• E2370: Einfacher Typenname erwartet (C++)
• E2371: sizeof für Bitfelder nicht zulässig (C++)
• E2372: sizeof für Funktionen nicht zulässig (C++)
• E2373: Bitfeld darf nicht static sein (C++)
• E2374: Funktion 'funktion' darf nicht static sein (C++)
• E2375: Überlauf des Assembler-Stacks (C++)
• E2376: In Anweisung fehlt (C++)
• E2377: In Anweisung fehlt ) (C++)
• E2378: do-while-Anweisung fehlt oder for-Anweisung fehlt ; (C++)
• E2379: Anweisung fehlt ; (C++)
• E2380: Nicht abgeschlossene String- oder Zeichen-Konstante (C++)
• E2381: Struktur zu lang (C++)
• E2382: Seiteneffekte nicht zulässig (C++)
• E2383: Der Auswahlausdruck in den Klammern einer switch-Anweisung muss ganzzahlig sein (C++)
• E2384: Elementfunktion der near-Klasse kann nicht durch einen Zeiger des Typs 'typ' aufgerufen werden (C++)
• E2385 'near'-Member-Funktion '%s' kann nicht durch Zeigertyp '%s' aufgerufen werden (C++)
• E2386: Parameter 'parameter' kann nicht in einen komplexen Teil-Spezialisierungsausdruck aufgenommen werden (C++)
• E2387: Teil-Spezialisierungen dürfen keine abhängigen, typenlosen Parameter ('parameter') spezifizieren (C++)
• E2388: Argumentliste der Spezialisierung darf nicht identisch mit der Parameterliste der Haupt-Schablone sein (C++)
• E2389: Keine Übereinstimmung des Substitutionsarguments und des Template-Parameters 'parameter' (C++)
• E2390: Keine Übereinstimmung des Parameters 'nummer' in Template-Klassenname 'template' (C++)
• E2391: Keine Übereinstimmung des Parameters 'parameter' in Template-Klassenname 'template' (C++)
• E2392: Template-Instanz 'template' bereits instantiiert (C++)
• E2393: Adresse des typenlosen, nicht-referenzierten Template-Parameters 'parameter' kann nicht übernommen werden (C++)
• E2394: Zu wenig Argumente an Template 'template' übergeben (C++)
• E2395: Zu viel Argumente an Template 'template' übergeben (C++)
• E2396: Template-Argument muss ein konstanter Ausdruck sein (C++)
• E2397: Template-Argument darf keine static oder local Einbindungsangabe haben (C++)
• E2398: Template-Funktionsargument 'argument' nicht in Argumenttypen verwendet (C++)
• E2399: Template-Argument 'arg' in Template-Klasse 'klasse' darf nicht auf diese Weise referenziert werden (C++)
• E2400: Typenloses Template-Argument muss von skalarem Typ sein (C++)
• E2401: Ungültige Template-Argumentliste (C++)
• E2402: Ungültiger Basisklassentyp: formaler Typ 'typ' geht zurück auf 'typ' (C++)
• E2403: Abhängige Aufrufsspezifikation ergibt die Nicht-Funktion 'name' (C++)
• E2404: Abhängiger Typqualifizierer 'qualifizierer' hat keinen Elementtyp mit dem Namen 'name' (C++)
• E2405: Abhängige Template-Referenz 'bezeichner' ergibt Nicht-Template-Symbol (C++)
• E2406: Abhängiger Typqualifizierer 'qualifizierer' ist keine Klasse oder Struktur (C++)
• E2407: Abhängiger Typqualifizierer 'qualifizierer' hat kein Elementsymbol mit dem Namen 'name' (C++)
• E2408: Standardwerte dürfen nur in Template-Deklarationen der Hauptklasse festgelegt werden (C++)
• E2409: Keine gültige Spezifizierung für 'bezeichner' gefunden (C++)
• E2410: Fehlende Template-Parameter bei friend-Template 'template' (C++)
• E2411: Deklaration der Standardparameter der Elementfunktion nach der Spezialisierung wurde bereits erweitert (C++)
• E2412: Deklaration der Standardparameter der Elementfunktion nach der Spezialisierung wurde bereits erweitert (C++)
• E2413: Ungültige Template-Funktionsdeklaration (C++)
• E2414: Destruktoren dürfen nicht als Template-Funktionen deklariert werden (C++)
• E2415: Template-Funktionen dürfen nur mit type eingeleitete Argumente haben (C++)
• E2416: Ungültige Template-Funktionsdeklaration (C++)
• E2417: Template-Parameter dürfen nicht in expliziten Spezialisierungen von 'spezifizierer' festgelegt werden (C++)
• E2418: Maximale Instantiierungstiefe überschritten; suchen Sie nach Rekursionen (C++)
• E2419: Fehler beim Instantiieren der Template 'template' (C++)
• E2420: Explizite Instantiierung darf nur in globalen Bereichen verwendet werden (C++)
• E2421: Lokaler Typ 'bezeichner' darf nicht als Template-Argument verwendet werden (C++)
• E2422: Keine Übereinstimmung des Argumenttyps in Redeklaration des Template-Parameters 'parameter' (C++)
• E2423: Explizite Spezialisierung oder Instantiierung der nicht-vorhandenen Template 'template' (C++)
• E2424: Template-Klasse zu tief verschachtelt: 'klasse' (C++)
• E2425: 'element' ist kein gültiges Template-Typelement (C++)
• E2426: Für die explizite Spezialisierung von 'bezeichner' ist die Deklaration 'template<>' erforderlich (C++)
• E2427: 'main' kann keine Template-Funktion sein (C++)
• E2428: Templates müssen Klassen oder Funktionen sein (C++)
• E2429: Ungültige Teil-Spezialisierung von 'spezifizierer' (C++)
• E2430: Anzahl der Template-Parameter stimmt nicht mit Redeklaration von 'spezifizierer' überein (C++)
• E2431: Typenlose Template-Parameter können keine Fließkomma-, Klassen- oder void-Typen sein (C++)
• E2432: Der Qualifizierer 'template' muss eine Instanz einer Template-Klasse oder -Funktion bezeichnen (C++)
• E2433: Spezialisierung nach erster Verwendung der Schablone (C++)
• E2434: In Template-Deklaration fehlen Template-Parameter ('template<...>') (C++)
• E2435: Zu viele Template-Parametergruppen angegeben (C++)
• E2436: Standardtyp für Template-Argument 'arg' bezeichnet keine Haupt-Template-Klasse (C++)
• E2437: Nach 'typname' muss ein qualifizierter, abhängiger Typname folgen (C++)
• E2438: Template-Argumente müssen eine Klasse bezeichnen (C++)
• E2439: 'typname' ist nur in Template-Deklarationen zulässig (C++)
• E2440: Spezialisierung kann aus 'bezeichner' nicht generiert werden, weil dieser Typ noch nicht definiert wurde (C++)
• E2441: 'spezifizierer' wird instantiiert (C++)
• E2442: Zwei aufeinander folgende Punkte (C++)
• E2443: Basisklasse 'klasse' wurde mehr als einmal initialisiert (C++)
• E2444: Element 'element' wurde mehr als einmal initialisiert (C++)
• E2445: Variable 'bezeichner' wurde mehr als einmal initialisiert (C++)
• E2446: Funktionsdefinition darf keine typedef-Deklaration sein (C++)
• E2447: 'bezeichner' muss ein bereits definiertes enum sein (C++)
• E2448: Undefinierte Sprungadresse 'bezeichner' (C++)
• E2449: Größe von 'bezeichner' unbekannt oder Null (C++)
• E2450: Undefinierte Struktur 'struktur' (C++)
• E2451: Undefiniertes Symbol 'bezeichner' (C++)
• E2452: Größe des Typs ist unbekannt oder Null (C++)
• E2453: Größe des Typs 'bezeichner' ist unbekannt oder Null (C++)
• E2454: union darf kein Basistyp sein (C++)
• E2455: union darf keinen Basistyp haben (C++)
• E2456: Union-Element 'element' ist vom Typ einer Klasse mit Konstruktor (oder Destruktor oder Operator =) (C++)
• E2457: Klassen im Delphi-Stil müssen über Referenzen angesprochen werden (C++)
• E2458: Klassen im Delphi-Stil müssen von Delphi-Klassen abgeleitet werden (C++)
• E2459: Klassen im Delphi-Stil müssen mit dem Operator new erstellt werden (C++)
• E2460: Für Klassen im Delphi-Stil ist eine aktivierte Exception-Behandlung erforderlich (C++)
• E2461: '%s' muss zur Laufzeit initialisiert/finalisiert werden (C++)
• E2462: 'virtual' kann nur für Nicht-Template-Elementfunktionen verwendet werden (C++)
• E2463: 'basis' ist eine indirekte, virtuelle Basisklasse von 'klasse' (C++)
• E2464: 'virtual' kann nur für Elementfunktionen verwendet werden (C++)
• E2465: unions können keine virtuellen Funktionen als Elemente enthalten (C++)
• E2466: void & ist kein gültiger Typ (C++)
• E2467: Void 'funktion' kann keinen Wert zurückgeben (C++)
• E2468: Ein Wert vom Typ void ist nicht zulässig (C++)
• E2469: Die Speichermodelle tiny und huge können mit Windows nicht verwendet werden (C++)
• E2470: Für typeid muss der Header <typeinfo> einbezogen werden (C++)
• E2471: pragma checkoption fehlgeschlagen: Optionen sind anders als erwartet (C++)
• E2472: Eine Elementfunktion kann nicht über die Instantiierung deklariert werden (C++)
• E2473: Ungültige explizite Spezialisierung von 'spezifizierer' (C++)
• E2474: 'funktion' darf nicht als static oder inline deklariert werden (C++)
• E2475: 'main' darf keine Template-Funktion sein (C++)
• E2476: 'funktion' kann nicht überladen werden (C++)
• E2477: Für Template 'template' wurden zu wenig Template-Parameter deklariert (C++)
• E2478: Für Template 'template' wurden zu viele Template-Parameter deklariert (C++)
• E2479: Template-Klasse und Funktion dürfen nicht denselben Namen 'name' haben (C++)
• E2480: Template-Parameter können nicht in komplexe Teil-Spezialisierungsargumente aufgenommen werden (C++)
• E2481: Unerwartete String-Konstante (C++)
• E2482: String-Konstante erwartet (C++)
• E2483: Array-Dimension 'bezeichner' kann nicht bestimmt werden (C++)
• E2484: Der Name der Template-Klasse 'klasse' kann nicht überladen werden (C++)
• E2485: Adresse des Arrayelements kann nicht als typenloses Template-Argument verwendet werden (C++)
• E2486: Adresse des Klassenelements kann nicht als typenloses Template-Argument verwendet werden (C++)
• E2487: Für explizite Spezialisierungen können keine Standardfunktionsargumente festgelegt werden (C++)
• E2488: Maximale Antworttiefe für Token überschritten; suchen Sie nach Rekursionen (C++)
• E2489: Maximale Antworttiefe für Optionskontext überschritten; suchen Sie nach Rekursionen (C++)
• E2490: Spezialisierung innerhalb von Template-Klassen noch nicht implementiert (C++)
• E2491: Maximale VIRDEF-Anzahl überschritten; suchen Sie nach Rekursionen (C++)
• E2492: Eigenschaften dürfen nur mit einfachen Anweisungen, wie z.B. \"prop = value;\" zugewiesen werden (C++)
• E2493: Ungültiger GUID-String (C++)
• E2494: Nicht erkannter __declspec-Modifizierer (C++)
• E2495: Redefinition von uuid ist nicht identisch (C++)
• E2496 Ungültiger Aufruf von uuidof(struct type |variable) (C++)
• E2497: Mit Typ 'typ' ist keine GUID assoziiert (C++)
• E2498: Vorher definierte struct GUID erforderlich (C++)
• E2499: Ungültiges Format von __declspec(uuid(GuidString)) (C++)
• E2500: __declspec(selectany) ist nur für initialisierte und extern sichtbare Variablen (C++)
• E2501: Import-Datei 'dateiname' kann nicht geöffnet werden. (C++)
• E2502: Fehler beim Auflösen von #import: problem (C++)
• E2503: Fehlende oder falsche Version von TypeLibImport.dll (C++)
• E2504: 'dynamic' kann nur mit Nicht-Vorlagen-Element-Funktionen verwendet werden (C++)
• E2505: Explizite Instanziierung benötigt ausgearbeitete Typspezifikation (z.B: "class foo<int") (C++)
• E2506: Explizite Spezialisierung ist nicht eindeutig: Template-Arg. müssen angegeben werden (C++)
• E2507: 'klasse' ist keine direkte Basis-Klasse von 'klasse' (C++)
• E2508: 'using' kann sich nicht auf eine Vorlagenspezialisierung beziehen (C++)
• E2509: Wertebereich ist überschritten (C++)
• E2510: Operandengröße stimmt nicht überein (C++)
• E2511: Makroargument wurde nicht beendet (C++)
• E2512: RTTI kann nicht als Rückgabetyp von 'funktion' ausgegeben werden (C++)
• E2513: RTTI kann nicht als 'parameter' in 'funktion' ausgegeben werden (C++)
• E2514: Die Auflösung überladener Elemente ist während der Template-Instantiierung (noch) nicht möglich (C++)
• E2515: Ein Element einer generischen Template-Klasse kann nicht explizit spezialisiert werden (C++)
• E2516 LOOP/JCXZ außerhalb des Wertebereichs (C++)
• E2518 typeof kann bei einem Bitfeld nicht angewendet werden (C++)
• E2519 typeof fehlgeschlagen (C++)
• E2520 Die GNU-Instantiierung von externen Vorlagen wird nicht unterstützt (C++)
• E2521 Die mit 'implements' gekennzeichnete __property '%s' muss einem Feld zugeordnet werden (C++)
• E2522: Nicht konstante Funktion 'funktion' für konstantes Objekt aufgerufen (C++)
• E2523: Nicht-volatile Funktion 'name' für volatile Objekt aufgerufen (C++)
• E2524: Anonyme Strukturen/Varianten dürfen in C++ keine anonymen Member haben (C++)
• E2525: Vor dem Einbeziehen von xstring muss _PCH_STATIC_CONST definiert werden, damit dieses Feature verwendet werden kann (C++)
• E2526: Eigenschaft 'name' verwendet eine andere Eigenschaft als Getter/Setter; Nicht zulässig (C++)
• E2527: Option 'name' kann nicht über 'name' gesetzt werden (C++)
• E2528: Option 'name' muss vor dem Start der Compilierung gesetzt werden (C++)
• E2529: Pfad 'pfad' überschreitet die Maximalgröße von 'n' (C++)
• E2530: Nicht erkannte Option oder keine Hilfe verfügbar (C++)
• E2531: Parameter ist ein unvollständiger Typ (C++)
• E2532: Konstante in neuem Ausdruck benötigt Initialisierung (C++)
• E2533 Keine Entsprechung der Parameter (Typname erforderlich) (C++)
• E2534: Integraler Konstantenausdruck erwartet (C++)
• E2535 Unvollständiger Typ darf nicht Teil einer throw-Spezifikation sein (C++)
• E2536 Unvollständiger Typ darf nicht Teil einer Exception-Deklaration sein (C++)
• E2537: Instanz der abstrakten Klasse kann nicht erzeugt werden (C++)
• E2538 Statisches Assert fehlgeschlagen: '%s' (C++)
• E2026: Konstantenausdruck erwartet (C++)
• E2540: String-Literal erwartet (C++)
• E2541 Attribut '%s' kann nicht gesetzt werden (C++)
• E2542 '%s' ist als 'final' gekennzeichnet und kann nicht überschrieben werden (C++)
• E2543 Die Kombination von Optionen %s ist nicht zulässig (C++)
• E2544 Exception-Spezifikationen für Funktion stimmen nicht überein (C++)
• E2545 Der dem Enum zugrunde liegende Typ muss ein Integer sein (C++)
• E2546 Redeklaration von enum ist nicht identisch (C++)
• E2547 ... erwartet (C++)
• E2548 ... wurde nicht erwartet; Ausdruck ist kein variadisches Template Pattern (C++)
• E2549 Operand ist kein Parameterpaket (C++)
• E2550 Einer variadischen Template in einer Argumentenliste dürfen keine Argumente folgen (C++)
• E2551 Return-Anweisung in _finally-Block nicht zulässig (C++)
• E2552 Dieses Feature wird (noch) nicht unterstützt (C++)
• E2553: Redeklaration von '%s' stimmt mit %s nicht überein (C++)
• E2554 Abstrakte Funktion '%s' darf nicht als 'final' deklariert werden (C++)
• E2555 Option1 muss vor Option2 stehen (C++)
• E2556 Ungültiger universeller Zeichenname '\%s' (C++)
• E2557: Mehrstellige Zeichenkonstante nicht zulässig (C++)
• E2558: Der Wert '\U08x' ist nicht innerhalb der char16 t-Zeichenkonstante (C++)
• E2559: R-Wertreferenz des Typs '%s' kann nicht mit L-Wert des Typs '%s' initialisiert werden (C++)
• E2560 %s sind Typen erforderlich, die als published verwendet werden können (d.h. int, double, DynamicArray<T>, DelphiInterface<T>, UnicodeString etc.) (C++)
• E2561: Member kann nicht explizit in eine bereits für den Export gekennzeichnete Klasse exportiert werden (C++)
• E2562: Funktion mit anderer Bindung definiert
• E2563: Eine Funktion, die gerade definiert wird, kann nicht importiert werden (C++)
• E2564: Interne Bindung kann nicht importiert werden (C++)
• E2565: Eine lokale Variable kann nicht exportiert werden (C++)
• E2566: Ungültiger Typ '%s' in Aufruf von %s (C++)
• E2567: Unzulässige Initialisierung des Arrays '%s' (C++)
• E2568: Unzulässige Initialisierung der Funktion '%s' (C++)
• E2569: Interne Bindung kann nicht exportiert werden (C++)
• E2570: Member kann nicht explizit in für den Import gekennzeichnete Klasse importiert werden (C++)
• E2571: Warnungen als Fehler behandelt (C++)
• E2572 Die mit 'implements' gekennzeichnete Eigenschaft '%s' muss einem Feld zugeordnet werden (C++)
• E2573 Maximale Größe von SAVEMEM muss zwischen %d und %d liegen (C++)

Fehlermeldungen

• F1000: Überlauf einer internen Compiler-Tabelle (C++)
• F1001: Interner Verarbeitungsfehler im Code-Generator (C++)
• F1002: Ausgabedatei 'dateiname' kann nicht erstellt werden (C++)
• F1003: error-Anweisung: 'meldung' (C++)
• F1004: Interner Compiler-Fehler (C++)
• F1005: Include-Dateien zu tief verschachtelt (C++)
• F1006: Ungültiger Aufruf einer Inline-Funktion (C++)
• F1007: Nicht reduzierbarer Ausdruck (C++)
• F1008: Zu wenig Arbeitsspeicher (C++)
• F1009: Eingabedatei 'dateiname' kann nicht geöffnet werden (C++)
• F1010: Datei 'dateiname' kann nicht geöffnet werden (C++)
• F1011: Fehler beim Zuweisen eines Registers (C++)
• F1012: Überlauf des Compiler-Stacks (C++)
• F1013: Fehler beim Schreiben der Ausgabedatei (C++)
• F1014: SAVEmem konnte nicht zugewiesen werden (C++)
• F1015: SAVEmem-Anforderung überschreitet maximal verfügbare Größe (%d MB) (C++)

Hilfethemen zu Warnungen

• W8000: Bei mehrdeutigen Operatoren sind Klammern erforderlich (C++)
• W8001: & bei Funktion überflüssig (C++)
• W8002: Compilierung mit Assembler-Sprachfähigkeiten neu gestartet (C++)
• W8003: Unbekannte Assembler-Anweisung (C++)
• W8004: 'bezeichner' wurde ein Wert zugewiesen, der nie verwendet wird (C++)
• W8005: Bitfelder müssen vom Typ signed oder unsigned int sein (C++)
• W8006: 'bezeichner' wird mit 'bezeichner' initialisiert (C++)
• W8007: Hexadezimalwert enthält mehr als drei Ziffern (C++)
• W8008: Bedingung ist immer wahr ODER Bedingung ist immer falsch (C++)
• W8009: Konstante ist zu lang (C++)
• W8010: Zeilenfortsetzungszeichen \ in //-Kommentar gefunden (C++)
• W8011: Nicht-übertragbarer Zeigervergleich (C++)
• W8012: Vergleich von signed- und unsigned-Werten (C++)
• W8013: Wahrscheinliche Verwendung von 'bezeichner' vor Definition (C++)
• W8014: Deklaration wird ignoriert (C++)
• W8015: Deklarieren Sie 'typ' vor der Verwendung im Prototyp (C++)
• W8016: Größe des Arrays für 'delete' ignoriert (C++)
• W8017: Redefinition von 'x' ist nicht identisch (C++)
• W8018: 'typ' wird 'aufzählung' zugewiesen (C++)
• W8019: Code hat keine Auswirkung (C++)
• W8020: 'bezeichner' ist sowohl als external als auch als static deklariert (C++)
• W8021: Behandlungsroutine für 'typ1' verborgen von vorheriger Behandlungsroutine für 'typ2' (C++)
• W8022: 'funktion1' verbirgt virtuelle Funktion 'funktion2' (C++)
• W8023: Array-Variable 'bezeichner' ist near (C++)
• W8024: Basisklasse 'klasse1' ist auch eine Basisklasse von 'klasse2' (C++)
• W8025: Ungültiges pragma (C++)
• W8026: Funktionen mit 'exception-spezifikationen' werden nicht als Inline expandiert (C++)
• W8027: Funktionen, die 'anweisung' enthalten, werden nicht als Inline expandiert (C++)
• W8028: Temporäre Größe für die Initialisierung von 'bezeichner' verwendet (C++)
• W8029: Temporäre Größe für Parameter '???' verwendet (C++)
• W8031: Temporäre Größe für Parameter 'parameter' ODER W8029 Temporäre Größe für Parameter 'nummer' ODER W8030 Temporäre Größe für Parameter 'parameter' in Aufruf von 'funktion' verwendet ODER W8032 Temporäre Größe für Parameter 'nummer' in Aufruf von 'funktion' verwendet (C++)
• W8032: Temporäre Größe für 'parameter2' in Aufruf von '???' verwendet (C++)
• W8033: Konvertierung in 'typ' schlägt für Elemente der virtuellen Basisklasse 'klasse' fehl (C++)
• W8034: Maximale Genauigkeit für Elementzeiger des Typs 'typ' verwendet (C++)
• W8035: Benutzerdefinierte Meldung (C++)
• W8036: Nicht in ANSI enthaltenes Schlüsselwort verwendet: 'schlüsselwort' (C++)
• W8037: Nicht konstante Funktion 'funktion' für konstantes Objekt aufgerufen (C++)
• W8038: Konstantenelement 'bezeichner' wurde nicht initialisiert (C++)
• W8039: Liste der Konstruktorinitialisierungswerte ignoriert (C++)
• W8040: Funktionsrumpf ignoriert (C++)
• W8041: unsigned-Wert negativiert (C++)
• W8042: Initialisierungswerte für Objekt 'x' ignoriert (C++)
• W8043: Makrodefinition ignoriert (C++)
• W8044: #undef-Anweisung ignoriert (C++)
• W8045: Keine Deklaration für Funktion 'funktion' (C++)
• W8046: #pragma option pop ohne zugehörige #pragma option push (C++)
• W8047: Deklaration der static-Funktion funktion ignoriert (C++)
• W8048: Verwenden Sie für den Zugriff auf Elementtyp 'bezeichner' einen qualifizierten Namen (C++)
• W8049: Verwenden Sie > > für verschachtelte Schablonen anstelle von >> (C++)
• W8050: Keine Typobjektdatei vorhanden; externe Typoptionen werden deaktiviert. (C++)
• W8051: Nicht-volatile Funktion 'funktion' für volatile Objekt aufgerufen (C++)
• W8052: Basisinitialisierung ohne einen Klassennamen ist nun veraltet (C++)
• W8053: 'funktion' ist veraltet (C++)
• W8054: Stil der Funktionsdefinition ist nun veraltet (C++)
• W8055: Möglicher Überlauf in Bit-Verschiebeoperation (C++)
• W8056 Überlauf in mathematischem Integer-Ausdruck (C++)
• W8057: Parameter 'parameter' wird nie verwendet (C++)
• W8058: Präcompilierter Header kann nicht erzeugt werden: 'grund' (C++)
• W8059: Packgröße der Struktur geändert (C++)
• W8060: Möglicherweise inkorrekte Zuweisung (C++)
• W8061: In Initialisierung nur teilweise Klammern vorhanden (C++)
• W8062: Vorherige Optionen und Warnungen nicht wiederhergestellt (C++)
• W8063: Überladener Präfix-Operator 'operator' als Postfix-Operator verwendet (C++)
• W8064: Aufruf der Funktion ohne Prototyp (C++)
• W8065: Aufruf der Funktion 'funktion' ohne Prototyp (C++)
• W8066: Code wird nie erreicht (C++)
• W8067: return-Anweisungen mit und ohne Werte verwendet (C++)
• W8068: Vergleichskonstante außerhalb des Bereichs (C++)
• W8069: Nicht-übertragbare Zeigerkonvertierung (C++)
• W8070: Funktion sollte einen Wert zurückgeben (C++)
• W8071: Bei Konvertierung könnten signifikante Ziffern verloren gehen (C++)
• W8072: Verdächtige Zeigerarithmetik (C++)
• W8073: Undefinierte Struktur 'struktur' (C++)
• W8074: Struktur als Wert übergeben (C++)
• W8075: Verdächtige Zeigerumwandlung (C++)
• W8076: Template-Instanz 'bezeichner' ist bereits instantiiert (C++)
• W8077: Explizite Spezialisierung eines explizit spezialisierten Klassenelements ist sinnlos (C++)
• W8078: throw-Ausdruck verletzt Exception-Spezialisierung (C++)
• W8079: Unterschiedliche Zeiger auf verschiedene char-Typen (C++)
• W8080: 'bezeichner' ist deklariert, wird aber nie verwendet (C++)
• W8081: void-Funktionen dürfen keinen Wert zurückliefern (C++)
• W8082: Division durch Null (C++)
• W8083: #pragma pack pop ohne entsprechendes #pragma pack push (C++)
• W8084: Verwenden Sie Klammern, um den Vorrang zu klären (C++)
• W8085: Funktion 'funktion' als nicht-inline redefiniert (C++)
• W8086: Ungültige Verwendung von #pragma alias "aliasName"="substitutname" (C++)
• W8087: ''operator=='' muss öffentlich (public) sein, um in ''name'' enthalten zu sein (C++)
• W8089: ''operator::'' muss öffentlich (public) sein, um in ''name'' enthalten zu sein (C++)
• W8090: ''operator<'' muss öffentlich (public) sein, um in ''name'' enthalten zu sein (C++)
• W8091: 'typ' Argument 'argument' übergeben an 'funktion' ist ein 'typ'-Iterator: 'typ'-Iterator erwartet (C++)
• W8092: 'typ' Argument 'argument' übergeben an 'funktion' ist kein Iterator: 'typ'-Iterator erwartet (C++)
• W8093: Ungültige Verwendung von #pragma codeseg [seg_name] ["seg_klasse"] [gruppe] (C++)
• W8094: Ungültige Verwendung von #pragma comment( <typ> [,"string"] ) (C++)
• W8095: Ungültige Verwendung von #pragma message( "string" ) (C++)
• W8096: Ungültige Verwendung von #pragma code_seg(["seg_name"[,"seg_klasse"]]) (C++)
• W8097: Nicht alle Optionen können gegenwärtig wiederhergestellt werden (C++)
• W8098: Ungültige mehrstellige Zeichenkonstante (C++)
• W8099: Static main wird nicht als Einsprungpunkt behandelt (C++)
• W8100 %s-Attributdirektive wird ignoriert (C++)
• W8101 Externe C-Bindung wird ignoriert (C++)
• W8102 Implizite Umwandlung von '%s' nach '%s' (C++)
• W8103: Pfad 'pfad' und Dateinamen 'dateiname' überschreiten die Maximalgröße von 'n' (C++)
• W8104: Local Static bei Konstruktor für Multithread-Anwendungen gefährlich (C++)
• W8105: %s-Member in Klasse '%s' ohne Konstruktoren (C++)
• W8106 %s sind veraltet (C++)
• W8107: Typname erwartet (C++)
• W8108: Konstante in neuem Ausdruck benötigt Initialisierung (C++)
• W8109 Parameter '%s' ist ein abhängiger Typ (C++)
• W8110: Doppelte '%s'-Attributdirektive wird ignoriert (C++)
• W8111 Zugriff auf veraltete Entität %s (C++)
• W8112: Unaufgelöste Abhängigkeiten im Ausdruck (C++)
• W8113: Inline-Funktion wurde mit 'extern template' deklariert (C++)
• W8114: Zeichen mit dem universellen Zeichennamen 'unnnn' kann in der aktuellen Codeseite (Codeseitennummer) nicht dargestellt werden (C++)
• W8115: Konstantenausdruck erwartet; Anweisung wird ignoriert (C++)
• W8116: Rückgabe des Zeigers an ein logisches Objekt (C++)
• W8117: Maximale Größe von SAVEMEM muss zwischen %d und %d liegen (C++)
• W8118 Inline-Member-Funktion in Package-Klasse
• W8119: Ausrichtung auf Maximum von %d reduziert (C++)
• W8120: Basisklasse der dllexport-Klasse muss auch dllexport sein (C++)
• W8121: Ungültiges Zeichen aus Quelltext in der aktuellen Text-Gebietseinstellung %s gefunden (C++)
• W8122: dllexport-Klassen-Member '%s' muss den Typ exported haben (C++)
• W8123: Pfad '%s' nicht gefunden - Pfad in Option '%s' ignoriert (C++)
• W8124: Published-Methode '%s' enthält einen nicht publizierbaren Typ (C++)
• W8125: dllexport überschreibt vorheriges dllimport (C++)
• W8126: Basisklasse der exportierten Klasse muss einen exported-Konstruktor haben (C++)
• W8127: Funktion mit anderer Bindung definiert (C++)
• W8128: Eine Funktion, die gerade definiert wird, kann nicht importiert werden (C++)
• W8129: Interface '%s' hat keine GUID (C++)
• W8130 Interface '%s' ist nicht von IUnknown abgeleitet. (Interfaces müssen von IUnknown abgeleitet sein) (C++)
• W8131: Umwandlung der Klasse im Delphi-Stil '%s' in ein Interface. Verwenden Sie stattdessen 'System::interface_cast<%s>(cls)' (C++)
• W8132: Umwandlung des Interface '%s' in eine Klasse im Delphi-Stil. Verwenden Sie stattdessen 'System::interface_cast<%s>(intf)' (C++)
• W8133: Angefordertes savemem überschreitet verfügbare Größe (%d) (C++)
• W8134 Arrays der Klasse '%s' im Delphi-Stil können nicht zugewiesen werden (C++)
• W8135: Unbekanntes #pragma '%s' ignoriert (C++)
• W8136 Initialisierung von TLS-Daten wird auf dieser Plattform nicht unterstützt. (C++)
• W8137 Veraltete Direktive #import gefunden. Bitte verwenden Sie stattdessen das Hilfsprogramm TLIBIMP. (C++)