RAD Studio
Contents
Concepts
Debugging C++ Applications with CodeGuard Error Reporting
CodeGuard Errors
Access Errors
Exception Errors
Function Failure Errors
Resource Errors
CodeGuard Overview
CodeGuard Warnings
Memory Block Comparison Warnings
Pathname Merging and Splitting Warnings
String Comparison Warnings
Developing Database Applications for the Win32 Platform
dbGo Overview
BDE Overview
dbExpress Components
Getting Started with InterBase Express
dbExpress 4 Feature Overview
Blackfish SQL Overview
dbExpress Framework
dbExpress Framework Compatibility
Developing Interoperable Applications
Developing COM Applications
Developing Reports for Your Win32 Applications
Using Rave Reports in RAD Studio
Developing Applications with VCL Components
VCL Overview
Using TEncoding for Unicode Files
Components Available Only on Specific OS
Developing Web Applications with WebSnap
Win32 Web Applications Overview
Developing Web Services with Win32 Applications
Web Services Overview
Developing Windows Applications
Windows Overview
Procedures
CodeGuard Procedures
Using CodeGuard
Database Procedures
Accessing Schema Information
Using Data Explorer to Obtain Connection Information
Configuring TSQL Connection
Connecting to the Application Server using DataSnap Components
Debugging dbExpress Applications using TSQLMonitor
Executing the Commands using TSQLDataSet
Fetching the Data using TSQLDataSet
Specifying the Data to Display using TSQLDataSet
Specifying the Provider using TLocalConnection or TConnectionBroker
Using BDE
Using DataSnap
Using TBatchMove (BDE)
Connecting to Databases with TDatabase
Using TQuery (Procedure)
Using TSQLQuery
Using TSQLStoredProc (Procedure)
Using TSQLTable
Managing Database Sessions Using TSession
Using TSimpleDataSet
Using TSimpleObjectBroker
Using TStoredProc
Using TTable (Procedure)
Using TUpdateSQL to Update a Dataset
Using dbExpress
Adding a New Connection to the Data Explorer
Browsing a Database in the Data Explorer
Executing SQL in the Data Explorer
Modifying Connections in the Data Explorer
Connecting to a Database using the dbExpress Driver Framework
Interoperable Applications Procedures
Using COM Wizards
Reporting Procedures
Adding Rave Reports to RAD Studio
VCL Procedures
Building a Windows "Hello World" Console Application
Developing a Windows Application
Building Application Menus
Building a VCL Forms Application with Decision Support Components
Building VCL Forms Applications With Graphics
Building a VCL Forms MDI Application Using a Wizard
Building a VCL Forms MDI Application Without Using a Wizard
Building a VCL Forms SDI Application
Creating a New VCL Component
Building a VCL Forms ADO Database Application
Building a VCL Forms Application
Creating Actions in a VCL Forms Application
Building a VCL Forms "Hello World" Application
Using ActionManager to Create Actions in a VCL Forms Application
Building a VCL Forms dbExpress Database Application
Building an Application with XML Components
Copying Data From One Stream To Another
Copying a Complete String List (VCL)
Creating Strings
Creating a VCL Form Instance Using a Local Variable
Deleting Strings
Displaying an Auto-Created VCL Form
Displaying a Bitmap Image in a VCL Forms Application
Displaying a Full View Bitmap Image in a VCL Forms Application
Drawing a Polygon in a VCL Forms Application
Drawing Rectangles and Ellipses in a VCL Forms Application
Drawing a Rounded Rectangle in a VCL Forms Application
Drawing Straight Lines In a VCL Forms Application
Dynamically Creating a VCL Modal Form
Dynamically Creating a VCL Modeless Form
Iterating Through Strings in a List
Building a Multithreaded Application
Writing Cleanup Code
Avoiding Simultaneous Thread Access to the Same Memory
Defining the Thread Object
Handling Exceptions
Initializing a Thread
Using the Main VCL Thread
Waiting for Threads
Writing the Thread Function (Procedure)
Placing A Bitmap Image in a Control in a VCL Forms Application
Reading a String and Writing It To a File
Renaming Files
Adding and Sorting Strings
Creating a VCL Forms ActiveX Button
Creating a VCL Forms ActiveX Active Form
Building a VCL Forms Web Browser Application
Creating an Application that Uses Ribbon Controls
Adding Commands to the Ribbon
WebSnap Procedures
Building a WebSnap Application
Building a WebSnap "Hello World" Application
Debugging a WebSnap Application using the Web Application Debugger
Using the HTML Tag Editor
Web Services Procedure
Building a "Hello World" Web Services Application
Reference
C++ Reference
Command Line Utilities
BCC32, the C++ Command-Line Compiler
BRC32, the Resource Shell
BRCC32.EXE, the Resource Compiler
COFF2OMF.EXE, the Import Library Conversion Tool
CPP32.EXE, the C Compiler Preprocessor
DCC32.EXE, the Delphi Command Line Compiler
GREP.EXE, the text search utility
ILINK32.EXE, the Incremental Linker
IMPDEF.EXE, the Module Definition Manager
IMPLIB.EXE, the Import Library Tool
Using Include Files
MAKE
MAKE Directives
MAKE Macros
MAKE Rules (Explicit and Implicit) and Commands
Message Options
Module Definition Files
Using Precompiled Header Files
RLINK32.DLL, the Resource Linker (C++)
TDUMP.EXE, the File Dumping Utility
TLIB.EXE, the Library Manager
Using TOUCH.EXE
TRIGRAPH
RC.EXE, the Microsoft SDK Resource Compiler
WSDLIMP.EXE, the Command Line WSDL Import Tool
C++ Compiler Errors And Warnings (C++)
E2066: Invalid MOM inheritance (C++)
E2525: You must define _PCH_STATIC_CONST before including xstring to use this feature (C++)
E2526: Property 'name' uses another property as getter/setter; Not allowed (C++)
E2008: Published property access functions must use __fastcall calling convention (C++)
E2122: Function call terminated by unhandled exception 'value' at address 'addr' (C++)
E2506: Explicit specialization of 'specifier' is ambiguous: must specify template arguments (C++)
E2483: Array dimension 'specifier' could not be determined (C++)
E2509: Value out of range (C++)
E2510: Operand size mismatch (C++)
E2050: __declspec(delphireturn) class 'class' must have exactly one data member (C++)
E2530: Unrecognized option, or no help available (C++)
E2527: Option 'name' cannot be set via 'name' (C++)
E2528: Option 'name' must be set before compilation begins (C++)
E2074: Value after -g or -j should be between 0 and 255 inclusive (C++)
E2492: Properties may only be assigned using a simple statement, e.g. \"prop = value;\" (C++)
E2505: Explicit instantiation requires an elaborated type specifier (i.e.,"class foo<int>") (C++)
E2100: Invalid template declarator list (C++)
E2102: Cannot use template 'template' without specifying specialization parameters (C++)
E2107: Invalid use of template 'template' (C++)
E2105: 'template' qualifier must specify a member template name (C++)
E2066: Information not available (C++)
E2471: pragma checkoption failed: options are not as expected (C++)
E2504: 'dynamic' can only be used with non-template member functions (C++)
E2191: '__far16' may only be used with '__pascal' or '__cdecl' (C++)
E2199: Template friend function 'function' must be previously declared (C++)
E2502: Error resolving #import: problem (C++)
E2501: Unable to open import file 'filename' (C++)
E2494: Unrecognized __declspec modifier (C++)
E2493: Invalid GUID string (C++)
E2499: Invalid __declspec(uuid(GuidString)) format (C++)
E2496: Invalid call to uuidof(struct type|variable) (C++)
E2511: Unterminated macro argument (C++)
E2489: Maximum option context replay depth exceeded; check for recursion (C++)
E2488: Maximum token reply depth exceeded; check for recursion (C++)
E2491: Maximum VIRDEF count exceeded; check for recursion (C++)
E2230: In-line data member initialization requires an integral constant expression (C++)
E2241: VCL style classes need virtual destructors (C++)
E2524: Anonymous structs/unions not allowed to have anonymous members in C++ (C++)
E2246: x is not abstract public single inheritance class hierarchy with no data (C++)
E2249: = expected (C++)
E2267: First base must be VCL class (C++)
E2472: Cannot declare a member function via instantiation (C++)
E2515: Cannot explicitly specialize a member of a generic template class (C++)
E2474: 'function' cannot be declared as static or inline (C++)
E2498: Need previously defined struct GUID (C++)
E2295: Too many candidate template specializations from 'specifier' (C++)
E2475: 'function' cannot be a template function (C++)
E2299: Cannot generate template specialization from 'specifier' (C++)
E2300: Could not generate a specialization matching type for 'specifier' (C++)
E2497: No GUID associated with type:'type' (C++)
E2522: Non-const function 'function' called for const object (C++)
E2523: Non-volatile function 'name' called for volatile object (C++)
E2513: Cannot emit RTTI for 'parameter' in 'function' (C++)
E2512: Cannot emit RTTI for return type of 'function' (C++)
E2507: 'class' is not a direct base class of 'class' (C++)
E2529: Path 'path' exceeds maximum size of 'n' (C++)
E2495: Redefinition of uuid is not identical (C++)
E2500: __declspec(selectany) is only for initialized and externally visible variables (C++)
E2482: String constant expected (C++)
E2481: Unexpected string constant (C++)
E2386: Cannot involve parameter 'parameter' in a complex partial specialization expression (C++)
E2387: Partial specializations may not specialize dependent non-type parameters ('parameter') (C++)
E2388: Argument list of specialization cannot be identical to the parameter list of primary template (C++)
E2389: Mismatch in kind of substitution argument and template parameter 'parameter' (C++)
E2480: Cannot involve template parameters in complex partial specialization arguments (C++)
E2392: Template instance 'template' is already instantiated (C++)
E2393: Cannot take the address of non-type, non-reference template parameter 'parameter' (C++)
E2399: Cannot reference template argument 'arg' in template class 'class' this way (C++)
E2397: Template argument cannot have static or local linkage (C++)
E2485: Cannot use address of array element as non-type template argument (C++)
E2402: Illegal base class type: formal type 'type' resolves to 'type' (C++)
E2403: Dependent call specifier yields non-function 'name' (C++)
E2404: Dependent type qualifier 'qualifier' has no member type named 'name' (C++)
E2405: Dependent template reference 'identifier' yields non-template symbol (C++)
E2406: Dependent type qualifier 'qualifier' is not a class or struct type (C++)
E2407: Dependent type qualifier 'qualifier' has no member symbol named 'name' (C++)
E2408: Default values may be specified only in primary class template declarations (C++)
E2409: Cannot find a valid specialization for 'specifier' (C++)
E2410: Missing template parameters for friend template 'template' (C++)
E2486: Cannot use address of class member as non-type template argument (C++)
E2411: Declaration of member function default parameters after a specialization has already been expanded (C++)
E2412: Attempting to bind a member reference to a dependent type (C++)
E2414: Destructors cannot be declared as template functions (C++)
E2473: Invalid explicit specialization of 'specifier' (C++)
E2490: Specialization within template classes not yet implemented (C++)
E2416: Invalid template function declaration (C++)
E2417: Cannot specify template parameters in explicit specialization of 'specifier' (C++)
E2418: Maximum instantiation depth exceeded; check for recursion (C++)
E2420: Explicit instantiation can only be used at global scope (C++)
E2422: Argument kind mismatch in redeclaration of template parameter 'parameter' (C++)
E2423: Explicit specialization or instantiation of non-existing template 'template' (C++)
E2479: Cannot have both a template class and function named 'name' (C++)
E2484: The name of template class 'class' cannot be overloaded (C++)
E2426: Explicit specialization of 'specifier' requires 'template<>' declaration (C++)
E2487: Cannot specify default function arguments for explicit specializations (C++)
E2427: 'main' cannot be a template function (C++)
E2429: Not a valid partial specialization of 'specifier' (C++)
E2430: Number of template parameters does not match in redeclaration of 'specifier' (C++)
E2477: Too few template parameters were declared for template 'template' (C++)
E2478: Too many template parameters were declared for template 'template' (C++)
E2431: Non-type template parameters cannot be of floating point, class, or void type (C++)
E2434: Template declaration missing template parameters ('template<...>') (C++)
E2435: Too many template parameter sets were specified (C++)
E2436: Default type for template template argument 'arg' does not name a primary template class (C++)
E2437: 'typename' should be followed by a qualified, dependent type name (C++)
E2438: Template template arguments must name a class (C++)
E2439: 'typename' is only allowed in template declarations (C++)
E2440: Cannot generate specialization from 'specifier' because that type is not yet defined (C++)
E2441: Instantiating 'specifier' (C++)
E2503: Missing or incorrect version of TypeLibImport.dll (C++)
E2470: Need to include header <typeinfo> to use typeid (C++)
E2514: Cannot (yet) use member overload resolution during template instantiation (C++)
E2508: 'using' cannot refer to a template specialization (C++)
E2462: 'virtual' can only be used with non-template member functions (C++)
W8086: Incorrect use of #pragma alias "aliasName"="substituteName" (C++)
W8099: Static main is not treated as an entry point (C++)
W8093: Incorrect use of #pragma codeseg [seg_name] ["seg_class"] [group] (C++)
W8094: Incorrect use of #pragma comment( <type> [,"string"] ) (C++)
W8085: Function 'function' redefined as non-inline (C++)
W8105: %s member '%s' in class without constructors (C++)
W8095: Incorrect use of #pragma message( "string" ) (C++)
W8098: Multi-character character constant (C++)
W8096: Incorrect use of #pragma code_seg(["seg_name"[,"seg_class"]]) (C++)
W8083: Pragma pack pop with no matching pack push (C++)
W8097: Not all options can be restored at this time (C++)
W8084: Suggest parentheses to clarify precedence (C++)
W8092: 'type' argument 'specifier' passed to 'function' is not an iterator: 'type' iterator required (C++)
W8087: 'operator::operator==' must be publicly visible to be contained by a 'type' (C++)
W8090: 'type::operator<' must be publicly visible to be used with 'type' (C++)
W8089: 'type::operator<' must be publicly visible to be contained by a 'type' (C++)
W8091: 'type' argument 'specifier' passed to 'function' is a 'iterator category' iterator: 'iterator category' iterator required (C++)
W8076: Template instance 'specifier' is already instantiated (C++)
W8077: Explicitly specializing an explicitly specialized class member makes no sense (C++)
Informational messages (C++)
E2196: Cannot take address of member function 'function' (C++)
F1002: Unable to create output file 'filename' (C++)
F1003: Error directive: 'message' (C++)
F1004: Internal compiler error (C++)
F1006: Bad call of intrinsic function (C++)
F1007: Irreducible expression tree (C++)
F1009: Unable to open input file 'filename' (C++)
F1011: Register allocation failure (C++)
F1012: Compiler stack overflow (C++)
F1013: Error writing output file (C++)
F1000: Compiler table limit exceeded (C++)
F1005: Include files nested too deep (C++)
F1008: Out of memory (C++)
F1010: Unable to open 'filename' (C++)
E2000: 286/287 instructions not enabled (C++)
Abnormal program termination (C++)
E2009: Attempt to grant or reduce access to 'identifier' (C++)
E2011: Illegal to take address of bit field (C++)
E2010: Cannot add or subtract relocatable symbols (C++)
E2013: 'function1' cannot be distinguished from 'function2' (C++)
E2014: Member is ambiguous: 'member1' and 'member2' (C++)
E2015: Ambiguity between 'function1' and 'function2' (C++)
E2017: Ambiguous member name 'name' (C++)
E2019: 'identifier' cannot be declared in an anonymous union (C++)
E2020: Global anonymous union not static (C++)
E2022: Array size too large (C++)
E2024: Cannot modify a const object (C++)
E2025: Assignment to 'this' not allowed, use X::operator new instead (C++)
E2026: Assembler statement too long (C++)
E2001: Constructors and destructors not allowed in __automated section (C++)
E2002: Only __fastcall functions allowed in __automated section (C++)
E2003: Data member definition not allowed in __automated section (C++)
E2004: Only read or write clause allowed in property declaration in __automated section (C++)
E2005: Redeclaration of property not allowed in __automated section (C++)
E2027: Must take address of a memory location (C++)
E2028: operator -> must return a pointer or a class (C++)
E2029: 'identifier' must be a previously defined class or struct (C++)
E2030: Misplaced break (C++)
E2031: Cannot cast from 'type1' to 'type2' (C++)
E2033: Misplaced continue (C++)
E2034: Cannot convert 'type1' to 'type2' (C++)
E2036: Conversion operator cannot have a return type specification (C++)
E2037: The constructor 'constructor' is not allowed (C++)
E2039: Misplaced decimal point (C++)
E2041: Incorrect use of default (C++)
E2042: Declare operator delete (void*) or (void*, size_t) (C++)
E2044: operator delete must return void (C++)
E2045: Destructor name must match the class name (C++)
E2048: Unknown preprocessor directive: 'identifier' (C++)
E2046: Bad file name format in include directive OR Bad file name format in line directive (C++)
E2051: Invalid use of dot (C++)
E2053: Misplaced elif directive (C++)
E2054: Misplaced else (C++)
E2055: Misplaced else directive (C++)
E2056: Misplaced endif directive (C++)
E2059: Unknown language, must be C or C++ (C++)
E2060: Illegal use of floating point (C++)
E2061: Friends must be functions or classes (C++)
E2062: Invalid indirection (C++)
E2063: Illegal initialization (C++)
E2064: Cannot initialize 'type1' with 'type2' (C++)
E2068: 'identifier' is not a non-static data member and can't be initialized here (C++)
E2069: Illegal use of member pointer (C++)
E2071: operator new must have an initial parameter of type size_t (C++)
E2072: Operator new[] must return an object of type void (C++)
E2075: Incorrect 'type' option: option (C++)
E2076: Overloadable operator expected (C++)
E2080: 'function' must be declared with one parameter (C++)
E2077: 'operator' must be declared with one or no parameters (C++)
E2079: 'function' must be declared with no parameters (C++)
E2078: 'operator' must be declared with one or two parameters (C++)
E2081: 'function' must be declared with two parameters (C++)
E2082: 'identifier' must be a member function or have a parameter of class type (C++)
E2083: Last parameter of 'operator' must have type 'int' (C++)
E2084: Parameter names are used only with a function body (C++)
E2085: Invalid pointer addition (C++)
E2086: Illegal pointer subtraction (C++)
E2087: Illegal use of pointer (C++)
E2088: Bad syntax for pure function definition (C++)
E2089: Identifier 'identifier' cannot have a type qualifier (C++)
E2090: Qualifier 'identifier' is not a class or namespace name (C++)
E2092: Storage class 'storage class' is not allowed here (C++)
E2096: Illegal structure operation (C++)
E2104: Invalid use of template keyword (C++)
E2108: Improper use of typedef 'identifier' (C++)
E2109: Not an allowed type (C++)
E2110: Incompatible type conversion (C++)
E2113: Virtual function 'function1' conflicts with base class 'base' (C++)
E2114: Multiple base classes require explicit class names (C++)
E2115: Bit field too large (C++)
E2116: Bit fields must contain at least one bit (C++)
W8005: Bit fields must be signed or unsigned int (C++)
E2119: User break (C++)
E2111: Type 'typename' may not be defined here (C++)
E2121: Function call missing ) (C++)
E2123: Class 'class' may not contain pure functions (C++)
E2126: Case bypasses initialization of a local variable (C++)
E2127: Case statement missing : (C++)
E2128: Case outside of switch (C++)
E2129: Character constant too long (or empty) (C++)
E2133: Unable to execute command 'command' (C++)
E2134: Compound statement missing closing brace (C++)
E2137: Destructor for 'class' required in conditional expression (C++)
E2135: Constructor/Destructor cannot be declared 'const' or 'volatile' (C++)
E2138: Conflicting type modifiers (C++)
E2136: Constructor cannot have a return type specification (C++)
E2038: Cannot declare or define 'identifier' here: wrong namespace (C++)
E2154: Cannot define 'identifier' using a namespace alias (C++)
E2421: Cannot use local type 'identifier' as template argument (C++)
E2035: Conversions of class to itself or base class not allowed (C++)
E2139: Declaration missing ; (C++)
E2140: Declaration is not allowed here (C++)
E2141: Declaration syntax error (C++)
E2142: Base class 'class' contains dynamically dispatchable functions (C++)
E2143: Matching base class function 'function' has different dispatch number (C++)
E2144: Matching base class function 'function' is not dynamic (C++)
E2145: Functions 'function1' and 'function2' both use the same dispatch number (C++)
E2146: Need an identifier to declare (C++)
E2147: 'identifier' cannot start a parameter declaration (C++)
E2150: Type mismatch in default argument value (C++)
E2152: Default expression may not use local variables (C++)
E2153: Define directive needs an identifier (C++)
E2155: Too many default cases (C++)
E2156: Default outside of switch (C++)
E2158: Operand of 'delete' must be non-const pointer (C++)
E2159: Trying to derive a far class from the huge base 'base' (C++)
E2160: Trying to derive a far class from the near base 'base' (C++)
E2161: Trying to derive a huge class from the far base 'base' (C++)
E2162: Trying to derive a huge class from the near base 'base' (C++)
E2163: Trying to derive a near class from the far base 'base' (C++)
E2164: Trying to derive a near class from the huge base 'base' (C++)
E2165: Destructor cannot have a return type specification (C++)
E2166: Destructor for 'class' is not accessible (C++)
E2167: 'function' was previously declared with the language 'language' (C++)
E2168: Division by zero (C++)
E2169: 'identifier' specifies multiple or duplicate access (C++)
E2170: Base class 'class' is included more than once (C++)
E2171: Body has already been defined for function 'function' (C++)
E2172: Duplicate case (C++)
E2175: Too many storage classes in declaration (C++)
E2176: Too many types in declaration (C++)
E2179: virtual specified more than once (C++)
E2007: Dispid only allowed in __automated sections (C++)
Divide error (C++)
E2182: Illegal parameter to __emit__ (C++)
E2183: File must contain at least one external declaration (C++)
E2184: Enum syntax error (C++)
E2185: The value for 'identifier' is not within the range of 'type-name' (C++)
E2186: Unexpected end of file in comment started on line 'number' (C++)
E2187: Unexpected end of file in conditional started on line 'number' (C++)
E2188: Expression syntax (C++)
E2190: Unexpected closing brace (C++)
E2189: extern variable cannot be initialized (C++)
E2344: Earlier declaration of 'identifier' (C++)
E2192: Too few parameters in call (C++)
E2193: Too few parameters in call to 'function' (C++)
E2194: Could not find file 'filename' (C++)
E2197: File name too long (C++)
E2195: Cannot evaluate function call (C++)
E2198: Not a valid expression format type (C++)
E2200: Functions may not be part of a struct or union (C++)
Floating point error: Divide by 0 OR Floating point error: Domain OR Floating point error: Overflow (C++)
Floating point error: Stack fault (C++)
Floating point error: Partial loss of precision OR Floating point error: Underflow (C++)
E2201: Too much global data defined in file (C++)
E2203: Goto bypasses initialization of a local variable (C++)
E2204: Group overflowed maximum size: 'name' (C++)
E2206: Illegal character 'character' (0x'value') (C++)
E2207: Implicit conversion of 'type1' to 'type2' not allowed (C++)
E2208: Cannot access an inactive scope (C++)
E2209: Unable to open include file 'filename' (C++)
E2210: Reference member 'member' is not initialized (C++)
E2212: Function defined inline after use as extern (C++)
E2211: Inline assembly not allowed in inline and template functions (C++)
F1001: Internal code generator error (C++)
E2413: Invalid template declaration (C++)
E2070: Invalid use of namespace 'identifier' (C++)
E2214: Cannot have a 'non-inline function/static data' in a local class (C++)
E2215: Linkage specification not allowed (C++)
E2216: Unable to create turboc.$ln (C++)
E2218: Templates can only be declared at namespace or class scope (C++)
E2217: Local data exceeds segment size limit (C++)
E2219: Wrong number of arguments in call of macro 'macro' (C++)
E2220: Invalid macro argument separator (C++)
E2221: Macro argument syntax error (C++)
E2222: Macro expansion too long (C++)
E2223: Too many decimal points (C++)
E2224: Too many exponents (C++)
E2225: Too many initializers (C++)
E2226: Extra parameter in call (C++)
E2227: Extra parameter in call to function (C++)
E2228: Too many error or warning messages (C++)
E2233: Cannot initialize a class member here (C++)
E2232: Constant/Reference member 'member' in class without constructors (C++)
E2229: Member 'member' has the same name as its class (C++)
E2234: Memory reference expected (C++)
E2231: Member 'member' cannot be used without an object (C++)
E2235: Member function must be called or its address taken (C++)
O2237: DPMI programs must use the large memory model (C++)
E2238: Multiple declaration for 'identifier' (C++)
E2239: 'identifier' must be a member function (C++)
E2240: Conversion of near pointer not allowed (C++)
E2243: Array allocated using 'new' may not have an initializer (C++)
E2244: 'new' and 'delete' not supported (C++)
E2245: Cannot allocate a reference (C++)
E2309: Inline assembly not allowed (C++)
E2250: No base class to initialize (C++)
E2254: : expected after private/protected/private (C++)
E2255: Use :: to take the address of a member function (C++)
E2256: No : following the ? (C++)
E2257: , expected (C++)
E2258: Declaration was expected (C++)
E2259: Default value missing (C++)
E2260: Default value missing following parameter 'parameter' (C++)
E2263: Exception handling not enabled (C++)
E2264: Expression expected (C++)
E2266: No file names given (C++)
E2265: No file name ending (C++)
E2271: Goto statement missing label (C++)
E2272: Identifier expected (C++)
E2275: Opening brace expected (C++)
E2276: ( expected (C++)
E2274: < expected (C++)
E2277: Lvalue required (C++)
E2278: Multiple base classes not supported for Delphi classes (C++)
E2280: Member identifier expected (C++)
E2279: Cannot find default constructor to initialize member 'identifier' (C++)
E2310: Only member functions may be 'const' or 'volatile' (C++)
E2311: Non-virtual function 'function' declared pure (C++)
E2283: Use . or -> to call 'function' (C++)
E2284: Use . or -> to call 'member', or & to take its address (C++)
E2285: Could not find a match for 'argument(s)' (C++)
E2286: Overloaded function resolution not supported (C++)
E2287: Parameter 'number' missing name (C++)
E2288: Pointer to structure required on left side of -> or ->* (C++)
E2290: 'code' missing ] (C++)
E2291: brace expected (C++)
E2292: Function should return a value (C++)
E2293: ) expected (C++)
E2294: Structure required on left side of . or .* (C++)
E2312: 'constructor' is not an unambiguous base class of 'class' (C++)
E2313: Constant expression required (C++)
E2296: Templates not supported (C++)
E2314: Call of nonfunction (C++)
E2321: Declaration does not specify a tag or an identifier (C++)
E2297: 'this' can only be used within a member function (C++)
E2316: 'identifier' is not a member of 'struct' (C++)
E2317: 'identifier' is not a parameter (C++)
E2319: 'identifier' is not a public base class of 'classtype' (C++)
E2320: Expression of scalar type expected (C++)
E2302: No type information (C++)
E2303: Type name expected (C++)
E2304: 'Constant/Reference' variable 'variable' must be initialized (C++)
E2305: Cannot find 'class::class' ('class'&) to copy a vector OR Cannot find 'class'::operator=('class'&) to copy a vector (C++)
E2306: Virtual base classes not supported for Delphi classes (C++)
E2308: do statement must have while (C++)
E2322: Incorrect number format (C++)
E2324: Numeric constant too large (C++)
E2282: Namespace name expected (C++)
E2334: Namespace member 'identifier' declared outside its namespace (C++)
E2325: Illegal octal digit (C++)
E2329: Invalid combination of opcode and operands (C++)
E2327: Operators may not have default argument values (C++)
E2330: Operator must be declared as function (C++)
E2333: Class member 'member' declared outside its class (C++)
E2335: Overloaded 'function name' ambiguous in this context (C++)
E2339: Cannot overload 'main' (C++)
E2336: Pointer to overloaded function 'function' doesn't match 'type' (C++)
E2337: Only one of a set of overloaded functions can be "C" (C++)
E2338: Overlays only supported in medium, large, and huge memory models (C++)
E2340: Type mismatch in parameter 'number' (C++)
E2341: Type mismatch in parameter 'number' in call to 'function' (C++)
E2342: Type mismatch in parameter 'parameter' (C++)
E2343: Type mismatch in parameter 'parameter' in call to 'function' (C++)
E2345: Access can only be changed to public or protected (C++)
E2349: Nonportable pointer conversion (C++)
E2350: Cannot define a pointer or reference to a reference (C++)
E2352: Cannot create instance of abstract class 'class' (C++)
E2354: Two operands must evaluate to the same type (C++)
E2355: Recursive template function: 'x' instantiated 'y' (C++)
E2356: Type mismatch in redeclaration of 'identifier' (C++)
E2357: Reference initialized with 'type1', needs lvalue of type 'type2' (C++)
E2358: Reference member 'member' needs a temporary for initialization (C++)
E2360: Invalid register combination (e.g. [BP+BX]) (C++)
E2361: 'specifier' has already been included (C++)
E2362: Repeat count needs an lvalue (C++)
E2363: Attempting to return a reference to local variable 'identifier' (C++)
E2364: Attempting to return a reference to a local object (C++)
E2365: Member pointer required on right side of .* or ->* (C++)
E2366: Can't inherit non-RTTI class from RTTI base OR E2367 Can't inherit RTTI class from non-RTTI base (C++)
E2368: RTTI not available for expression evaluation (C++)
E2371: sizeof may not be applied to a bit field (C++)
E2372: sizeof may not be applied to a function (C++)
E2373: Bit field cannot be static (C++)
E2374: Function 'function' cannot be static (C++)
Stack overflow (C++)
E2376: statement missing (C++)
E2377: statement missing ) (C++)
E2378: do-while or for statement missing ; (C++)
E2379: Statement missing ; (C++)
E2380: Unterminated string or character constant (C++)
E2381: Structure size too large (C++)
E2382: Side effects are not allowed (C++)
E2383: Switch selection expression must be of integral type (C++)
E2433: Specialization after first use of template (C++)
E2384: Cannot call near class member function with a pointer of type 'type' (C++)
E2390: Type mismatch in parameter 'number' in template class name 'template' (C++)
E2391: Type mismatch in parameter 'parameter' in template class name 'template' (C++)
E2394: Too few arguments passed to template 'template' (C++)
E2395: Too many arguments passed to template 'template' (C++)
E2396: Template argument must be a constant expression (C++)
E2401: Invalid template argument list (C++)
E2400: Nontype template argument must be of scalar type (C++)
E2415: Template functions may only have 'type-arguments' (C++)
E2425: 'member' is not a valid template type member (C++)
E2428: Templates must be classes or functions (C++)
E2432: 'template' qualifier must name a template class or function instance' (C++)
E2442: Two consecutive dots (C++)
E2443: Base class 'class' is initialized more than once (C++)
E2444: Member 'member' is initialized more than once (C++)
E2445: Variable 'identifier' is initialized more than once (C++)
E2446: Function definition cannot be a typedef'ed declaration (C++)
E2132: Templates and overloaded operators cannot have C linkage (C++)
E2447: 'identifier' must be a previously defined enumeration tag (C++)
E2448: Undefined label 'identifier' (C++)
E2449: Size of 'identifier' is unknown or zero (C++)
E2450: Undefined structure 'structure' (C++)
E2451: Undefined symbol 'identifier' (C++)
E2453: Size of the type 'identifier' is unknown or zero (C++)
E2452: Size of the type is unknown or zero (C++)
E2454: union cannot be a base type (C++)
E2455: union cannot have a base type (C++)
E2456: Union member 'member' is of type class with 'constructor' (or destructor, or operator =) (C++)
E2461: '%s' requires run-time initialization/finalization (C++)
E2464: 'virtual' can only be used with member functions (C++)
E2465: unions cannot have virtual member functions (C++)
E2466: void & is not a valid type (C++)
E2467: 'Void function' cannot return a value (C++)
E2468: Value of type void is not allowed (C++)
E2469: Cannot use tiny or huge memory model with Windows (C++)
E2006: CodeGuarded programs must use the large memory model and be targeted for Windows (C++)
E2269: The function 'function' is not available (C++)
E2124: Invalid function call (C++)
E2213: Invalid 'expression' in scope override (C++)
E2236: Missing 'identifier' in scope override (C++)
Pure virtual function called (C++)
E2095: String literal not allowed in this context (C++)
Unexpected termination during compilation [Module Seg#:offset] OR Unexpected termination during linking [Module Seg#:offset] (C++)
E2012: Cannot take address of 'main' (C++)
E2016: Ambiguous override of virtual base member 'base_function': 'derived_function' (C++)
E2021: Array must have at least one element (C++)
E2023: Array of references is not allowed (C++)
E2032: Illegal use of closure pointer (C++)
E2040: Declaration terminated incorrectly (C++)
E2047: Bad 'directive' directive syntax (C++)
E2049: Class type 'type' cannot be marked as __declspec(delphireturn) (C++)
E2052: Dynamic function 'function' conflicts with base class 'class' (C++)
E2057: Exception specification not allowed here (C++)
E2058: Exception handling variable may not be used here (C++)
E2065: Using namespace symbol 'symbol' conflicts with intrinsic of the same name (C++)
E2067: 'main' must have a return type of int (C++)
E2073: Nothing allowed after pragma option pop (C++)
E2091: Functions cannot return arrays or functions (C++)
E2093: Operator 'operator' not implemented in type 'type' for arguments of the same type (C++)
E2094: Operator 'operator' not implemented in type 'type' for arguments of type 'type' (C++)
E2097: Explicit instantiation only allowed at file or namespace scope (C++)
E2098: Explicit specialization declarator "template<>" now required (C++)
E2099: Explicit specialization only allowed at file or namespace scope (C++)
E2101: 'export' keyword must precede a template declaration (C++)
E2103: Explicit instantiation must be used with a template class or function (C++)
E2106: Explicit specialization must be used with a template class or function (C++)
E2112: Unknown unit directive: 'directive' (C++)
E2118: Bit fields must have integral type (C++)
E2120: Cannot call 'main' from within the program (C++)
E2125: Compiler could not generate copy constructor for class 'class' OR Compiler could not generate default constructor for class 'class' OR Compiler could not generate operator = for class 'class' (C++)
E2130: Circular property definition (C++)
E2131: Objects of type 'type' cannot be initialized with { } (C++)
E2148: Default argument value redeclared for parameter 'parameter' (C++)
E2149: Default argument value redeclared (C++)
E2151: Type mismatch in default value for parameter 'parameter' (C++)
E2157: Deleting an object requires exactly one conversion to pointer operator (C++)
E2173: Duplicate handler for 'type1', already had 'type2' (C++)
E2174: The name handler must be last (C++)
E2177: Redeclaration of #pragma package with different arguments (C++)
E2178: VIRDEF name conflict for 'function' (C++)
E2180: Dispid number already used by identifier (C++)
E2181: Cannot override a 'dynamic/virtual' with a 'dynamic/virtual' function (C++)
E2202: Goto into an exception handler is not allowed (C++)
E2205: Illegal type type in __automated section (C++)
E2242: Specifier requires Delphi style class type (C++)
E2247: 'member' is not accessible (C++)
E2248: Cannot find default constructor to initialize array element of type 'class' (C++)
E2251: Cannot find default constructor to initialize base class 'class' (C++)
E2252: 'catch' expected (C++)
E2253: Calling convention must be attributed to the function type, not the closure (C++)
E2261: Use of dispid with a property requires a getter or setter (C++)
E2262: '__except' or '__finally' expected following '__try' (C++)
E2270: > expected (C++)
E2273: 'main' cannot be declared as static or inline (C++)
E2281: Identifier1 requires definition of Identifier2 as a pointer type (C++)
E2289: __published or __automated sections only supported for Delphi classes (C++)
E2298: Cannot generate 'function' from template function 'template' (C++)
E2301: Cannot use templates in closure arguments -- use a typedef (C++)
E2307: Type 'type' is not a defined class with virtual functions (C++)
E2315: 'Member' is not a member of 'class', because the type is not yet defined (C++)
E2318: 'type' is not a polymorphic class type (C++)
E2323: Illegal number suffix (C++)
E2326: Use __declspec(spec1[, spec2]) to combine multiple __declspecs (C++)
E2328: Classes with properties cannot be copied by value (C++)
E2331: Number of allowable option contexts exceeded (C++)
E2332: Variable 'variable' has been optimized and is not available (C++)
E2476: Cannot overload 'function' (C++)
E2346: 'x' access specifier of property 'property' must be a member function (C++)
E2347: Parameter mismatch in access specifier 'specifier' of property 'property' (C++)
E2348: Storage specifier not allowed for array properties (C++)
E2351: Static data members not allowed in __published or __automated sections (C++)
E2353: Class 'classname' is abstract because of 'member = 0' (C++)
E2359: Reference member 'member' initialized with a non-reference parameter (C++)
E2369: Cannot use the result of a property assignment as an rvalue' (C++)
E2370: Simple type name expected (C++)
E2398: Template function argument 'argument' not used in argument types (C++)
E2419: Error while instantiating template 'template' (C++)
E2424: Template class nesting too deep: 'class' (C++)
E2457: Delphi style classes must be caught by reference (C++)
E2458: Delphi classes have to be derived from Delphi classes (C++)
E2459: Delphi style classes must be constructed using operator new (C++)
E2460: Delphi style classes require exception handling to be enabled (C++)
E2463: 'base' is an indirect virtual base class of 'class' (C++)
Null pointer assignment (C++)
E2268: Call to undefined function 'function' (C++)
E2375: Assembler stack overflow (C++)
Initializing enumeration with type (C++)
<name> is not a valid identifier (C++)
Example for "Temporary used ..." error messages (C++)
Application is running (C++)
Printf/Scanf floating-point formats not linked (C++)
W8000: Ambiguous operators need parentheses (C++)
W8060: Possibly incorrect assignment (C++)
W8002: Restarting compile using assembly (C++)
W8003: Unknown assembler instruction (C++)
W8052: Base initialization without a class name is now obsolete (C++)
E2117: Bit fields must be signed or unsigned int (C++)
W8064: Call to function with no prototype (C++)
W8065: Call to function 'function' with no prototype (C++)
W8009: Constant is long (C++)
W8008: Condition is always true OR W8008 Condition is always false (C++)
W8012: Comparing signed and unsigned values (C++)
W8010: Continuation character \ found in // comment (C++)
W8080: 'identifier' is declared but never used (C++)
W8014: Declaration ignored (C++)
W8068: Constant out of range in comparison (C++)
W8016: Array size for 'delete' ignored (C++)
W8082: Division by zero (C++)
W8018: Assigning 'type' to 'enumeration' (C++)
W8006: Initializing 'identifier' with 'identifier' (C++)
W8001: Superfluous & with function (C++)
W8020: 'identifier' is declared as both external and static (C++)
W8007: Hexadecimal value contains more than three digits (C++)
W8024: Base class 'class1' is also a base class of 'class2' (C++)
W8022: 'function1' hides virtual function 'function2' (C++)
W8023: Array variable 'identifier' is near (C++)
W8061: Initialization is only partially bracketed (C++)
W8038: constant member 'identifier' is not initialized (C++)
W8071: Conversion may lose significant digits (C++)
W8043: Macro definition ignored (C++)
W8017: Redefinition of 'x' is not identical (C++)
W8079: Mixing pointers to different 'char' types (C++)
W8067: Both return and return with a value used (C++)
W8048: Use qualified name to access member type 'identifier' (C++)
W8039: Constructor initializer list ignored (C++)
W8040: Function body ignored (C++)
W8042: Initializer for object 'x' ignored (C++)
W8044: #undef directive ignored (C++)
W8037: Non-const function 'function' called for const object (C++)
W8051: Non-volatile function 'function' called for volatile object (C++)
W8019: Code has no effect (C++)
W8057: Parameter 'parameter' is never used (C++)
W8070: Function should return a value (C++)
W8047: Declaration of static function function ignored (C++)
W8041: Negating unsigned value (C++)
W8054: Style of function definition is now obsolete (C++)
W8025: Ill-formed pragma (C++)
W8063: Overloaded prefix operator 'operator' used as a postfix operator (C++)
W8015: Declare 'type' prior to use in prototype (C++)
W8069: Nonportable pointer conversion (C++)
W8066: Unreachable code (C++)
W8029: Temporary used for parameter '???' (C++)
W8031: Temporary used for parameter 'parameter' OR W8029 Temporary used for parameter 'number' OR W8030 Temporary used for parameter 'parameter' in call to 'function' OR W8032 Temporary used for parameter 'number' in call to 'function' (C++)
W8032: Temporary used for parameter 2 in call to '???' (C++)
W8028: Temporary used to initialize 'identifier' (C++)
W8074: Structure passed by value (C++)
W8011: Nonportable pointer comparison (C++)
W8075: Suspicious pointer conversion (C++)
W8059: Structure packing size has changed (C++)
W8045: No declaration for function 'function' (C++)
W8073: Undefined structure 'structure' (C++)
W8013: Possible use of 'identifier' before definition (C++)
W8004: 'identifier' is assigned a value that is never used (C++)
W8081: Void functions may not return a value (C++)
W8078: Throw expression violates exception specification (C++)
W8021: Handler for 'type1' hidden by previous handler for 'type2' (C++)
W8056: Integer arithmetic overflow (C++)
W8035: User-defined message (C++)
W8049: Use '> >' for nested templates Instead of '>>' (C++)
W8026: Functions with exception specifications are not expanded inline (C++)
W8058: Cannot create pre-compiled header: 'reason' (C++)
W8046: Pragma option pop with no matching option push (C++)
W8050: No type OBJ file present; disabling external types option. (C++)
W8027: Functions containing 'statement' are not expanded inline (C++)
W8036: Non-ANSI keyword used: 'keyword' (C++)
W8053: 'ident' is obsolete (C++)
W8103: Path 'path' and filename 'filename' exceed maximum size of 'n' (C++)
W8062: Previous options and warnings not restored (C++)
W8055: Possible overflow in shift operation (C++)
W8072: Suspicious pointer arithmetic (C++)
W8033: Conversion to 'type' will fail for members of virtual base 'class' (C++)
W8034: Maximum precision used for member pointer type 'type' (C++)
E2537: Cannot create instance of abstract class (C++)
E2018: Cannot catch 'identifier' -- ambiguous base class 'identifier' (C++)
E2550: No arguments can follow a variadic template in an argument list (C++)
E2538: Static assert failed: '%s' (C++)
E2548: ... was unexpected; expression is not a variadic template pattern (C++)
E2543: Combination of options 'options' is not permitted (C++)
E2549: Operand is not a parameter pack (C++)
E2544: Function exception specifications do not match (C++)
E2536: Incomplete type cannot be part of a exception declaration (C++)
E2535: Incomplete type cannot be part of a throw specification (C++)
E2532: Constant in new expression requires an initializer (C++)
E2541: Attribute '%s' cannot be set (C++)
E2545: Enum underlying type must be an integral (C++)
E2546: Redeclaration of enum is not identical (C++)
E2533: Parameter mismatch (wanted typename) (C++)
E2534: Integral constant expression expected (C++)
E2531: Parameter is an incomplete type (C++)
E2539: Constant expression expected (C++)
E2547: ... expected (C++)
E2540: String literal expected (C++)
E2552: This feature is not (yet) supported (C++)
E2542: '%s' is marked 'final' and cannot be overriden (C++)
E2553: %s mismatch in redeclaration of '%s' (C++)
E2551: Return statement not allowed in __finally block (C++)
W8104: Local Static with constructor dangerous for multi-threaded apps (C++)
W8106: %s are deprecated (C++)
W8110: Duplicate '%s' attribute directive ignored (C++)
W8108: Constant in new expression requires an initializer (C++)
W8113: Inline function was declared with 'extern template' (C++)
W8109: Parameter '%s' is a dependent type (C++)
W8105: Reference/Constant member 'identifier' in class without constructors (C++)
W8107: Type name expected (C++)
W8112: Unresolved dependencies in expression (C++)
C++ Language Guide
C++ Specifics
Classes
C++ Classes
Friends Of Classes
Friends Of Classes
Class Member List
Inline Functions
Inline Functions
Class Name Scope
The Keyword This
Static Members
Class Names
Member Scope
Base And Derived Class Access
Member Access Control
Member Scope
Nested Types
Class Objects
Virtual Base Classes
Virtual Base Classes
Class Types
Member Functions
VCL Class Declarations
Class Methods
Static Properties
Class Templates Overview
Using Angle Brackets In Templates
Template Arguments
Class Templates
Eliminating Pointers In Templates
Using Type-safe Generic Lists In Templates
Compiler Template Switches
Template Compiler Switches
Template Generation Semantics
Constructors And Destructors
Introduction To Constructors And Destructors
Constructors
Class Initialization
Constructor Defaults
Constructors
Order Of Calling Constructors
Overloading Constructors
The Copy Constructor
Destructors
Destructors
Exit And Destructors
Invoking Destructors
Virtual Destructors
abort And Destructors
atexit, #pragma exit, And Destructors
C++ namespaces
Declaring A namespace
Accessing Elements Of A namespace
Anonymous namespaces
Defining A namespace
Explicit Access Qualification
Extending A namespace
namespace Alias
using Directive
C++ Scope
C++ Scope
C++ Scoping Rules Summary
Class Scope
Hiding
Exporting And Importing Templates
Exporting And Importing Templates
Function Templates Overview
Function Templates
Implicit And Explicit Template Functions
Overriding A Template Function
The new And delete Operators
Handling Errors For The New Operator
Operator new Placement Syntax
Overloading The Operator delete
Overloading The Operator new
The delete Operator With Arrays
Operator new
The Operator new With Arrays
New-style Typecasting Overview
New-style Typecasting
Operator Overloading Overview
How To Construct A Class Of Complex Vectors
Example Of Overloading Operators
Overloading Operators
Overloading Operator Functions Overview
Overloading The Assignment operator =
Overloading Binary Operators
Overloading The Class Member Access Operators ->
Overloading The Function Call Operator ( )
Overloading Operator Functions
Overloaded Operators And Inheritance
Overloading The Subscript Operator []
Overloading Unary Operators
Polymorphic Classes
Abstract Classes
Abstract Classes
Polymorphic Classes
Virtual Functions
Dynamic Functions
Virtual Functions
Referencing
Reference Arguments
Referencing
Simple References
Run-time Type Identification (RTTI)
Runtime Type Identification (RTTI) Overview
The Typeid Operator
Runtime Type Identification And Destructors
The Scope Resolution Operator
Scope Resolution Operator ::
Stricter C++ Compiler (C++Builder 2007)
Stricter C++ Compiler: Binding of References and Qualifiers
Stricter C++ Compiler: String Literals Are Now Constants
Stricter C++ Compiler: Template Changes
Stricter C++ Compiler: Function Overload Resolution
Stricter C++ Compiler: Initialization and Conversion
Templates
Template Body Parsing
Using Templates
C++0x Features (C++Builder 2009)
alignof Operator (C++0x)
Type Trait Functions (C++0x)
Type Trait Functions Overview (C++0x)
__alignment_of
__array_extent
__array_rank
__has_nothrow_assign
__has_nothrow_copy_constructor
__has_nothrow_default_constructor
__has_trivial_assign
__has_trivial_copy_constructor
__has_trivial_default_constructor
__has_trivial_destructor
__has_virtual_destructor
__is_abstract
__is_arithmetic
__is_array
__is_base_of
__is_class
__is_complete_type (typename T )
__is_compound
__is_const
__is_convertible
__is_empty
__is_enum
__is_floating_point
__is_function
__is_fundamental
__is_integral
__is_lvalue_expr
__is_lvalue_reference
__is_member_function_pointer
__is_member_object_pointer
__is_member_pointer
__is_object
__is_pod
__is_pointer
__is_polymorphic
__is_reference
__is_rvalue_expr
__is_rvalue_reference
__is_same
__is_scalar
__is_signed
__is_standard_layout
__is_trivial
__is_union
__is_unsigned ( typename T )
__is_void
__is_volatile
Attributes noreturn and final (C++0x)
Explicit Conversion Operators (C++0x)
extern Templates (C++0x)
Forward Declaration of Enums (C++0x)
rvalue References (C++0x)
Static Assertions (C++0x)
Strongly Typed Enums (C++0x)
Type Specifier decltype (C++0x)
Unicode Character Types and Literals (C++0x)
Unicode for C++
TCHAR Mapping
Floating Functions
Enabling C++ Applications for Unicode
Handling Delphi Features in C++Builder 2009
How to Handle Delphi Anonymous Methods in C++
How to Handle Delphi AnsiString Code Page Specification in C++
How to Handle Delphi Generics in C++
Keywords, Alphabetical Listing
__automated
__classid
__closure
__declspec
__dispid
__except
__inline
__int8, __int16, __int32, __int64, Unsigned __int64, Extended Integer Types
__msfastcall
__msreturn
__property
__published
__rtti, -RT Option
__thread, Multithread Variables
__try
_export, __export
_fastcall, __fastcall
_stdcall, __stdcall
alignof
and, &&
asm, _asm, __asm
auto
bitand, &
bitor, |
bool, false, true
break
case
catch
cdecl, _cdecl, __cdecl
char
char16_t
char32_t
class
compl, ~
const
const_cast (typecast Operator)
continue
__declspec(dllexport)
__declspec(dllimport)
__declspec(naked)
__declspec(noreturn)
__declspec(nothrow)
__declspec(novtable)
__declspec(property)
__declspec(selectany)
__declspec(thread)
__declspec(uuid(“ComObjectGUID”))
decltype
default
delete
do
double
dynamic_cast (typecast Operator)
enum
explicit
export
extern
final
__finally
float
for
friend
goto
if, else
import, _import, __import
inline
int
long
mutable
namespace
new
noreturn
not, !
not_eq, !=
nullptr
operator
or, ||
or_eq, |=
pascal, _pascal, __pascal
private
protected
public
register
reinterpret_cast (typecast Operator)
return
short
signed
sizeof
static
static_assert
static_cast (typecast Operator)
struct
switch
template
this
throw
try
typedef
typeid
typename
union
unsigned
using (declaration)
virtual
void
volatile
wchar_t
while
xor, ^
__classmethod
alignas
and_eq, &=
axiom
concept
concept_map
constexpr
late_check
requires
thread_local
xor_eq, ^=
_Bool
_Complex
_Imaginary
restrict
Keywords, By Category
Alternative Representations of Tokens
Attributes
C++Builder Keyword Extensions
C++ Specific Keywords
Modifiers
Operators
Reserved Words
Special Types
Statement Keywords
Storage Class Specifiers
Type Specifiers (C++)
Language Structure
Binary Operators
Binary Operators
Bitwise Operators
C++ Specific Operators
Equality Operators
Logical Operators
>, <, >=, <= Relational Operators
Assignment Operators
Comma Operator
Conditional Operators
Multiplicative Operators
Declarations
Duration
Linkage
Objects
Scope
Storage Classes And Types
Translation Units
Visibility
Declaration Syntax
Tentative Definitions
Possible Declarations
External Declarations and Definitions
Type Specifiers
Type Categories
The Fundamental Types
Initialization
Declaration and Declarators
Use of Storage Class Specifiers
Variable Modifiers
Mixed-Language Calling Conventions
Multithread Variables
Function Modifiers
Enumerations
Enumerations
Assignment To Enum Types
Expressions
Expressions (C++)
Precedence Of Operators
Expressions And C++
Evaluation Order
Errors And Overflows
Functions
Declarations And Definitions
The main() Function
About The main() Function
Arguments to main()
Default Runtime Libraries
Dynamic-link Libraries
Multithread Programs
Passing File Information To Child Processes
Static Runtime Libraries
The Value main() Returns
Using --p (Pascal Calling Conventions)
Wildcard Arguments
Declarations And Prototypes
Definitions
Extended Types Formatted I/O
Formal Parameter Declarations
Function Calls And Argument Conversions
Operators Summary
Operators Summary
Pointers
Arrays
C++ Reference Declarations
Pointer Arithmetic
Pointer Constants
Pointer Conversions
Pointer Declarations
Pointers
Pointers To Functions
Pointers To Objects
Postfix Expression Operators
. (direct Member Selector)
-> (indirect Member Selector)
Array Subscript Operator
Increment/decrement Operators
Function Call Operator
Primary Expression Operators
Primary Expression Operators
Statements
Blocks
C++ Specifics
Expression Statements
Iteration Statements
Jump Statements
Labeled Statements
Selection Statements
Statements
Structures
Structures
Untagged Structures And Typedefs
Structure Member Declarations
Structures And Functions
Structure Member Access
Structure Name Spaces
Incomplete Declarations
Bit Fields
Unary Operators
Unary Operators
Arithmetic Operators
Plus And Minus Operators
Reference/Deference Operators
Unions
Unions
Anonymous Unions
Union Declarations
Lexical Elements
Lexical Elements
Tokens Overview
Constants Overview
Character Constants Overview
Character Constants
Escape Sequences
The Three Char Types
Wide-character And Multi-character Constants
Constants
Integer Constant Without L Or U
Constant Expressions
Constant Expressions
Constants and Internal Representation
Constants And Internal Representation
Floating Point Constants
Enumeration Constants
Enumeration Constants
Integer Constants
Internal Representation of Numerical Types
Internal Representation Of Numerical Types
String Constants
String Constants
Tokens
Identifiers Overview
Identifiers
Keywords Overview
Keywords
Keyword Extensions
C++-Specific Keywords
Table Of CodeGear C++ Register Pseudovariables
Punctuators Overview
Punctuators
Whitespace Overview
Comments
Whitespace
The Preprocessor
Conditional Compilation Overview
Conditional Compilation
#if, #elif, #else, And #endif
#ifdef And #ifndef
Defined
Defining And Undefining Macros
Using The -D And -U Command-line Options
Keywords And Protected Words In Macros
#define
#undef
The #error Control Directive
#error
File Inclusion With #include
#include
Header File Search With <header_name>
Header File Search With "header_name"
The #line Control Directive
#line
Macros With Parameters Overview
Macros With Parameters
Nesting Parentheses And Commas
Token Pasting With ##
Converting To Strings With #
Using The Backslash (\) For Line Continuation
Side Effects And Other Dangers
Pragma Directives Overview
#pragma
#pragma alignment
#pragma anon_struct
#pragma argsused
#pragma checkoption
#pragma codeseg
#pragma comment
#pragma defineonoption and #pragma undefineonoption
#pragma exit and #pragma startup
#pragma hdrfile
#pragma hdrstop
#pragma inline
#pragma intrinsic
#pragma link
#pragma message
#pragma nopushoptwarn
#pragma obsolete
#pragma option
#pragma pack
#pragma package
#pragma region and #pragma end_region
#pragma resource
#pragma warn
Predefined Macros Overview
Predefined Macros
Preprocessor Directives
Preprocessor Directives
# (null Directive)
C Runtime Library Reference
alloc.h
_heapchk
_heapmin
_heapset
_msize
_rtl_heapwalk
calloc
free
heapcheck
heapcheckfree
heapchecknode
heapfillfree
heapwalk
malloc
realloc
stackavail
assert.h
NDEBUG #define
assert
conio.h
_setcursortype
cgets
clreol
clrscr
cprintf
cputs
cscanf
delline
getch
getche
getpass
gettext
gettextinfo
gotoxy
highvideo
insline
kbhit
lowvideo
movetext
normvideo
putch
puttext
textattr
textbackground
textcolor
textmode
ungetch
wherex
wherey
window
ctype.h
_ctype
_IS_xxx #defines
_tolower
_toupper
isalnum, __iscsym, iswalnum, _ismbcalnum
isalpha, __iscsymf, iswalpha, _ismbcalpha
isascii, iswascii
iscntrl, iswcntrl
isdigit, iswdigit, _ismbcdigit
isgraph, iswgraph, _ismbcgraph
islower, iswlower, _ismbclower
isprint, iswprint, _ismbcprint
ispunct, iswpunct, _ismbcpunct
isspace, iswspace, _ismbcspace
isupper, iswupper, _ismbcupper
isxdigit, iswxdigit
toascii
tolower, _mbctolower, towlower
toupper, _mbctoupper, towupper
delayimp.h
__pfnDliNotifyHook, __pfnDliFailureHook
__FUnloadDelayLoadedDLL
direct.h
_chdrive
_getdcwd, _wgetdcwd
dirent.h
closedir, wclosedir
opendir, wopendir
readdir, wreaddir
rewinddir, wrewinddir
dir.h
chdir
MAXxxxx #defines (fnsplit)
findclose, _wfindclose
findfirst, _wfindfirst
findnext, _wfindnext
fnmerge, _wfnmerge
fnsplit, _wfnsplit
Bit Definitions for fnsplit
getcurdir, _wgetcurdir
getcwd, _wgetcwd
getdisk, setdisk
mkdir, _wmkdir
_mktemp, _wmktemp
_rmdir, _wrmdir
searchpath, wsearchpath
dos.h
FA_xxxx #defines
NFDS #define
_getdrive
_osmajor
_osminor
_osversion
_sleep
_version
disable, _disable, enable, _enable
dostounix
geninterrupt
getdate, setdate
getdfree
gettime, settime
unixtodos
_unlink, _wunlink
errno.h
EDOM, ERANGE, #defines
_doserrno
errno (C Runtime Library Reference)
Error Numbers in errno
perror,_wperror
_sys_errlist
_sys_nerr
except.h
__throwExceptionName
__throwFileName
__throwLineNumber
set_terminate
set_unexpected
terminate
unexpected
fastmath.h
Using fastmath math routines
fcntl.h
O_xxxx #defines
_fmode
_pipe
open, _wopen
_sopen, _wsopen
float.h
CW_DEFAULT #define
_chgsign, _chgsignl
_clear87, _clearfp
_control87, _controlfp
_copysign, _copysignl
_finite, _finitel
_fpclass, _fpclassl
_fpreset
_isnan, _isnanl
_logb, _logbl
_nextafter, _nextafterl
_scalb, _scalbl
_status87, _statusfp
io.h
_findclose
_findfirst, __wfindfirst
_findfirsti64, _wfindfirsti64
_findnext, __wfindnext
_findnexti64, _wfindnexti64
_get_osfhandle
_open_osfhandle
_rtl_chmod, _wrtl_chmod
_rtl_close
_rtl_creat, _wrtl_creat
_rtl_open, _wrtl_open
_rtl_read
_rtl_write
access, _waccess
chmod, _wchmod
chsize
close
_creat, _wcreat
creatnew
creattemp
dup
dup2
eof
filelength
getftime, setftime
isatty
lock
locking
lseek
read
setmode
tell
umask
unlock
vsscanf
write
limits.h
CHAR_xxx #defines
INT_xxx #defines
LONG_xxx #defines
SCHAR_xxx #defines
SHRT_xxx #defines
Uxxxx_MAX #defines
locale.h
localeconv
setlocale, _wsetlocale
malloc.h
alloca
math.h
HUGE_VAL #defines
M_E, M_LOGxxx, M_LNxx #defines
M_SQRTxx #defines
PI constants
atof, _wtof
_atold, _wtold
_i64toa, _i64tow
_matherr, _matherrl
abs
acos, acosl
asin, asinl
atan, atanl
atan2, atan2l
cabs, cabsl
ceil, ceill
cos, cosl
cosh, coshl
exp, expl
fabs, fabsl
floor, floorl
fmod, fmodl
frexp, frexpl
hypot, hypotl
ldexp, ldexpl
ldiv
log, logl
log10, log10l
modf, modfl
poly, polyl
pow, powl
pow10, pow10l
sin, sinl
sinh, sinhl
sqrt, sqrtl
tan, tanl
tanh, tanhl
mem.h
memccpy
memchr, _wmemchr
memcmp
memcpy, _wmemcpy
memicmp
memmove
memset, _wmemset
setmem
new.h
_new_handler
set_new_handler function
process.h
P_xxxx #defines
_adopt_thread
_beginthread
_beginthreadNT
_beginthreadex
_c_exit
_cexit
_endthread
_endthreadex
_expand
_unadopt_thread
cwait
execl, execle, execlp, execlpe, execv, execve, execvp, execvpe, _wexecl, _wexecle, _wexeclp, _wexeclpe, _wexecv, _wexecve, _wexecvp, _wexecvpe
getpid
spawnl, spawnle, spawnlp, spawnlpe, spawnv, spawnve, spawnvp, spawnvpe, _wspawnl, _wspawnle, _wspawnlp, _wspawnlpe, _wspawnv, _wspawnve, _wspawnvp, _wspawnvpe
wait
setjmp.h
longjmp
setjmp
share.h
SH_xxxx #defines
signal.h
SIGxxxx #defines
SIG_xxx #defines
raise
signal (C RTL)
stdarg.h
va_arg, va_end, va_start
stddef.h
NULL #define
_threadid
offsetof
stdio.h
BUFSIZ #define
_F_xxxx #defines
OPEN_MAX #define
L_ctermid #define
L_tmpnam #define
TMP_MAX #define
_IOxxx #defines
_fsopen, _wfsopen
_pclose
_popen, _wpopen
_snprintf;_snwprintf
_vsnprintf;_vsnwprintf
clearerr
EOF #define
fclose
_fcloseall
_fdopen, _wfdopen
feof
ferror
fflush
fgetc, fgetwc
_fgetchar, _fgetwchar
fgetpos
fgets, fgetws
_fileno
_flushall
fopen, _wfopen
fprintf, fwprintf
fputc, fputwc
_fputchar, _fputwchar
fputs, fputws
fread
freopen, _wfreopen
fscanf, fwscanf
fseek
fsetpos
ftell
fwrite
getc, getwc
getchar, getwchar
gets, _getws
_getw
printf, wprintf
putc, putwc
putchar, putwchar
puts, _putws
_putw
remove, _wremove
rename, _wrename
rewind
_rmtmp
scanf, wscanf
setbuf
setvbuf
snprintf;snwprintf
sprintf, swprintf
sscanf, swscanf
stderr, stdin, stdout
_tempnam, _wtempnam
tmpfile
tmpnam, _wtmpnam
ungetc, ungetwc
vfprintf, vfwprintf
vfscanf
vprintf, vwprintf
vscanf
vsnprintf;vsnwprintf
vsprintf, vswprintf
stdlib.h
EXIT_xxxx #defines
RAND_MAX #define
_argc
_argv, _wargv
_atoi64, _wtoi64
_crotl, _crotr
_exit
_fullpath, _wfullpath
_lrand
_lrotl, _lrotr
_makepath, _wmakepath
_rotl, _rotr
_searchenv, _wsearchenv
_searchstr, _wsearchstr
_splitpath, _wsplitpath
_ui64toa, _ui64tow
abort
atexit
atoi, _wtoi
atol, _wtol
bsearch
div
ecvt
_environ, _wenviron
exit
fcvt
gcvt
getenv, _wgetenv
itoa, _itow
labs
lfind
lsearch
ltoa, _ltoa, _ltow
max
mblen
mbstowcs
mbtowc
min
putenv, _wputenv
qsort
rand
random
randomize
srand
strlen, _mbslen, wcslen, _mbstrlen
strtod, _strtold, wcstod, _wcstold
strtol, wcstol
strtoul, wcstoul
swab
system, _wsystem
ultoa, _ultow
wcstombs
wctomb
string.h
_ismbblead, _ismbbtrail
_ismbclegal
_ismbslead, _ismbstrail
_mbbtype
_mbccpy
_mbsbtype
_mbsnbcmp
_mbsnbcnt, _mbsnccnt, _strncnt, _wcsncnt
_mbsnbcoll, _mbsnbicoll
_mbsnbcpy
_mbsnbicmp
_mbsnbset
_mbsninc, _strninc, _wcsninc
_mbsspnp, _strspnp, _wcsspnp
_strdec, mbsdec, _wcsdec
_strerror
_strinc, mbsinc, _wcsinc
_strnextc,_mbsnextc,_wcsnextc
stpcpy, _wstpcpy, _stpcpy
strcat, _mbscat, wcscat
strchr, _mbschr, wcschr
strcmp, _mbscmp, wcscmp
strcmpi
strcoll,_stricoll, _mbscoll, _mbsicoll, wcscoll, _wcsicoll
strcpy
strcspn, _mbscspn, wcscspn
strdup, _mbsdup, _wcsdup
strerror
stricmp, _mbsicmp, _wcsicmp
strlwr, _mbslwr, _wcslwr
strncat
strncmp, _mbsncmp, wcsncmp
strncmpi, wcsncmpi
strncoll, strnicoll, _mbsncoll, _mbsnicoll, _wcsncoll, _wcsnicoll
strncpy, _mbsncpy, wcsncpy
strnicmp, _mbsnicmp, _wcsnicmp
strnset, _mbsnset, _wcsnset
strpbrk, _mbspbrk, wcspbrk
strrchr, _mbsrchr, wcsrchr
strrev, _mbsrev, _wcsrev
strset, _mbsset, _wcsset
strspn, _mbsspn, wcsspn
strstr, _mbsstr, wcsstr
strtok, _mbstok, wcstok
strupr, _mbsupr, _wcsupr
strxfrm, wcsxfrm
sys\stat.h
S_Ixxxx #defines
_stati64, _tstati64, stati64, _wstati64
fstat, stat, _wstat
sys\timeb.h
ftime
sys\types.h
time_t
time.h
_strdate, _wstrdate
_strtime, _wstrtime
asctime
clock
clock_t
ctime, _wctime
_daylight
difftime
gmtime
localtime
mktime
stime
strftime, wcsftime
time
_timezone
tm
_tzname,_wtzname
_tzset, _wtzset
typeinfo.h
bad_cast class
bad_typeid class
type_info class
utime.h
_utime, _wutime
values.h
BITSPERBYTE #define
HIBITx #defines
MAXxxxx #defines (integer data types)
Float and Double Limits
Win32 Developer's Guide
Component Writer's Guide
Creating a graphic component
Adding Graphic Capabilities
Creating a Graphic Component
Creating and Registering the Graphic Component
Declaring the Access Properties
Declaring the Class Fields
Declaring the Property
Declaring the Property Type
Determining What to Draw
Drawing the Component Image
Initializing Owned Classes
Overriding the Constructor and Destructor
Publishing Inherited Properties (Graphic)
Publishing the Pen and Brush
Refining the Shape Drawing
Setting Owned Classes' Properties
Writing the Implementation Method
Creating events
Creating Events: Overview
What Are Events?
Events Are closures (C++)
Events Are Method Pointers
Calling the Click-event Handler
Events Are Properties
Event Types Are Method-pointer Types
Event Handler Types Are Procedures
Event Handlers Have A Return Type of void (C++)
Event Types Are closure Types (C++)
Event Handlers Are Optional
Implementing the Standard Events
Identifying Standard Events
Making Events Visible
Changing the Standard Event Handling
Defining Your Own Events
Triggering the Event
Two Kinds of Events
Defining the Handler Type
Declaring the Event
Calling the Event
Empty Handlers Must Be Valid
Users Can Override Default Handling
Creating methods
Abstract Methods
Avoiding Interdependencies
Creating Methods: Overview
Declaring Methods
Example of Declaring Methods
Methods That Should Be Protected
Methods That Should Be Public
Naming Methods
Protecting Methods
Making Methods Virtual
Creating properties
Creating Properties: Overview
Why Create Properties?
Types of Properties
Publishing Inherited Properties
Defining Properties
Property Declarations
Internal Data Storage
Direct Access
Access Methods (properties)
The Read Method
The Write Method
Default Property Values
Specifying No Default Value
Creating Array Properties
Creating Properties for Interfaces
Creating Properties for Subcomponents
Storing and Loading Properties
Using the Store-and-load Mechanism
Specifying Default Values
Determining What to Store
Initializing After Loading
Storing and Loading Unpublished Properties
Creating Methods to Store and Load Property Values
Overriding the DefineProperties Method
Customizing a grid
Accessing the Day, Month, and Year
Changing Initial Values
Creating and registering the component (Grid)
Customizing a Grid: Overview
Excluding Blank Cells
Filling in the Cells
Generating the Day Numbers
Moving the Selection
Navigating Days
Navigating Months and Years
Providing an OnChange Event
Publishing Inherited Properties (Grid)
Resizing the Cells
Selecting the Current Day
Storing the Internal Date
Tracking the Date
Extending the IDE
Adding an Action to the Action List
Adding an Image to the Image List
Creating Forms and Projects
Debugging a Wizard
Deleting Toolbar Buttons
Extending the IDE
Implementing the Wizard Interfaces
Installing the Wizard Package
Interface Version Numbers
Notifying a Wizard of IDE Events
Obtaining Tools API Services
Overview of the Tools API
Using Editor Interfaces
Using Module Interfaces
Using Native IDE Objects
Working with Files and Editors
Writing a Wizard Class
Handling messages
Broadcasting a Message to All Controls in a Form
Calling a Control's Message Handler Directly
Responding to System Events
Sending a Message That Does Not Execute Immediately
Sending a Message Using the Windows Message Queue
Sending Messages
Changing Message Handling
Creating New Message Handlers
Declaring a Message Identifier
Example: User-defined Messages
Example: Message Structure
Declaring a Message-structure Type
Declaring a New Message-handling Method
Example: Message Handler
Defining Your Own Messages
Dispatching Messages
Example: Overriding a Message Handler
Overriding the Handler Method
Handling Messages and System Notifications: Overview
Trapping Messages
The WndProc Method
Understanding the message-handling system
Using Message Parameters
What's in a Windows Message?
Introduction to component creation
Overview of Component Creation
Class library
Components and Classes
Creating Components
Modifying Existing Controls
Creating Original Controls
Creating a New Component
Creating a Unit File
Declaring A New Constructor (C++)
Deriving the Component
Creating Nonvisual Components
Creating Graphic Controls
Encapsulating Graphics
Setting Properties, Methods, and Events
Registering the Component
Removing Dependencies
Registering Components (Introduction)
Subclassing Windows Controls
Creating a Component with the Component Wizard
What Goes into a Component?
Making Source Files Available
Testing Installed Components
Testing Uninstalled Components
Making a control data aware
Adding the Data Link
Adding the ReadOnly property
Allowing Needed Updates
Changing the Default Value of FReadOnly
Creating a Data Browsing Control
Creating a Data Editing Control
Creating and registering the data-aware component
Declaring the Access Properties for a Data-aware Control
Declaring the Class Field
Handling Mouse-down and Key-down Messages
Initializing the Data Link
Making a Control Data Aware
Making the Control Read-only
Modifying the Change Method
Responding to Data Changes
Responding to Key-down Messages
Responding to Mouse-down Messages
Updating the Dataset
Updating the Field Data Link Class
Making components available at design time
Adding Clipboard Formats
Adding Component Editors
Adding Items to the Context Menu
Adding Property Editors
Changing the Double-click Behavior
Compiling Components into Packages
Creating the Entries
Creating the Help File
Declaring the Register Procedure
Deriving a Property-editor Class
Editing the Property as a Whole
Implementing Commands
Making Component Help Context-sensitive
Making Components Available at Design Time: Overview
Property Categories
Specifying Property Categories
Providing Help for Your Component
Registering Components
Registering Multiple Properties at Once
Registering One Property at a Time
Registering the Component Editor
Registering the Property Editor
Setting the Property Value
Specifying Editor Attributes
Specifying Menu Items
Specifying the Components
Specifying the Palette Page
Troubleshooting Custom Components (C++)
Using the IsPropertyInCategory Function
Using the RegisterComponents Function
Writing the Register Procedure
Making a dialog box a component
Adding Interface Properties
Adding the Execute Method
Creating and Registering the Component (Dialog Box)
Creating the Component Interface
Defining the Component Interface
Including the Form Unit
Making a Dialog Box a Component: Overview
Testing the Component
Modifying an existing component
Creating and Registering the Modified Component
Modifying an Existing Component: Overview
Modifying the Component Object
Overriding the Constructor
Specifying the New Default Property Value
Object-oriented programming for component writers
Object-oriented Programming for Component Writers: Overview
Defining New Classes
Deriving New Classes
Abstract Class Members
Adding New Capabilities to a Class
Ancestors, Descendants, and Class Hierarchies
Changing Class Defaults to Avoid Repetition
Controlling Access
Declaring a New Component Class
Defining the Design-time Interface
Defining the Component Writer's Interface
Defining the Runtime Interface
Dispatching Methods
Dynamic Methods
Hiding Implementation Details
Virtual Methods
Classes and Pointers
Overriding Methods
Regular Methods (C++)
Static Methods
Using graphics in components
Creating and Managing Off-screen Bitmaps
Loading and Storing Graphics
Handling Palettes
Off-screen Bitmaps
Overview of Graphics
Using a Picture, Graphic, or Canvas
Responding to Changes
Responding to Palette Changes
Specifying a Palette for a Control
Using Graphics in Components: Overview
Using the Canvas
Working with Pictures
Developing COM-based Applications
COM basics
Overview of COM Technologies
Parts of a COM Application
COM Interfaces
The Fundamental COM Interface, IUnknown
COM Interface Pointers
COM Servers
CoClasses and Class Factories
In-process, Out-of-process, and Remote Servers
The Marshaling Mechanism
Aggregation (COM)
COM Clients
COM Extensions
Automation Servers
Active Server Pages
ActiveX Controls
Active Documents
Type Libraries
Implementing COM Objects with Wizards
Code Generated by Wizards
COM+ Event And Event Subscriber Objects
Creating an Active Server Page
Creating Active Server Pages: Overview
Creating an Active Server Object
Using the ASP Intrinsics
Creating ASPs for In-process or Out-of-process Servers
Registering an Active Server Object
Testing and Debugging the Active Server Page Application
Using ActiveX controls
Elements of an ActiveX Control
Designing an ActiveX Control
Generating an ActiveX Control Based On a VCL Form
Licensing ActiveX Controls
Customizing the ActiveX Control's Interface
Adding Additional Properties, Methods, and Events
How Delphi Adds Properties
How Delphi Adds Events
Enabling Simple Data Binding with the Type Library
Creating a Property Page for an ActiveX Control
Creating a New Property Page
Adding Controls to a Property Page
Associating Property Page Controls with ActiveX Control Properties
Updating the Property Page
Updating the Object
Connecting a Property Page to an ActiveX Control
Creating COM clients
Creating COM Clients
Importing Type Library Information
Code Generated When You Import Type Library Information
Controlling an Imported Object
Using Component Wrappers
Writing Client Code Based On Type Library Definitions
Connecting to a Server
Controlling an Automation Server Using a Dual Interface
Controlling an Automation Server Using a Dispatch Interface
Handling Events in an Automation Controller
Creating Clients for Servers That Do Not Have a Type Library
Creating simple COM servers
Creating Simple COM Servers: Overview
Designing a COM Object
Using the COM Object Wizard
Using the Automation Object Wizard
COM Object Instancing Types
Choosing a Threading Model
Defining a COM Object's Interface
Managing Events in Your Automation Object
Automation Interfaces
Dual Interfaces
Dispatch Interfaces
Custom Interfaces
Marshaling Data
Registering a COM Object
Testing and Debugging the Application
Working with type libraries
Working with Type Libraries: Overview
Type Library Editor
Parts of the Type Library Editor
Toolbar
Object List Pane
Status Bar
Pages of Type Information
Type Library Elements
Using the Type Library Editor
Valid Types
SafeArrays
Using Object Pascal or IDL Syntax
Creating a New Type Library
Opening an Existing Type Library
Adding an Interface to the Type Library
Modifying an Interface Using the Type Library
Adding Properties and Methods to the Type Library
Adding a CoClass to the Type Library
Adding an Interface to a CoClass
Adding an Enumeration to the Type Library
Adding an Alias to the Type Library
Adding a Record or Union to the Type Library
Adding a Module to the Type Library
Saving and Registering Type Library Information
Apply Updates Dialog
Saving a Type Library
Refreshing the Type Library
Registering the Type Library
Deploying Type Libraries
GenTLB.exe
RIDL File
Developing Database Applications
Working with ADO components
ADO Connection Events
Accessing the Connection Object
Accessing the Connection's Datasets
Applying the Batch Updates to Base Tables
Canceling Batch Updates
Canceling Commands
Connecting to ADO Data Stores
Connecting to a Data Store Using TADOConnection
Connecting an ADO Dataset to a Data Store
Controlling Timeouts
Fetching Records Asynchronously
Filtering Multiple Rows Based On Update Status
Filtering Records Based On Bookmarks
Fine-tuning a Connection
Forcing Asynchronous Connections
Handling Command Parameters
Indicating the Types of Operations the Connection Supports
Inspecting the Update Status of Individual Rows
Loading Data from and Saving Data to Files
Opening the Dataset in Batch Update Mode
Overview of ADO Components
Retrieving Result Sets with Commands
Specifying the Command
Specifying Whether the Connection Automatically Initiates Transactions
Using ADO datasets
Using Batch Updates
Using Command Objects
Using TADODataSet
Using the Execute Method
Working with ADO Components
Working with Record Sets
Connecting to databases
Controlling Connections
Disconnecting from a Database Server
Managing Transactions
Obtaining Metadata
Sending Commands to the Server
Specifying the Transaction Isolation Level
Using Implicit Connections
Working with Associated Datasets
Connecting to Databases: Overview
Controlling Server Login
Connecting to a Database Server
Creating multi-tiered applications
Connecting to the Application Server
Creating Multi-tiered Applications: Overview
Connecting to the Server
Advantages of the Multi-tiered Database Model
Brokering Connections
Building a Multi-tiered Application
Building an InternetExpress Application
Building Web Applications Using InternetExpress
Calling Server Interfaces
Choosing a Connection Protocol
Configuring TMTSDataModule
Configuring TRemoteDataModule
Configuring TSOAPDataModule
Connecting to an Application Server That Uses Multiple Data Modules
Creating an Active Form for the Client Application
Creating the Application Server
Creating the Client Application
Creating Web Pages with an InternetExpress Page Producer
Customizing the InternetExpress Page Producer Template
Distributing a Client Application as an ActiveX Control
Dropping or Changing a Server Connection
Extending the Interface of the Application Server
Granting Permission to Access and Launch the Application Server
Managing Server Connections
Managing Transactions in Multi-tiered Applications
Overview of a Three-tiered Application
Pooling Remote Data Modules
Registering the Application Server
Setting Up the Remote Data Module
Setting Web Item Properties
Specifying a Connection Using HTTP
Specifying a Connection Using DCOM
Specifying a Connection Using SOAP
Specifying a Connection Using Sockets
Supporting Master/detail Relationships
Supporting State Information in Remote Data Modules
The Structure of the Application Server
The Structure of the Client Application
Understanding Multi-tiered Database Applications
Using an XML Broker
Using DCOM Connections
Using Transactional Data Modules
Using Multiple Remote Data Modules
Using SOAP Connections
Using Socket Connections
Using the Javascript Libraries
Using the Web Page Editor
Using Web Connections
Writing Web-based Client Applications
Creating reports with Rave Reports
Rave Component Overview
Getting More Information
Getting Started with Rave Reports
Rave Reports: Overview
Rave Visual Designer
Designing database applications
Database architecture
Connecting a Client Dataset to Another Dataset in the Same Application
