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

Nach oben zu C++-Referenz

Dieser Abschnitt enthält die Fehlermeldungen und Warnungen des C++-Compilers von RAD Studio für 32-Bit-Windows (BCC32.EXE).

Hinweis: Informationen zu Fehlern/Warnungen des C++-Compilers für 64-Bit-Windows (BCC64.EXE) finden Sie unter:

• Warnungen und Fehler von BCC64

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 '%s' nicht für die Klasse 'klasse' generieren
• 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++)