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
Connecting Directly to a Database Server
Connecting to Another Dataset
Database Architecture
Using a Dedicated File on Disk
Using a Multi-Tiered Architecture
Combining Approaches
Designing Database Applications: Overview
Designing the user interface
Analyzing Data
Designing the User Interface
Writing Reports
Using databases
Database Security
Referential Integrity, Stored Procedures, and Triggers
Transactions
Types of Databases
Using Databases
Understanding datasets
Creating an Index with IndexFieldNames
Supplying Parameters at Design Time
Supplying Parameters at Runtime
Adding New Records
Applying or Canceling a Range
Calculating Fields
Canceling Changes
Controlling Read/Write Access to Tables
Creating and Deleting Tables
Creating Filters
Creating Master/detail Relationships
Deleting Records
Editing Records
Emptying Tables
Enabling and Disabling Filtering
Establishing Master/detail Relationships Using Parameters
Executing a Search with Find Methods
Executing a Search with Goto Methods
Executing Queries That Don't Return a Result Set
Executing Stored Procedures That Don't Return a Result Set
Fetching Multiple Result Sets
Limiting Records with Ranges
Making the Table a Detail of Another Dataset
Marking and Returning to Records
Modifying a Range
Modifying Entire Records
Navigating Records in a Filtered Dataset
Obtaining Information About Indexes
Opening and Closing Datasets
Posting Data
Preparing Queries
Preparing Stored Procedures
Searching On Partial Keys
Searching On Partial Keys
Setting Filter Options
Setting the Filter Property
Sorting Records with Indexes
Specifying Ranges
Specifying the Current Record After a Successful Search
Specifying the Query
Synchronizing Tables
Understanding the Differences Between Ranges and Filters
Using Indexes to Search for Records
Using Nested Detail Tables
Using Parameters in Queries
Using Query-type Datasets
Using Stored Procedure-type Datasets
Using TDataSet Descendants
Using Table Type Datasets
Using the Eof and Bof Properties
Using the First and Last Methods
Using the MoveBy Method
Using the Next and Prior Methods
Using Unidirectional Result Sets
Working with Stored Procedure Parameters
Using Locate
Using Lookup
Modifying Data
Searching Datasets
Specifying an Index with IndexName
Displaying and Editing a Subset of Data Using Filters
Understanding Datasets: Overview
Determining Dataset States
Navigating Datasets
Writing an OnFilterRecord Event Handler
Types of Datasets
Using the Borland Database Engine
BDE-based Architecture
Executing an Update Statement
Using an Update Component's Query Property
Using Multiple Update Objects
Calling the Apply Method
Executing the SQL Statements
Using the Borland Database Engine
Connecting to databases with TDatabase
Associating a Database Component with a Session
Using TDatabase to Connect to Databases
Opening a Connection Using TDataBase
Understanding Database and Session Component Interactions
Using Database Components in Data Modules
Setting BDE Alias Parameters
Identifying the Database
Managing database sessions
Activating a Session
Creating Additional Sessions
Iterating Through a Session's Database Components
Opening Database Connections
Searching for a Database Connection
Specifying Paradox Directory Locations
Retrieving Information About a Session
Closing Database Connections
Working with BDE Aliases
Naming a Session
Managing Multiple Sessions
Specifying Default Database Connection Behavior
Dropping Inactive Database Connections
Working with Password-protected Paradox and dBASE Tables
Managing Database Sessions
Managing Database Connections
Using BDE-enabled datasets
Associating a Dataset with Database and Session Connections
Binding Parameters
Caching BLOBs
Controlling Read/Write Access to Local Tables
Importing Data from Another Table
Working with BDE Handle Properties
Renaming a Table
Specifying a dBASE Index File
Specifying the Table Type for Local Tables
Using TQuery
Using TStoredProc
Using TTable
Using BDE-enabled Datasets
Creating Heterogenous Queries
Obtaining an Editable Result Set
Updating a Read-only Result Set
Working with Oracle Overloaded Stored Procedures
Using TBatchMove
Creating a Batch Move Component
Executing a Batch Move
The Data Dictionary
Tools for Working with the BDE
Specifying a Batch Move Mode
Using TBatchMove
Handling Batch Move Errors
Mapping Data Types
Using the BDE to cache updates
Applying Cached Updates Using a Database
Composing Update SQL Statements
Enabling BDE-based Cached Updates
Understanding Parameter Substitution in Update SQL Statements
Using the BDE to Cache Updates
Using the Update SQL Editor
Applying BDE-based Cached Updates
Using Update Objects to Update a Dataset
Creating an OnUpdateRecord Event Handler
Applying Cached Updates with Dataset Component Methods
Creating SQL Statements for Update Components
Handling Cached Update Errors
Using transactions with the BDE
Using Local Transactions
Using Passthrough SQL
Using Transactions with the BDE
Using client datasets
Adding a New Index
Adding Application-specific Information to the Data
Aggregating over groups of records
Applying Updates
Choosing the Type of Dataset for Caching Updates
Communicating with Providers Using Custom Events
Constraining Data Values
Copying Data from Another Dataset
Creating a New Dataset
Deleting and Switching Indexes
Editing Data
Getting Parameters from the Application Server
Handling Constraints from the Server
Indicating What Records Are Modified
Intervening as Updates Are Applied
Limiting Records with Parameters
Merging Changes into Data
Navigating Data in Client Datasets
Obtaining Aggregate Values
Overriding the Dataset On the Application Server
Overview of Using Cached Updates
Passing Parameters to the Source Dataset
Refreshing Records
Representing Calculated Values
Requesting Data from the Source Dataset or Document
Saving Changes
Sending Query or Stored Procedure Parameters
Setting Up a Simple Dataset
Sorting and Indexing
Specifying a Provider
Specifying Aggregates
Undoing Changes
Updating Records
Using a Client Dataset to Cache Updates
Using a Client Dataset with a Provider
Using a Client Dataset with File-based Data
Using a Simple Dataset
Using Indexes to Group Data
Using Internally Calculated Fields in Client Datasets
Using Maintained Aggregates
When to Use TSimpleDataSet
Cloning a Client Dataset Cursor
Working with Data Using a Client Dataset
Reconciling Update Errors
Assigning Data Directly
Loading Data from a File or Stream
Saving Data to a File or Stream
Using Client Datasets: Overview
Limiting What Records Appear
Using data controls
Associating a Data Control with a Dataset
Choosing How to Organize the Data
Displaying a Single Record
Changing the Associated Dataset at Runtime
Restricting Field Values with Radio Controls
Arranging the Order of Persistent Columns
Choosing Navigator Buttons to Display
Controlling Grid Drawing
Creating a Customized Grid
Creating a Grid That Contains Other Data-aware Controls
Creating Persistent Columns
Defining a Lookup List Column
Deleting Persistent Columns
Displaying ADT and Array Fields
Displaying Fly-over Help
Displaying Multiple Records
Editing in the Grid
Putting a Button in a Column
Responding to User Actions at Runtime
Restoring Default Values to a Column
Setting Column Properties at Design Time
Setting Grid Options
Using a Grid Control in Its Default State
Using a Single Navigator for Multiple Datasets
Viewing and Editing Data with TDBGrid
Navigating and Manipulating Records
Disabling and Enabling Data Display
Displaying and Editing Data in List and Combo Boxes
Displaying and Editing Data in Lookup List and Combo Boxes
Displaying and Editing Fields in an Edit Box
Displaying and Editing Graphics Fields in an Image Control
Displaying and Editing Text in a Memo Control
Displaying and Editing Text in a Rich Edit Memo Control
Displaying Data as Labels
Editing and Updating Data
Editing Data in a Control
Enabling and Disabling the Data Source
Enabling Editing in Controls On User Entry
Enabling Mouse, Keyboard, and Timer Events
Handling Boolean Field Values with Check Boxes
Refreshing Data Display
Responding to Changes Mediated by the Data Source
Using Common Data Control Features
Using TDBListBox and TDBComboBox
Using Data Controls
Using decision support components
Changing Other Decision Graph Series Properties
Changing Other Decision Graph Template Properties
Changing the Default Decision Graph Type
Changing the Series Graph Type
Creating Decision Datasets with TQuery or TTable
Creating Decision Grids
Decision Cube Properties and Events
Decision Graphs at Runtime
Decision Grids at Runtime
Decision Pivots: Runtime Behavior
Decision Support Components at Runtime
Drilling Down for Detail in Decision Grids
Limiting Dimension Selection in Decision Grids
Opening and Closing Decision Grid Fields
Overview of Decision Support Components
Decision Pivot Properties
Reorganizing Rows and Columns in Decision Grids
Saving Decision Graph Series Settings
Setting Decision Graph Template Defaults
Setting Dimension State
Setting Maximum Dimensions, Summaries, and Cells
Setting the Maximum Available Dimensions and Summaries
Using Paged Dimensions
Viewing and Changing Design Options
Viewing and Changing Dimension Settings
Viewing Overall Decision Graph Properties
One-Dimensional Crosstabs
Using Decision Graphs
The Decision Graph Display
Using the Decision Cube Editor
Creating and Using Decision Graphs
Multidimensional Crosstabs
Using Decision Cubes
Decision Grid Properties
Using Decision Pivots
Customizing Decision Graph Series
Using Datasets with Decision Support Components
Using Decision Support Components
Decision Support Components and Memory Control
Using Decision Grids
Customizing Decision Graphs
Creating Decision Graphs
Creating Decision Datasets with the Decision Query Editor
Using Decision Sources
Creating and Using Decision Grids
About Crosstabs
Guidelines for Using Decision Support Components
Using provider components
Responding to Client Update Requests
Adding Custom Information to Data Packets
Applying Updates to Datasets That do Not Represent a Single Table
Choosing How to Apply Updates Using a Dataset Provider
Communicating with the Client Dataset
Controlling What Information Is Included in Data Packets
Determining the Source of Data
Editing Delta Packets Before Updating the Database
Handling Server Constraints
Influencing How Updates Are Applied
Resolving Update Errors On the Provider
Responding to Client Data Requests
Responding to Client-generated Events
Screening Individual Updates
Setting Options That Influence the Data Packets
Specifying What Fields Appear in Data Packets
Using Provider Components
Using dbExpress Components
Using dbExpress Datasets
Accessing dbExpress Schema Information
Connecting to the Database Server
Creating and Modifying Server Metadata
Debugging dbExpress Applications
Executing Commands That Do Not Return Records
Executing the Command
Fetching Metadata into a dbExpress Dataset
Fetching the Data
Representing the Records in a Table
Representing the Results of a Query
Representing the Results of a Stored Procedure
Setting Up Master/Detail Linked Relationships
Setting Up TSQLConnection
Specifying the Command to Execute
Specifying What Data to Display
Types of dbExpress Datasets
The Structure of Metadata Datasets
Using XML in database applications
Converting XML Documents into Data Packets
Defining Transformations
Mapping Between XML Nodes and Data Packet Fields
Using an XML Document as the Client of a Provider
Using an XML Document as the Source for a Provider
Using XML in Database Applications
Using XMLMapper
Working with field components
Accessing Field Values with a Dataset's FieldByName Method
Accessing Field Values with a Dataset's Fields Property
Arranging Persistent Fields
Associating Attribute Sets with Field Components
Creating a Custom Constraint
Defining a Data Field
Defining an Aggregate Field
Defining New Persistent Fields
Deleting Persistent Field Components
Displaying, Converting, and Accessing Field Values
Displaying Field Component Values in Standard Controls
Persistent Field Components
Removing Attribute Associations
Setting a Default Value for a Field
Setting Display and Edit Properties at Design Time
Using Object Fields
Using Server Constraints
Working with Constraints
Working with Field Component Methods at Runtime
Working with ADT Fields
Working with Array Fields
Working with DataSet Fields
Working with Reference Fields
Defining a Lookup Field
Creating Attribute Sets for Field Components
Programming a Calculated Field
Setting Persistent Field Properties and Events
Handling Events
Accessing Field Values with the Default Dataset Property
Defining a Calculated Field
Using Default Formatting for Numeric, Date, and Time Fields
Setting Field Component Properties at Runtime
Creating Persistent Fields
Converting Field Values
Dynamic Field Components
Working with Field Components: Overview
Controlling and Masking User Input
Programming with Delphi
Building applications, components, and libraries
Creating packages and DLLs
Creating DLLs Containing VCL Components (C++)
Creating Packages and DLLs
Linking DLLs
When to Use Packages and DLLs
Using DLLs in RAD Studio (C++)
Creating Applications
Creating Web server applications
Creating Web Services Applications
Creating WebSnap Applications
Creating Web Broker Applications
Creating Web Server Applications
Enabling Help in applications
Asking the Help Manager for Information
Calling a Help System Directly
Communicating with the Help Manager
Customizing the IDE Help System
Displaying Keyword-based Help
Displaying Tables of Contents
Enabling Help in Applications
Help System Interfaces
How TApplication Processes VCL Help
How VCL Controls Process Help
Implementing ICustomHelpViewer
Implementing IExtendedHelpViewer
Implementing IHelpSelector
Registering Help System Objects
Using Help in a VCL Application
Using IHelpSystem
GUI applications
Setting IDE, Project, and Compiler Options
Console Applications
MDI Applications
SDI Applications
User Interface Models
GUI Applications
Service applications
Debugging Service Applications
Service Applications
Service Name Properties
Service Threads
Using data modules
Accessing a Data Module from a Form
Adding a Remote Data Module to an Application Server Project
Creating and Editing Standard Data Modules
Creating Business Rules in a Data Module
Using Data Modules
Naming a Data Module and Its Unit File
Placing and Naming Components
Using Component Properties and Events in a Data Module
Using the Object Repository
Adding Items to the Object Repository
Copying an Item
Inheriting an Item
Modifying Shared Items
Sharing Items Within a Project
Sharing Objects in a Team Environment
Using an Item
Using an Object Repository Item in a Project
Using Project Templates
Using the Object Repository
Writing applications using COM
Writing Applications Using COM
Writing database applications
Distributing Database Applications
Writing Database Applications
Creating international applications
Creating International Applications: Overview
Internationalization and Localization
Internationalization
Localization
Internationalizing Applications
Enabling Application Code
Character Sets
OEM and ANSI Character Sets
Multibyte Character Sets (MBCS)
Wide Characters
Including Bi-directional Functionality in Applications
ParentBiDiMode Property
FlipChildren Method
Additional Methods
Locale-specific Features
Localization Considerations in UI Design
Text
Graphic Images
Formats and Sort Order
Keyboard Mappings
Isolating Resources
Creating Resource DLLs
Using Resource DLLs
Dynamic Switching of Resource DLLs
Localizing Applications
Delphi programming fundamentals
Designing Applications
Creating Projects
Editing Code
Compiling Applications
Debugging Applications
Deploying Applications
Deploying applications
Deploying BDE Applications
Deploying dbExpress Database Applications
Deploying On Apache Servers
Accommodating Varying Color Depths
Deploying ActiveX Controls
Application Files, Listed by File Name Extension
Borland Database Engine
Considerations When Dynamically Resizing Forms and Controls
Considerations When Not Dynamically Resizing
DLL Locations
Deploying Applications: Overview
Deploying Database Applications
Deploying General Applications
Deploying Web Applications
Fonts
Helper Applications
Identifying Application Files
Merge Modules
Deploying Multi-tiered Database Applications (DataSnap)
Package Files
Programming for Varying Host Environments
Screen Resolutions and Color Depths
Software License Requirements
Using Installation Programs
Operating System Versions
Developing the application user interface
Adding Forms
Adding Color, Patterns, or Pictures to Menus, Buttons, and Toolbars
Adding Icons to Menus and Toolbars
Adding Images to Menu Items
Adding, Inserting, and Deleting Menu Items
Adding a Cool Bar Component
Adding a Speed Button to a Panel
Adding a Toolbar Using a Panel Component
Adding a Toolbar Using the Toolbar Component
Adding a Tool Button
Adding Hidden Toolbars
Allowing Toggle Buttons
Allowing Toggled Tool Buttons
Assigning a Menu to a Tool Button
Assigning a Speed Button's Glyph
Assigning Images to Tool Buttons
Building Menus
Common Controls and XP Themes
Controlling When Forms Reside in Memory
Creating and Managing Menus
Creating and Using Component Templates
Creating Customizable Toolbars and Menus
Creating Dynamic Menus
Creating Frames
Creating Most Recently Used Lists
Creating Submenus
Creating Toolbars and Menus
Creating a Group of Speed Buttons
Creating Forms Dynamically
Creating Groups of Tool Buttons
Creating Modeless Forms Such as Windows
Demo Programs: Actions, Action Lists, Menus, and Toolbars
Designing Toolbars and Cool Bars
Determining the Order of Merged Menu Items: GroupIndex Property
Developing the Application User Interface: Overview
Displaying an Auto-created Form
Editing Menu Items in the Object Inspector
What Happens When an Action Fires
Handling the Screen
Hiding the Main Form
Hiding Unused Items and Categories in Action Bands
Hiding and Showing Toolbars
How Actions Find Their Targets
Developing Dialog Boxes
Importing Resource Files
Managing Layout
Manipulating Menu Items at Runtime
Merging Menus
Using Forms
Moving Menu Items
Naming Conventions for Template Menu Items and Event Handlers
Naming Menus
Naming the Menu Items
Opening the Menu Designer
Organizing Actions for Toolbars and Menus
Passing Additional Arguments to Forms
Predefined Action Classes
Registering Actions
Responding to Clicks
Retrieving Data from Forms
Retrieving Data from Modal Forms
Retrieving Data from Modeless Forms
Reusing Components and Groups of Components
Saving a Menu as a Template
Selecting Menu and Toolbar Styles
Setting Up Action Bands
Setting Up Action Lists
Setting the Appearance of the Cool Bar
Setting the Initial Condition of a Speed Button
Setting Tool Button Appearance and Initial Conditions
Sharing Frames
Specifying Accelerator Keys and Keyboard Shortcuts
Specifying the Active Menu: Menu Property
Switching Between Menus at Design Time
Controlling Application Behavior
Updating Actions
Using Action Lists
Using and Modifying Frames
Using Menu Templates
Using the Main Form
Using the Menu Designer Context Menu
Creating a Form Instance Using a Local Variable
Viewing the Menu
What Is an Action?
Working at the Application Level
Working with Frames
Writing Action Components
Using Windows Common Dialog Boxes
Exception handling
Unwinding Exceptions (C++)
Exception Handling Options (C++)
Constructors In Exception Handling (C++)
Defining Protected Blocks
Exception Handling
Exception-handling Statements
Throwing An Exception (C++)
Raising an Exception
Reraising Exceptions
Smart Pointers (C++)
Scope of Exception Handlers
Silent Exceptions
Writing a finally Block (C++)
Writing a Finally Block (Delphi)
Writing Exception Handlers
Writing finally Blocks
Writing the Try Block
Handling Classes of Exceptions
VCL Exception Classes
Default Exception Handling in VCL
Defining Your Own VCL Exceptions
Handling Exceptions in VCL Applications
Types of controls
Value List Editors (VCL Only)
Animation Control
Bevels
Bitmap Buttons
Button Controls
Buttons and Similar Controls
Check Boxes
Combo Boxes
Cool Bars (VCL Only)
Draw Grids
Graphic Controls
Group Boxes and Radio Groups
Grouping Controls
List Controls
Header Controls
Help and Hint Properties
Hot Key Controls (VCL Only)
Images
Labels
List Boxes and Check-list Boxes
List Views
Memo and Rich Edit Controls
Page Controls
Paint Boxes
Panels
Progress Bars
Radio Buttons
Scroll Bars
Scroll Boxes
Shapes
Specialized Input Controls
Speed Buttons
Splitter Controls
Status Bars
String Grids
Tab Controls
Grids
Edit Controls
Toolbar Controls
Track Bars
Tree Views
Up-down Controls (VCL Only)
Display Controls
Text Controls
Text Viewing Controls
Understanding the component library
Understanding the Component Library
Properties, Methods, and Events
Types of Events
Objects, Components, and Controls
TObject Branch
TPersistent Branch
TComponent Branch
TControl Branch
TWinControl/TWidgetControl Branch
Using the object model
Using Object Variables
Changing the Name of a Component
Components and Ownership
Creating, Instantiating, and Destroying Objects
Examining a Delphi Object
Inheriting Data and Code from an Object
Private, Protected, Public, and Published Declarations
Scope and Qualifiers
Using the Object Model
What Is an Object?
TInterfacedObject
Defining New Classes (Delphi)
Aggregation
Implementing IInterface
Memory Management of Interface Objects
Not Using Reference Counting
Reusing Code and Delegation
Using Interfaces Across the Hierarchy
Using Implements for Delegation
Using Interfaces
Using Interfaces in Distributed Applications
Using Interfaces with Procedures
Using Reference Counting
Using the as Operator with Interfaces
Using the VCL/RTL
Using the VCL/RTL: Overview
Adding New Measurement Types
Approaches to File I/O
Common List Operations
Converting Measurements
Copying and Clearing Custom Variants
Copying Data from One Stream to Another
Creating a Class to Enable the Custom Variant Type
Creating a Simple Conversion Family and Adding Units
Defining Custom Variants
Enabling Casting
Use __fastcall When Overriding VCL Methods
Working with ini Files and the System Registry
Using Streams
Using TRegistry
Implementing Binary Operations
Implementing Comparison Operations
Implementing Unary Operations
Loading and Saving Custom Variant Values
Performing Conversions
Persistent Lists
Specifying the Stream Position and Size
Storing a Custom Variant Type's Data
String Dependencies
Supporting Properties and Methods in Custom Variants
Using a Class to Manage Conversions
Using a Conversion Function
Using Streams to Read or Write Data
Using the TCustomVariantType Descendant
Writing Utilities to Work with a Custom Variant Type
Commonly Used Long String Routines
Commonly Used Routines for Null-terminated Strings
Compiler Directives for Strings
Copying a File
Declaring and Initializing Strings
Deleting a File
File Date-time Routines
Finding a File
Manipulating Files
Mixing and Converting String Types
Passing a Local Variable as a PChar
Creating Drawing Spaces
Printing
Using TRegistryIniFile
Renaming a File
Returning a PChar Local Variable
String to PChar Conversions
Using TIniFile and TMemIniFile
Using File Streams
Accessing a Particular String
Adding a String to a List
Associating Objects with a String List
Copying a Complete String List
Counting the Strings in a List
Creating a New String List
Deleting a String from a List
Locating Items in a String List
Iterating Through Strings in a List
Loading and Saving String Lists
Manipulating Strings in a List
Working with Lists
Working with String Lists
Wide Character Routines
Working with Files
Working with Strings
Working with components
Adding Custom Components to the Tool Palette
Associating Menu Events with Event Handlers
Calling Methods
Deleting Event Handlers
Displaying and Coding Shared Events
Associating an Event with an Existing Event Handler
Generating a New Event Handler
Generating a Handler for a Component's Default Event
Locating Event Handlers
Setting Properties at Design Time
Setting Component Properties
Setting Properties at Runtime
Using Property Editors
Using the Sender Parameter
Working with Events and Event Handlers
Working with controls
Accepting Dragged Items
Adding Graphical Objects to a String List
Adding Graphics to Controls
Adding Images to a String List
Adding Images to an Application
Adding Scroll Bars at Runtime
Adding the Clipboard Object
Changing the Drag Mouse Pointer
Controlling How Child Controls Are Docked
Controlling How Child Controls Are Undocked
Controlling How Child Controls Respond to Drag-and-dock Operations
Customizing Drag and Drop with a Drag Object
Cutting, Copying, and Pasting Text
Deleting Selected Text
Disabling Menu Items
Implementing Drag and Drop in Controls
Drawing Owner-draw Items
Drawing Owner-drawn Items
Dropping Items
Ending a Drag Operation
Handling the OnPopup Event
Implementing Drag and Dock in Controls
Making a Control a Dockable Child
Making a Windowed Control a Docking Site
Providing a Pop-up Menu
Selecting All Text
Selecting Text
Indicating That a Control Is Owner-drawn
Setting Text Alignment
Sizing Owner-draw Items
Starting a Drag Operation
Working with Text in Controls
Screen Scaling and ChangeScale
Working with graphics and multimedia
Changing the Brush Style
Overview of Graphics Programming
Working with Multimedia
Adding Audio and/or Video Clips to an Application
Adding Silent Video Clips to an Application
Example of Adding Audio and/or Video Clips (VCL Only)
Example of Adding Silent Video Clips
Adding a Field to a Form Object to Track Mouse Actions
Adding an Image Control
Changing the Brush Color
Changing the Pen Color
Changing the Pen Mode
Changing the Pen Style
Changing the Pen Width
Changing the Tool with Speed Buttons
Common Properties and Methods of Canvas
Copying Graphics to the Clipboard
Cutting Graphics to the Clipboard
Drawing Lines
Drawing Lines and Polylines
Drawing On a Graphic
Drawing On the Bitmap
Drawing Polygons
Drawing Polylines
Drawing Rectangles and Ellipses
Drawing Rounded Rectangles
Drawing Shapes
Drawing Shapes (Code)
Getting the Pen Position
Handling Multiple Drawing Objects in Your Application
Keeping Track of Which Drawing Tool to Use
Loading a Picture from a File
Loading and Saving Graphics Files
Making Scrollable Graphics
Pasting Graphics from the Clipboard
Placing the Control
Reading and Setting Pixels
Refining Line Drawing
Refreshing the Screen
Replacing the Picture
Responding to a Mouse Move
Responding to a Mouse-down Action
Responding to a Mouse-up Action
Responding to the Mouse
Rubber Banding Example
Saving a Picture to a File
Setting the Brush Bitmap Property
Setting the Initial Bitmap Size
Sharing Code Among Event Handlers
Tracking Movement
Tracking the Origin Point
Types of Graphic Objects
Using Brushes
Using Canvas Methods to Draw Graphic Objects
Using Drawing Tools
Using Pens
Using the Clipboard with Graphics
Using the Properties of the Canvas Object
What's in a Mouse Event
Working with Graphics and Multimedia: Overview
Working with packages and components
Loading Packages with the LoadPackage Function
Working with Packages and Components: Overview
Compiling Packages
Creating and Editing Packages
Creating a Package
Custom Packages
Deciding Which Runtime Packages to Use
Deploying Packages
Design-time Packages
Editing an Existing Package
Editing Package Source Files Manually
Installing Component Packages
Package Collection Files
Package Files Created by Compiling
Packages and Standard DLLs
Package-specific Compiler Directives
Runtime Packages
Understanding the Structure of a Package
Loading Packages in an Application
Compiling and Linking from the Command Line
Weak Packaging
Why Use Packages?
Writing multi-threaded applications
Coordinating threads
Other Techniques for Sharing Memory
Avoiding Simultaneous Access
Coordinating Threads
Locking Objects
Using Critical Sections
Using the Multi-read Exclusive-write Synchronizer
Waiting for a Task to Be Completed
Waiting for a Thread to Finish Executing
Waiting for Other Threads
Writing Multi-threaded Applications
Defining thread objects
Checking for Termination by Other Threads
Defining Thread Objects
Handling Exceptions in the Thread Function
Initializing the Thread
Using the Main VCL Thread
Using Thread-local Variables
Writing Clean-up Code
Writing the Thread Function
Executing thread objects
Assigning Separate Names to Similar Threads
Converting an Unnamed Thread to a Named Thread
Naming a Thread
Debugging Multi-threaded Applications
Executing Thread Objects
Overriding the Default Priority
Starting and Stopping Threads
Writing Internet Applications
Creating Internet server applications
Debugging server applications
Debugging Web Applications That Are DLLs
Debugging Server Applications
Using the Web Application Debugger
About Web Broker and WebSnap
HTTP server activity
Composing Client Requests
HTTP Server Activity
Responding to Client Requests
Serving Client Requests
Types of Web Server Applications
Creating Internet Applications: Overview
Terminology and standards
HTTP Request Header Information
Parts of a Uniform Resource Locator
Terminology and Standards
Using IntraWeb (VCL for the Web)
Getting started with IntraWeb
Getting Started with IntraWeb
Creating a New VCL for the Web Application
Editing the Main Form
Writing an Event Handler for the Button
Running the Completed Application
Changing VCL for the Web application type
Using IntraWeb Components
Creating Web Server Applications Using IntraWeb
Using IntraWeb with Web Broker and WebSnap
Using Web Broker
Generating the content of response messages
Using database information in responses
Adding a Session to the Web Module
Embedding Tables in HTML Documents
Representing a Dataset in HTML
Specifying the Columns
Specifying the Row Attributes
Specifying the Table Attributes
Using Dataset Page Producers
Using Database Information in Responses
Using TDataSetTableProducer
Using TQueryTableProducer
Using Table Producers
Chaining Page Producers Together
Converting HTML-transparent Tags
Generating the Content of Response Messages
HTML Templates
Specifying the HTML Template
Using Page Producer Components
Using Page Producers from an Action Item
Using Predefined HTML-transparent Tag Names
Using Web Broker
The structure of a Web Broker application
Accessing client request information
Accessing Client Request Information
Properties That Contain Request Header Information
Properties That Describe the Content
Properties That Describe the Expected Response
Properties That Describe the Web Client
Properties That Identify the Purpose of the Request
Properties That Identify the Target
The Content of HTTP Request Messages
Adding Actions to the Dispatcher
Action items
Action Items
Choosing a Default Action Item
Determining When Action Items Fire
Enabling and Disabling Action Items
Responding to Request Messages with Action Items
The Request Method Type
The Target URL
Dispatching Request Messages
Creating HTTP response messages
Creating HTTP Response Messages
Describing the Content
Describing the Server Application
Filling in the Response Header
Indicating the Need for Client Action
Indicating the Response Status
Sending the Response
Setting the Response Content
The Structure of a Web Broker Application
The Web dispatcher
The Web Dispatcher
Creating Web Server Applications with Web Broker
The Web Application Object
The Web Module
Using Web Services
Using Web Services
Understanding Invokable Interfaces
Using Nonscalar Types in Invokable Interfaces
Registering Nonscalar Types
Using Remotable Objects
Remotable Object Example
Writing Servers that Support Web Services
Using the SOAP Application Wizard
Adding New Web Services
Using the WSDL Importer
Defining and Using SOAP Headers
Creating Custom Exception Classes for Web Services
Generating WSDL Documents for a Web Service Application
Writing Clients for Web Services
Importing WSDL Documents
Calling Invokable Interfaces
Processing Headers in Client Applications
Using WebSnap
Creating Web server applications with WebSnap
Advanced HTML Design
Specifying Application Module Components
Creating Web Server Applications with WebSnap
Selecting a Server Type
Selecting Web Application Module Options
Creating Web Server Applications Using WebSnap
Dispatching requests and responses
Adapter dispatcher operation
Adapter Dispatcher Operation
Receiving Adapter Requests and Generating Responses
Dispatcher Components
Dispatching Action Items
Dispatching Requests and Responses
Page dispatcher operation
Fundamental WebSnap components
Web modules
Web Application Module Types
Web Data Modules
Web Modules
Web Page Modules
Adapters
Fundamental WebSnap Components
Page Producers
Login support
Adding Login Support
Login Pages
Login Support
Setting Pages to Require Logins
User Access Rights
Using the Sessions Service
Server-side scripting in WebSnap
Script Objects
Server-side Scripting in WebSnap
Working with sockets
Describing sockets
Describing Sockets
Describing the Host
Using Ports
Working with Sockets
Implementing services
Implementing Services
Services and Ports
Understanding Service Protocols
Reading and writing over socket connections
Blocking Connections
Non-blocking Connections
Reading and Writing Events
Reading and Writing Over Socket Connections
Responding to socket events
Client Events
Error Events
Responding to Socket Events
Server Events
Types of socket connections
Client Connections
Listening Connections
Server Connections
Types of Socket Connections
Using socket components
Using client sockets
Closing the Connection
Forming the Connection
Getting Information About the Client Socket Connection
Specifying the Desired Server
Using Client Sockets
Using Socket Components
Using server sockets
Closing Server Connections
Connecting to Clients
Listening for Client Requests
Specifying the Port
Using Server Sockets
Getting Information About the Client or Server Socket Connection
Working with XML documents
Working with XML Documents
Using the Document Object Model
Working with XML Components
Using TXMLDocument
Working with XML Nodes
Abstracting XML Documents with the Data Binding Wizard
Using the XML Data Binding Wizard
Using Code That the XML Data Binding Wizard Generates
Copyright(C) 2009 Embarcadero Technologies, Inc. All Rights Reserved.
