Enhanced descriptions from Syndetics:

This text focuses on the advanced topics of Visual C++ programming - rapid application development, object-oriented programming and database design. It is designed for readers that have Visual C++ programming experience and are ready to tackle complex enterprise development projects. It provides discussions of software lifecycle models, of issues encountered in RAD such as scheduling, estimating and testing, and overviews of client/server and network development, distribution issues, prototyping applications, as well as profiling and targeting the end user.

Table of contents provided by Syndetics

• Preface (p. xv)
• Part 1 Software Development Life Cycle (p. 1)
• Chapter 1 An Introduction to Rapid Application Development (RAD) with Visual C++ (p. 3)
• Introduction (p. 4)
• The Costs vs. Benefits of RAD (p. 4)
• Avoiding the Pitfalls of RAD (p. 6)
• Picking the Right Tool for the Job (p. 7)
• A Brief History of Visual C++ (p. 10)
• Software Life Cycle Models (p. 11)
• Example Programs (p. 13)
• Chapter 2 Overview of the Visual C++ Environment and Advanced Options (p. 15)
• Introduction (p. 16)
• The Developer Studio Environment (p. 16)
• Project vs. Workspace (p. 16)
• What Is MFC? (p. 17)
• Project Types (p. 17)
• File Types in a C++ Project (p. 20)
• Project Management (p. 21)
• Project Settings (p. 21)
• Linker (p. 25)
• The Tools Menu (p. 26)
• Navigating a Project: The Workspace Window (p. 30)
• Class Wizard (p. 31)
• Custom App Wizard Creation (p. 32)
• Version Control (p. 32)
• New Features in Visual C++ Version 6 (p. 35)
• Chapter 3 Requirements Gathering, Documentation, and Analysis (p. 39)
• Introduction (p. 40)
• Requirements Gathering (p. 40)
• Documentation (p. 40)
• Analysis (p. 43)
• Part 2 Designing Visual C++ Software (p. 49)
• Chapter 4 Systems Architecture vs. Software Architecture (p. 51)
• Introduction (p. 52)
• Systems Architecture: The Big Picture (p. 52)
• Networks (p. 53)
• Client/Server Model (p. 53)
• Distributed Applications (p. 55)
• General Scalability (p. 55)
• Layered Application Development (p. 55)
• Chapter 5 The C/C++ Programming Language (p. 59)
• Introduction (p. 60)
• Data Types (p. 60)
• Declaring Variables (p. 63)
• Rules for Variable Names (p. 63)
• Initializing Variables (p. 64)
• Declaring Constants (p. 65)
• Casting (p. 66)
• The Increment and Decrement Operators (p. 66)
• Bitwise Operators (p. 68)
• One's Complement (p. 70)
• Defining New Type Names (p. 71)
• Pointers (p. 72)
• The addressof Operator (p. 73)
• A Quick Summary of Pointers (p. 74)
• Preprocessor Directives (p. 75)
• The Concatenation Operator ## (p. 77)
• The Charizing Operator #@ (p. 78)
• Arrays (p. 78)
• Multidimensional Arrays (p. 79)
• Initializing Arrays (p. 80)
• Programming with Strings (p. 80)
• Comments (p. 81)
• Control Structures (p. 82)
• Modular Programming--Using Functions (p. 90)
• The Void Return Type (p. 91)
• Passing Parameters--Pass by Value vs. Pass by Reference (p. 93)
• Prototyping (p. 94)
• Variable Scope and Lifetime (p. 96)
• Passing Arrays to Functions (p. 97)
• Passing Arrays as Pointers (p. 99)
• Pointers to Functions (p. 100)
• Function Overloading (p. 101)
• Dynamic Memory Allocation (p. 102)
• Defining Data Types with Structures (p. 103)
• Example: Using Simple Structures (p. 106)
• Programming Structures with Pointers (p. 108)
• Passing Structures to Functions (p. 109)
• Good Programming Practices (p. 115)
• Some Common Mistakes and How to Avoid Them (p. 118)
• Chapter 6 Object-Oriented Design (p. 121)
• Introduction (p. 122)
• Structuring Your Data with Classes (p. 125)
• The Aspects of Object-Oriented Programming (p. 126)
• COM (p. 128)
• Code Reuse vs. Component Reuse (p. 129)
• Existing Methodologies (p. 130)
• Chapter 7 Classes (p. 133)
• Introduction (p. 134)
• Creating a Class (p. 134)
• Data and Function Members (p. 136)
• Public vs. Private Members (p. 137)
• Adding Member Functions to a Class (p. 138)
• Using Inline Functions (p. 140)
• Constructors and Destructors (p. 141)
• Declaring and Using a Class Variable (p. 142)
• Inheritance-Based and Derived Classes (p. 144)
• Building a Derived Class (p. 146)
• Implementing Polymorphism (p. 154)
• Advanced Class Topics (p. 156)
• Chapter 8 Coding Standards (p. 173)
• Introduction (p. 174)
• Creating Coding Standards (p. 175)
• Language Standards (p. 175)
• Naming Conventions (p. 182)
• Commenting Standards (p. 184)
• Code Construction Standards to Enhance Readability (p. 187)
• Enforcing Coding Standards (p. 189)
• Chapter 9 User Interface Design (p. 193)
• Introduction (p. 194)
• The Elements of a Good User Interface (p. 195)
• A Main Window (p. 198)
• Displaying Data in Grid Format (p. 199)
• Displaying Individual Records (p. 201)
• Creating a User Interface with Visual C++ (p. 202)
• Single-Document Interface (SDI) Applications (p. 203)
• Messages and the Class Wizard (p. 209)
• Adding New Code and a Menu Item (p. 213)
• Displaying a Dialog Box to Set the Font (p. 217)
• Creating a Dialog Box (p. 218)
• Closing the Dialog (p. 231)
• Adding a Menu Item for the New Dialog (p. 231)
• Programming with ActiveX Controls (p. 232)
• Adding an ActiveX Control to a Project (p. 233)
• Programming a Control in Code (p. 234)
• User Interface Prototyping (p. 240)
• Chapter 10 Database Design (p. 243)
• Introduction (p. 244)
• Overview of Database Design (p. 244)
• The Elements of a Database (p. 247)
• Organizing Data into Tables (p. 248)
• Data Types in an Access Database (p. 249)
• Indexes (p. 252)
• The Primary Key (p. 253)
• Foreign Keys and Relating Tables (p. 253)
• One-to-Many Relationships (p. 254)
• Queries (p. 255)
• Views (p. 255)
• Stored Procedures (p. 255)
• Normalization (p. 256)
• Denormalizing a Database (p. 261)
• Using the Visual Data Manager (p. 262)
• Adding a Table (p. 263)
• Chapter 11 Data Access (p. 267)
• Introduction (p. 268)
• Flat Files (p. 268)
• Basic File I/O Using C (p. 269)
• Using fstream for File I/O (p. 274)
• Opening a File with fstream (p. 274)
• Closing a File with fstream (p. 275)
• Reading from fstream (p. 276)
• Writing a File with fstream (p. 277)
• Working with Text Strings (p. 278)
• Example: Programming with Flat Files (p. 279)
• Working with Databases (p. 290)
• A Brief Note on Database Options and File Support (p. 291)
• Programming with the ADO Data Control (p. 292)
• Connecting Data Bound Controls (p. 297)
• Programming the ADO Data Control in Code (p. 298)
• Important ADO Data Control Events (p. 305)
• Creating a Database Project (p. 308)
• Programming a Database with DAO (p. 310)
• What Type of Data Access Should You Use--ADO, DAO, or ODBC? (p. 316)
• Structured Query Language (SQL) (p. 316)
• Building Select Queries (p. 317)
• Aliasing (p. 318)
• Restricting the Records Returned with a Where Clause (p. 318)
• Using the Like Operator (p. 320)
• Returning Records that Fall Only within a Certain Range (p. 321)
• Using the IN operator (p. 321)
• Sorting the Records Returned by a Query (p. 322)
• Building More-Complicated Queries with Logical Operators (p. 322)
• Grouping Records (p. 323)
• Editing, Adding, and Deleting Records (p. 324)
• Joining Data from Different Tables (p. 325)
• Multiuser Considerations (p. 326)
• Database Transactions (p. 327)
• Chapter 12 Putting It All Together (p. 329)
• Introduction (p. 330)
• Programming with a Recordset (p. 330)
• Opening a Recordset with SQL (p. 338)
• Part 3 Implementation (p. 341)
• Chapter 13 The Microsoft Foundation Class Library (p. 343)
• Introduction (p. 344)
• Overview of MFC (p. 344)
• Window Classes (p. 347)
• The Application Class (p. 348)
• Using MFC Wizards (p. 349)
• Chapter 14 Advanced Topics--Multithreading, DLLs, ActiveX Controls, and Web Programming (p. 351)
• Threads, Processes, and Asynchronous Program Flow (p. 352)
• Programming with OLE (p. 355)
• Creating a Container (p. 356)
• Creating a Dynamic-Link Library (p. 361)
• ActiveX Controls (p. 373)
• Control Basics (p. 374)
• Example: A Simple MFC ActiveX Control (p. 380)
• Adding Properties to the Control (p. 383)
• Adding Custom Methods (p. 385)
• Adding Events (p. 387)
• Fixing the OnDraw Member Function (p. 388)
• Modifying the About Box and Property Page (p. 390)
• Modifying the Toolbox Icon (p. 392)
• Compiling the Control (p. 392)
• Using the ActiveX Control Test Container (p. 393)
• Testing the Control in a VB App (p. 394)
• Creating an ActiveX Control with ATL (p. 394)
• Adding a Property to an ATL Control (p. 396)
• Adding a Method to an ATL Control (p. 398)
• Internet Programming (p. 399)
• Chapter 15 Debugging (p. 401)
• Introduction (p. 402)
• Setting Breakpoints and Starting the Debug Process (p. 403)
• Stepping through Code (p. 405)
• Using Watch Expressions and Examining the Contents of Variables and Memory (p. 407)
• Error Trapping and Handling Exceptions (p. 412)
• The Try Block (p. 413)
• Part 4 Testing and Distribution of Visual C++ Software (p. 417)
• Chapter 16 Testing Applications (p. 419)
• Introduction (p. 420)
• The Importance of Documenting the Testing Process (p. 421)
• Testing for Proof of Concept (p. 422)
• Unit Testing (p. 422)
• Integration Testing (p. 423)
• System Testing (p. 424)
• Beta Testing (p. 424)
• Regression Testing (p. 426)
• Chapter 17 Distribution of Software (p. 429)
• Identifying the Target Audience (p. 430)
• Creating a Setup Program for the Application (p. 430)
• Determining the Dependencies (p. 431)
• Compiling the Final Version of Your App (p. 432)
• Getting Started with InstallShield (p. 432)
• Specifying the Components (p. 437)
• Other Third-Party Utilities (p. 444)
• Distribution of the Software--Selecting Media (p. 444)
• Patches and Updating Applications (p. 446)
• Appendix Appendix (p. 447)
• Index (p. 449)