Using Borland® C++ 4.5

Your key to successful application development!

All the latest features, techniques, and tips are at your fingertips with this comprehensive tutorial and reference. Using Borland C++ 4.5 reveals everything you need to master OLE encapsulation and OWL and work with the bundled compiler tools.

Step-by-step lessons and practical examples help you get productive with object-oriented programming. You learn how to use classes, objects, constructors, destructors, and streams, as well as how to take advantage of Borland C++'s OLE 2.0 functionality. In no time you'll be developing industrial-strength applications with this desktop companion!

Master the art of professional programming with Using Borland C++ 4.5 from Que!

1. Getting started with Borland C++
• Running the Installation Utility
• Installing Borland C++
• Using the Integrated Development Environment (IDE)
• Starting the IDE
• Using the IDE's Menus and Windows
• The Menu System
• The Window System
• Configuring Borland C++
• Setting the IDE Options
• The Project Settings
• The Environment Settings
• The Tools Settings
• Writing Your First C++ Program
• Understanding C++ Program Structure
• Preprocessor Directives
• Global Declarations
• The main() function
• User-Defined Functions
• Function Declarations, Definitions, and Calls
• Using the Editor to Write a program
• Compiling and Running the Program
• Looking at How the Program Works
• Introducing the Library Functions
• Using Some Basic Input Functions
• The get…() Functions
• The scanf() Function
• Using Some Basic Output Functions
• The put…() Functions
• The printf() Function
• Using Some Format-Conversion Functions
• The atoi () Function
• The toupper() Function
• Exercises
• Summary
2. Understanding the foundations of C
• Laying the Foundation
• Understanding Source, Object, and Load Modules
• Understanding Program Logic and Execution Flow
• Using Conditional Instructions
• Using Loop Instructions
• Using the Basic Data Types
• Understanding C's Basic Data Types
• Integers
• Floating-Point Numbers
• Character Data
• Knowing Where to Define Data Objects
• Writing C Expressions and Statements
• Understanding Expressions and Statements
• Introducing the C Operator Set
• Controlling Type Conversions
• Understanding Implicit Type Conversions
• Using Explicit Type Conversions
• Using C Macros
• Defining Object-like Macros
• Defining Function-like Macros
• Exercises
• Summary
3. Using C functions
• Understanding the main() Function and Library Functions
• Writing the main() Function
• Using Library Functions
• Knowing Which Library Functions Are Available
• Including Library Functions in Your Program
• Writing Your Own Functions
• Writing Prototypes for Your Functions
• Passing Arguments to Your Functions
• Returning Values from Functions
• Defining and Using Function Types
• Using Functions Like Objects
• Understanding Storage Classes
• Determining a Variable's Scope
• Determining a Variable's Duration
• Determining a Variable's Linkage
• Using Advanced Program Control Logic
• Writing Loop-Control Statements
• Using goto
• Using break
• Using continue
• Changing the Flow of Program Execution
• Using exit() and abort()
• Using the WinExec() Function
• Using Variable Argument Lists
• Designing Variable Argument Lists
• Using the va_…() Functions
• Exercises
• Summary
4. Using pointers and derived types
• Understanding Standard C Derived Types
• Understanding C's Typing Scheme
• Creating New Types from Old
• Understanding C Pointers
• Understanding Indirect Addressing
• Using C's Indirection and Address-of Operators
• Using Arrays and Strings
• Declaring and Using Arrays of Objects
• Understanding C Strings
• Using Structures and Unions
• Building Structures from Different Types
• Unions Are Alternative Views of Structures and Objects
• Using Pointers to Functions
• Declaring and Initializing Pointers to Functions
• Calling Functions with a Pointer Reference
• Using Pointers with Dynamic Memory
• Your C Program and Dynamic Memory
• Using Dynamic Memory
• Exercises
• Summary
5. Building, compiling, and testing Borland C++ programs
• Using Several Source Files for One Program
• Deciding What to Put in a Source File
• Setting Up a Borland C++ Project File
• Understanding External References
• Using the extern Keyword
• Using External Functions
• Writing Header Files for External Modules
• Deciding What Goes in the Header File
• Including User-Supplied Header Files
• Using Conditional Compiler Directives in Header Files
• Compiling and Running Programs with the IDE
• Compiling and Running Simple Programs
• Simple Error Correction
• Introducing the Integrated Debugger
• Using the Step over Command to Narrow the Search
• Using the Trace into Command to Pinpoint the Problem
• Exercises
• Summary
6. Using the Borland C++ I/O function library
• Understanding I/O Concepts
• Understanding Files and Devices
• Understanding Files and Streams
• Understanding Text and Binary Streams
• Using the Standard Streams for I/O
• Using Formatted I/O Functions
• Understanding scanf()
• Understanding printf()
• Using Character I/O Functions
• Using File Control Functions
• Opening, Closing, and Controlling Files
• The fopen() Function
• The fclose() and fcloseall() Functions
• The tmpfile() and tmpnam() Functions
• The remove() Function
• The rename() Function
• Controlling File Buffers
• The setbuf() Function
• The setvbuf() Function
• Using the Direct File I/O Functions
• Understanding Direct I/O Concepts
• Reading and Writing Direct Files
• Using the File-Positioning Functions
• Obtaining the Current File Position
• Setting a New File Position
• Handling File I/O Errors
• Detecting File I/O Errors
• Displaying and Clearing File I/O Errors
• Exercises
• Summary
7. Using C++ classes
• Comparing Derived Types in C and C++
• Redefining "Derived" in C++
• Understanding C++ Encapsulation
• Declaring Classes with struct
• Declaring C++ Classes
• Understanding the class Declaration
• Using Class Declaration Syntax
• Declaring Class Members
• Building a LIFO Stack Class
• Using the this Pointer
• Using the public, private, and protected Keywords
• Writing Member Functions for a Class
• Associating Member Functions with a Class
• Compiling Member Functions Separately
• Declaring Inline Member Functions
• Specifying Default Arguments for Member Functions
• Providing Constructor and Destructor Functions
• Using Friend Functions
• Including Friend Functions in a Class
• Deciding When to Use a Friend Function
• Exercises
• Summary
8. Creating C++ objects
• Defining C++ Objects
• Assigning Storage Classes to Class Objects
• Defining Arbitrary-Duration Class Objects
• Defining Local (auto) Class Objects
• Defining Global (static) Class Objects
• Initializing Class Objects
• Using Constructors to Initialize Class Objects
• Using Initializer Lists
• Exercises
• Summary
9. Accessing C++ objects
• Using the Scope Resolution Operator
• Using Scope Resolution in General
• Using Scope Resolution for Syntax Control
• Controlling Ambiguities with Scope Resolution
• Understanding the C++ Scope Rules
• Understanding the Difference between C and C++ Scope
• Examining the C++ Scope Rules
• Communicating with C++ Objects
• Sending Messages to Objects
• Understanding the this Pointer
• Using the Reference Operator
• Evolving the Reference Operator from the Address-of Operator
• Understanding the Reference Operator
• Using Objects as Function Parameters
• Passing Objects by Value and by Reference
• Accessing Other Objects from a Member Function
• Using Pointers to Objects
• Understanding When Pointers Are Required
• Declaring Pointers and Arrays of Objects
• Exercises
• Summary
10. Using overloaded functions and operators in C++
• Overloading Member Functions
• Understanding C++ Overloading
• Declaring Overloaded Member Functions
• Overloading Friend and Nonmember Functions
• Overloading Friends of a Class
• Overloading Nonmember Functions
• Understanding Type-Safe Linkages
• Understanding Function Mangling
• Controlling Linkage Problems with Standard C Include Files
• Overloading Operators with C++
• Understanding Operator Overloading
• Declaring Overloaded Operator Functions
• Understanding Overloaded Operator Function Syntax
• Specifying Arguments for Overloaded Operator Functions
• Specifying a Return Type for an Operator Function
• Overloading Binary and Unary Operators
• Overloading the Subscript and Function Call Operators
• Using an Overloaded Subscript Operator
• Using an Overloaded Function Call Operator
• Exercises
• Summary
11. Using C++ constructors and destructors
• Understanding Constructors and Destructor Calls
• Declaring Constructors and Destructors
• Declaring Constructor Functions
• Declaring Destructor Functions
• Using Constructor Initializers
• When Are Constructor Functions Called?
• When Are Destructor Functions Called?
• Overloading Constructor Functions
• Writing a Default Constructor Function
• Writing Other Constructors
• Deciding When You Need a Copy Constructor
• Using the new and delete Operators
• Using new and delete in general
• Dynamically Creating and Deleting Class Objects
• Overloading the new and delete Operators
• Overloading the Global Operators
• Overloading the Operators for a Class
• Exercises
• Summary
12. Using C++ streams
• Introducing C++ Streams
• Comparing C++ Streams to Standard Streams
• Using C++ Streams for Standard I/O
• Handling C++ Stream Errors
• Detecting C++ Streams Error States
• Using the Streams State Member Functions
• Controlling Data Formats with C++ Streams
• Using Inserters and Extractors for Built-in Types
• Overloading the << and >> Operators
• Using C++ Stream Manipulators
• Understanding C++ Manipulators
• Using Manipulators to Change States and Attributes
• Using C++ File I/O Streams
• Reading and Writing fstream Files
• File Positioning with C++ Streams
• Using and Converting Old C++ Streams
• AT&T C++ 3.0
• Difference Between Old and New C++ Streams
• Converting to the New C++ Streams
• Exercises
• Summary
13. Using C++ derived classes
• Reusing Code without Inheritance
• Understanding Code Reusability
• Reusing Code by Composition
• Using Single Base Classes
• Understanding Inheritance
• Declaring Base and Derived Classes
• Using Virtual Functions
• Using Late Binding and Virtual Functions
• using Scope Resolution to Control Member Function Access
• Using Multiple Base Classes
• Deriving from More Than One Base Class
• Declaring and using Virtual Base Classes
• Deriving Classes from Abstract Classes
• Understanding Pure Virtual Functions
• Implementing Pure Virtual Functions
• Using Constructors and Destructors with Inheritance
• Initialization Code Is Not Inherited
• Understanding the Order of Constructor and Destructor Calls with Inheritance
• Exercises
• Summary
14. Object control, performance, and future directions
• User-Defined Type Conversions
• Using Constructors to Convert Types
• Overloading Typecast Operators
• Controlling Object Behavior and Performance
• Using Friend Functions to Boost Efficiency
• Using Friend Functions to Control Object Syntax
• Using the static Storage Class to Avoid Repetitive Instantiation
• Using references and Pointers
• Using Inline Functions to Eliminate Function Calls
• Directions in Class Object Control
• Class and Function Templates
• Exception Handling
• Exercises
• Summary
15. Programming Windows with Borland C++
• Rumors about Windows Programming
• Why Program for Windows?
• Developer Advantage
• Understanding the Windows Programming Environment
• Windows Is a Multitasking Environment
• Windows Is an Object-Oriented Environment
• Windows Resources
• Types of Windows Resources
• Accelerator Keys
• Bitmaps
• Cursors
• Dialog Boxes
• Icons
• Menus
• Strings
• Resource File Types
• Working with resources
• Resources Needed by the fcwin.c Sample Program
• Building FCWIN Resources with Borland's Resource Workshop
• Exercises
• Summary
16. Windows programming tools
• The WinSpector Utility
• Invoking the WinSpector utility
• The Preference Dialog Box
• The Director Option
• The Viewer Option
• The Append New Reports Option
• The Overwrite Previous Report Option
• The System Information Option
• The Summary to AUX Option
• The Post-Mortem Dump Option
• The Stack Frame Data Option
• The User Comments Option
• Interpret the Log File
• The First Line
• The Second Line
• The Disassembly Section
• The Stack Trace Section
• The Registers Sections
• The Message Queue Section
• The Task Section
• The Modules Section
• The USER and GDI Heap Information Section
• The System Information Section
• The WinSight Utility
• Getting Started
• Choosing a View
• Using the Window Tree
• Window Tree Display Format
• Expanding and Collapsing the Window Tree
• Locating a Window
• Spying on Windows
• Working with Classes
• Selecting Traced Messages
• Turbo Debugger for Windows
• Setting Up for Debugging
• Understanding Bugs and Debuggers
• Preparing to Run Turbo Debugger from the IDE
• Using Turbo Debugger
• Running a Program with Turbo Debugger
• Viewing Data
• Using Advanced Debugging Features
• Changing Program Values
• Setting Breakpoints
• Exercises
• Summary
17. Designing Windows applications
• Setting Up the Windows Application Environment
• Understanding Windows Directory Usage
• Learn by Doing: Designing fcwin.c
• Creating Source Files for Windows Applications
• Understanding the Windows Programming Environment
• Creating a Module Definition File
• Designing the Program's Header File
• Creating a Project File for FCWIN
• Exercises
• Summary
18. Writing Windows applications with Borland C++
• Designing Windows Interfaces
• Registering the Window Class
• Setting Up the Main Message Loop
• Writing the WinProc() Function
• Setting Up Callback Functions for Dialog Boxes
• Creating Dialog Box Functions
• Controlling the Dialog Box
• Using MessageBox() for Pop-Up Help and Error Messages
• Spooling Hard Copy to the Windows Print Manager
• Using Dynamic Link Libraries
• Understanding DLLs
• Writing a DLL Application
• Exercises
• Summary
19. Using the ObjectWindows library
• The ObjectWindows Hierarchy
• Module and Application Classes
• Window Classes
• The Class TWindow
• The Frame Windows
• The MDI Windows
• The Decorated Windows
• Document and View Classes
• Control Classes
• The Standard Windows Controls
• The Class TStatic
• The Class TButton
• The Class TEdit
• The Class TCheckBox
• The Class TRadioButton
• The Class TGroupBox
• The Class TListBox
• The Widgets Classes
• The Decoration Classes
• Dialog Box Classes
• The Class TDialog
• Graphic Classes
• Printing Classes
• Miscellaneous Classes
• Responding to Windows Messages
• The Minimal OWL Application
• A Simple Interactive Windows Application
• The CALC1 Calculator Application
• The CALC2 Calculator Application
• The Text Editor Application
• Exercises
• Summary
20. The container classes
• Overview of Container Classes
• The Class Naming Convention
• The Vector Classes
• The Array Classes
• The Double-Linked List Classes
• The Declaration of Array Classes
• The Double-Linked List Classes
• Programming Examples
• The array1.exe Program
• The array2.exe Program
• The array3.exe Program
• The list1.exe Program
• Exercises
• Summary
21. Working with OLE 2.0
• ObjectComponents, ObjectWindows, and OLE
• Types of OLE Applications
• Creating OWL Container Applications
• Running tthe OLECONT1 Application
• Programming the OLECONT1 Application
• The Application Class
• The Frame Window Class
• The Client Window Class
• Running an OLE Application
• Dealing with Dynamic Menus
• Programming Dynamic Menus
• Putting Dynamic menus to Work
• Using Dynamic Menus in an MDI Application
• A Menu for Each Window Type
• Putting MDI Dynamic Window to Work
• Building an OLE Container Application's Menus
• Providing Menu Command Hints
• Cutting, Pasting, and Deleting OLE Objects
• Running the OLECONT2 Application
• Linked Objects
• Programming the OLECONT2 Application
• Loading and Saving OLE Compound Documents
• Running the OLECONT3 Application
• Handling the Save or Save As Command
• Saving an OLE File
• Handling the Open Command
• Handling the New Command
• Exercises
• Summary

1. ASCII table
2. Program listings for the quad class
3. Building DOS applications

A very good primer and reference on the Borland stuff. Outdated today, but it still is pretty good (especially compared to the excrement called MFC).