Using Borland® C++ 4.5

Special Edition

Paul J. Perry, Namir Clement Shammas, Lee Atkinson, Mark Atkinson, Steve Potts, Clayton Walnum

Publisher: Que, 1994, 999 pages

ISBN: 0-7897-0072-7

Keywords: Programming

Last modified: May 1, 2021, 7:54 p.m.

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

    Reviews

    Special Edition Using Borland&reg; C++ 4.5

    Reviewed by Roland Buresund

    Mediocre **** (4 out of 10)

    Last modified: May 21, 2007, 3:23 a.m.

    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).

    Comments

    There are currently no comments

    New Comment

    required

    required (not published)

    optional

    required

    captcha

    required