Votes given by Wet Water

Contents at a Glance
Introduction ................................................................ 1
Book I: Introducing C++............................................... 7
Chapter 1: Creating a First C++ Program ........................................................................ 9
Chapter 2: Storing Data in C++ ....................................................................................... 29 Chapter 3: Directing Your C++ Program Flow .............................................................. 59
Chapter 4: Dividing Your Work with Functions ........................................................... 83
Chapter 5: Dividing Between Source-Code Files ........................................................ 109
Chapter 6: Referring to Your Data through Pointers ................................................ 123
Chapter 7: Working with Classes ................................................................................. 151
Chapter 8: Using Advanced C++ Features...................................................................187
Book II: Understanding Objects and Classes .............. 223
Chapter 1: Planning and Building Objects..................................................................225
Chapter 2: Describing Your Program with UML ........................................................ 255
Chapter 3: Structuring Your Classes with UML ......................................................... 275
Chapter 4: Demonstrating Behavior with UML .......................................................... 287
Chapter 5: Modeling Your Programs with UML ......................................................... 305 Chapter 6: Building with Design Patterns...................................................................317
Book III: Fixing Problems ......................................... 347
Chapter 1: Dealing with Bugs ....................................................................................... 349 Chapter 2: Debugging a Program ................................................................................. 361
Chapter 3: Stopping and Inspecting Your Code.........................................................373
Chapter 4: Traveling About the Stack ......................................................................... 385
Book IV: Advanced Programming .............................. 395
Chapter 1: Working with Arrays, Pointers, and References.....................................397
Chapter 2: Creating Data Structures ........................................................................... 427
Chapter 3: Constructors, Destructors, and Exceptions............................................449
Chapter 4: Advanced Class Usage ............................................................................... 477
Chapter 5: Creating Classes with Templates.............................................................. 503
Chapter 6: Programming with the Standard Library.................................................535

Book V: Reading and Writing Files............................ 567
Chapter 1: Filing Information with the Streams Library ........................................... 569 Chapter 2: Writing with Output Streams .................................................................... 583 Chapter 3: Reading with Input Streams ...................................................................... 597 Chapter 4: Building Directories and Contents ........................................................... 609 Chapter 5: Streaming Your Own Classes .................................................................... 619
Book VI: Advanced C++ ........................................... 631
Chapter 1: Exploring the Standard Library Further .................................................. 633 Chapter 2: Building Original Templates......................................................................651 Chapter 3: Investigating Boost ..................................................................................... 671 Chapter 4: Boosting up a Step......................................................................................697
Book VII: Building Applications with Microsoft MFC... 713
Chapter 1: Working with the Visual C++ 2008 IDE and Projects .............................. 715 Chapter 2: Creating an MFC Dialog Box Project ........................................................ 731 Chapter 3: Creating an MFC SDI Project ..................................................................... 747 Chapter 4: Using the Visual C++ 2008 Debugger ........................................................ 769 Chapter 5: Analyzing Your Visual C++ 2008 Code...................................................... 779
Appendix A: Automating Your
Programs with Makefiles.......................................... 785
Appendix B: About the CD ........................................ 797 Index ...................................................................... 801
Table of Contents
Introduction ................................................................. 1
No Experience Necessary...............................................................................1 Great for Advanced Folks, Too! ..................................................................... 1 For All Computers ........................................................................................... 2 Conventions ..................................................................................................... 2 Organization ..................................................................................................... 3 Icons Galore ..................................................................................................... 4 What’s Next?..................................................................................................... 5
Book I: Introducing C++ ............................................... 7
Chapter 1: Creating a First C++ Program . . . . . . . . . . . . . . . . . . . . . . . . . .9
Creating a Project ............................................................................................ 9 Understanding projects ...................................................................... 10 Defining your first project................................................................... 10 Building and executing your first application..................................15
Typing the Code............................................................................................. 16 Starting with Main ......................................................................................... 17 Showing Information ..................................................................................... 18
Doing some math ................................................................................. 22
Tabbing your output ........................................................................... 26 Let Your Program Run Away........................................................................ 27
Chapter 2: Storing Data in C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Putting Your Data Places: Variables ........................................................... 30 Creating an integer variable ............................................................... 30 Declaring multiple variables............................................................... 33 Changing values ................................................................................... 33 Setting one variable equal to another...............................................34 Initializing a variable ........................................................................... 35 Creating a great name for yourself .................................................... 36
Manipulating Integer Variables.................................................................... 37 Adding integer variables.....................................................................38 Subtracting integer variables ............................................................. 41 Multiplying integer variables.............................................................. 43 Dividing integer variables...................................................................43
Characters ...................................................................................................... 45 Null character....................................................................................... 46 Nonprintable and other cool characters .......................................... 46

x C++ All-in-One For Dummies, 2nd Edition
Strings ............................................................................................................. 48 Getting a part of a string ..................................................................... 49 Changing part of a string..................................................................... 51 Adding onto a string............................................................................51 Adding two strings............................................................................... 52
Deciding between Conditional Operators .................................................. 52 Telling the Truth with Boolean Variables .................................................. 55 Reading from the Console ............................................................................ 56
Chapter 3: Directing Your C++ Program Flow . . . . . . . . . . . . . . . . . . . . .59
Doing This or Doing That ............................................................................. 60 Evaluating Conditions in C++ ....................................................................... 60 Finding the right C++ operators.........................................................61 Combining multiple evaluations ........................................................ 62 Including Evaluations in C++ Conditional Statements .............................. 63 Deciding what if and also what else .................................................. 64 Going further with the else and if ...................................................... 65 Repeating Actions with Statements That Loop ......................................... 67 Looping situations ............................................................................... 67 Looping for ........................................................................................... 68 Looping while ....................................................................................... 74 Doing while ........................................................................................... 77 Breaking and continuing ..................................................................... 77 Nesting loops........................................................................................ 79
Chapter 4: Dividing Your Work with Functions . . . . . . . . . . . . . . . . . . .83
Dividing Your Work.......................................................................................83 Calling a Function .......................................................................................... 88 Passing a variable ................................................................................ 89 Passing multiple variables..................................................................90 Writing Your Own Functions........................................................................ 91 Multiple parameters or no parameters............................................. 95 Returning nothing................................................................................97 Keeping your variables local..............................................................98 Forward references and function prototypes ................................ 100 Writing two versions of the same function..................................... 101 Calling All String Functions ........................................................................ 103 Understanding main....................................................................................105
Chapter 5: Dividing Between Source-Code Files. . . . . . . . . . . . . . . . .109
Creating Multiple Source Files ................................................................... 109 Multiple source files in CodeBlocks ................................................ 110 Multiple source files in other compilers.........................................112 Creating multiple files ....................................................................... 113

Table of Contents xi
Sharing with Header Files...........................................................................115 Adding the header only once ........................................................... 118 Using brackets or quotes..................................................................118
Sharing Variables Among Source Files ..................................................... 119 Using the Mysterious Header Wrappers .................................................. 121
Chapter 6: Referring to Your Data through Pointers . . . . . . . . . . . . . .123
Heaping and Stacking the Variables.......................................................... 124 Getting a variable’s address ............................................................. 127 Changing a variable by using a pointer........................................... 129 Pointing at a string............................................................................. 131 Pointing to something else ............................................................... 133 Tips on pointer variables.................................................................. 134
Dynamically Allocating with new .............................................................. 135 Using new............................................................................................ 135 Using an initializer ............................................................................. 137 Making new strings............................................................................138
Freeing Pointers...........................................................................................139 Passing Pointer Variables to Functions....................................................141 Changing variable values with pointers.......................................... 141 Modifying string parameters............................................................144 Returning Pointer Variables from Functions ........................................... 145 Returning a Pointer as a Nonpointer ........................................................ 148 Passing by Reference .................................................................................. 149 Remembering the Rules..............................................................................150
Chapter 7: Working with Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151
Understanding Objects and Classes ......................................................... 151 Classifying classes and objects........................................................153 Describing member functions and data.......................................... 154 Implementing a class.........................................................................156 Separating member function code .................................................. 160 The parts of a class............................................................................ 163
Working with a Class...................................................................................164 Accessing members........................................................................... 164 Using classes and pointers ............................................................... 167 Passing objects to functions............................................................. 170 Using const parameters in functions .............................................. 172 Using the this pointer........................................................................ 173 Overloading member functions ....................................................... 175
Starting and Ending with Constructors and Destructors ....................... 178 Starting with constructors................................................................ 178 Ending with destructors ................................................................... 178 Sampling constructors and destructors ......................................... 179 Adding parameters to constructors................................................181

xii C++ All-in-One For Dummies, 2nd Edition
Building Hierarchies of Classes ................................................................. 182 Creating a hierarchy in C++ .............................................................. 183 Understanding types of inheritance................................................184
Chapter 8: Using Advanced C++ Features . . . . . . . . . . . . . . . . . . . . . . .187
Filling Your Code with Comments.............................................................187 Converting Types ........................................................................................ 189 Reading from the Console .......................................................................... 195 Understanding Preprocessor Directives .................................................. 199 Using Constants ........................................................................................... 207 Using Switch Statements ............................................................................ 209 Supercharging enums with Classes........................................................... 212 Working with Random Numbers ............................................................... 215 Storing Data in Arrays.................................................................................216
Declaring and accessing an array....................................................217 Arrays of pointers..............................................................................218 Passing arrays to functions .............................................................. 219 Adding and subtracting pointers.....................................................221
Book II: Understanding Objects and Classes ............... 223
Chapter 1: Planning and Building Objects. . . . . . . . . . . . . . . . . . . . . . .225
Recognizing Objects....................................................................................225 Observing the mailboxes class ........................................................ 227 Observing the mailbox class ............................................................ 229 Finding other objects ........................................................................ 230
Encapsulating Objects ................................................................................ 230 Building Hierarchies.................................................................................... 236 Establishing a hierarchy ................................................................... 236 Protecting members when inheriting.............................................. 238 Overriding member functions..........................................................243 Specializing with polymorphism...................................................... 245 Getting abstract about things .......................................................... 247 Discovering Classes..................................................................................... 248 Engineering your software................................................................ 249 Finding those pesky classes ............................................................. 252
Chapter 2: Describing Your Program with UML . . . . . . . . . . . . . . . . . .255
Moving Up to UML.......................................................................................255 Modeling with UML............................................................................ 259 Diagramming and designing with UML ........................................... 259
Building with UML and the Unified Process.............................................264 Speaking iteratively ........................................................................... 266 Phasing in and out ............................................................................. 267

Table of Contents xiii
The inception phase..........................................................................269 The elaboration phase ...................................................................... 270 The construction phase....................................................................271 The transition phase ......................................................................... 272
Moving Forward with UML ......................................................................... 273
Chapter 3: Structuring Your Classes with UML . . . . . . . . . . . . . . . . . .275
Drawing Classes...........................................................................................276 Mapping classes with UML ............................................................... 277 Inheriting in UML ............................................................................... 280 Aggregating and composing classes ............................................... 281
Building Components.................................................................................. 282 Deploying the Software...............................................................................285
Chapter 4: Demonstrating Behavior with UML . . . . . . . . . . . . . . . . . . .287
Drawing Objects .......................................................................................... 287 Casing Out the Use Cases ........................................................................... 289 Expanding use cases.......................................................................... 291 Matching use cases and requirements ........................................... 292 Sequence Diagrams ..................................................................................... 293 Notating sequence diagrams............................................................295 Looping and comparing in sequence diagrams ............................. 296 Collaboration Diagrams .............................................................................. 299 Activity Diagrams ........................................................................................ 300 State Diagrams ............................................................................................. 302
Chapter 5: Modeling Your Programs with UML . . . . . . . . . . . . . . . . . .305
Using UML Goodies ..................................................................................... 305 Packaging your symbols ................................................................... 305 Notating your diagrams .................................................................... 308 Tagging your symbols ....................................................................... 308
Free to Be UML............................................................................................. 309 C++ and UML ................................................................................................ 312 Drawing enumerations ...................................................................... 312 Including static members ................................................................. 312 Parameterizing classes with templates........................................... 314
Chapter 6: Building with Design Patterns . . . . . . . . . . . . . . . . . . . . . . .317
Introducing a Simple Pattern: the Singleton ............................................ 318 Watching an Instance with an Observer................................................... 322 Observers and the Standard C++ Library ....................................... 326 Automatically adding an observer .................................................. 327 Mediating with a Pattern ............................................................................ 330

xiv C++ All-in-One For Dummies, 2nd Edition
Book III: Fixing Problems .......................................... 347
Chapter 1: Dealing with Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .349
It’s Not a Bug, It’s a Feature!.......................................................................349 Make Your Programming Features Look Like Features..........................351 Anticipating (Almost) Everything.............................................................. 352 Avoiding Mistakes, Plain and Simple ........................................................ 359
Chapter 2: Debugging a Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361
Programming with Debuggers ................................................................... 361 Running the debugger ....................................................................... 363 Recognizing the parts of the CodeBlocks debugger...................... 369
Debugging with Different Tools ................................................................. 371 Standard debuggers........................................................................... 371
Chapter 3: Stopping and Inspecting Your Code . . . . . . . . . . . . . . . . . .373
Setting and Disabling Breakpoints ............................................................ 374 Setting a breakpoint in CodeBlocks................................................. 375 Enabling and disabling breakpoints ................................................ 376
Watching, Inspecting, and Changing Variables ....................................... 378 Watching the local variables ............................................................ 380 Watching other variables.................................................................. 382
Chapter 4: Traveling About the Stack. . . . . . . . . . . . . . . . . . . . . . . . . . .385
Stacking Your Data ...................................................................................... 385 Moving about the stack..................................................................... 386 Storing local variables....................................................................... 388
Debugging with Advanced Features.......................................................... 390 Viewing threads ................................................................................. 390 Tracing through assembly code ...................................................... 391
Book IV: Advanced Programming............................... 395
Chapter 1: Working with Arrays, Pointers, and References . . . . . . .397
Building Up Arrays ...................................................................................... 397 Declaring arrays.................................................................................398 Arrays and pointers........................................................................... 400 Using multidimensional arrays ........................................................ 403 Arrays and command-line parameters............................................ 406 Allocating an array on the heap....................................................... 407 Storing arrays of pointers and arrays of arrays.............................409 Building constant arrays................................................................... 411
Table of Contents xv
Pointing with Pointers ................................................................................ 413 Becoming horribly complex ............................................................. 413 Pointers to functions.........................................................................418 Pointing a variable to a member function ...................................... 419 Pointing to static member functions...............................................422
Referring to References .............................................................................. 422 Reference variables ........................................................................... 423 Returning a reference from a function............................................424
Chapter 2: Creating Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . .427
Working with Data ....................................................................................... 427 The great variable roundup.............................................................. 427 Expressing variables from either side............................................. 429 Casting a spell on your data ............................................................. 431 Casting safely with C++ ..................................................................... 433 Dynamically casting with dynamic_cast......................................... 433 Statically casting with static_cast.................................................... 437
Structuring Your Data ................................................................................. 438 Structures as component data types .............................................. 439 Equating structures ........................................................................... 440 Returning compound data types ..................................................... 441
Naming Your Space ..................................................................................... 442 Using variables and part of a namespace.......................................445
Chapter 3: Constructors, Destructors, and Exceptions . . . . . . . . . . . .449
Constructing and Destructing Objects ..................................................... 449 Overloading constructors................................................................. 450 Initializing members .......................................................................... 451 Adding a default constructor ........................................................... 455 Functional constructors.................................................................... 458 Calling one constructor from another ............................................ 460 Copying instances with copy constructors.................................... 461 When constructors go bad: failable constructors? ....................... 464 Destroying your instances................................................................465 Virtually inheriting destructors ....................................................... 466
Programming the Exceptions to the Rule................................................. 469 Throwing direct instances................................................................472 Catching any exception..................................................................... 473 Rethrowing an exception..................................................................474
Chapter 4: Advanced Class Usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . .477
Inherently Inheriting Correctly..................................................................477 Morphing your inheritance............................................................... 477 Adjusting access ................................................................................ 480 Returning something different, virtually speaking ........................ 482 Multiple inheritance .......................................................................... 486

xvi C++ All-in-One For Dummies, 2nd Edition
Virtual inheritance.............................................................................489
Friend classes and functions............................................................492 Using Classes and Types within Classes .................................................. 493 Nesting a class.................................................................................... 494 Types within classes ......................................................................... 499
Chapter 5: Creating Classes with Templates . . . . . . . . . . . . . . . . . . . .503
Templatizing a Class ................................................................................... 503 Separating a template from the function code............................... 510 Including static members in a template.......................................... 512
Parameterizing a Template ........................................................................ 514 Putting different types in the parameter ........................................ 514 Including multiple parameters.........................................................518
Typedefing a Template ............................................................................... 521 Deriving Templates ..................................................................................... 522 Deriving classes from a class template...........................................522 Deriving a class template from a class............................................524 Deriving a class template from a class template ........................... 525 Templatizing a Function ............................................................................. 528 Overloading and function templates...............................................530 Templatizing a member function.....................................................533
Chapter 6: Programming with the Standard Library . . . . . . . . . . . . . .535
Architecting the Standard Library ............................................................ 536 Containing Your Classes.............................................................................536 Storing in a vector.............................................................................. 536 Mapping your data............................................................................. 538 Containing instances, pointers, or references ............................... 539 Comparing instances.........................................................................543 Iterating through a container ........................................................... 547 A map of pairs in your hand.............................................................551 The Great Container Showdown................................................................ 551 Associating and storing with a set................................................... 552 Unionizing and intersecting sets...................................................... 554 Listing with list...................................................................................557 Stacking the deque ............................................................................ 561 Waiting in line with stacks and queues...........................................562 Copying Containers.....................................................................................564
Book V: Reading and Writing Files ............................ 567
Chapter 1: Filing Information with the Streams Library . . . . . . . . . . .569
Seeing a Need for Streams..........................................................................570 Programming with the Streams Library ................................................... 571 Getting the right header file ............................................................. 572 Opening a file...................................................................................... 573

Table of Contents xvii
Handling Errors When Opening a File....................................................... 576 Flagging the ios Flags .................................................................................. 578
Chapter 2: Writing with Output Streams . . . . . . . . . . . . . . . . . . . . . . . .583
Inserting with the << Operator................................................................... 583 Formatting Your Output ............................................................................. 585 Formatting with flags......................................................................... 586 Specifying a precision ....................................................................... 590 Setting the width and creating fields............................................... 592
Chapter 3: Reading with Input Streams . . . . . . . . . . . . . . . . . . . . . . . . .597
Extracting with Operators..........................................................................597 Encountering the End of File......................................................................599 Reading Various Types ............................................................................... 604 Reading Formatted Input............................................................................607
Chapter 4: Building Directories and Contents . . . . . . . . . . . . . . . . . . .609
Manipulating Directories ............................................................................ 610 Creating a directory........................................................................... 610 Deleting a directory...........................................................................611
Getting the Contents of a Directory .......................................................... 611 Copying Files ................................................................................................ 614 Moving and Renaming Files and Directories............................................ 616
Chapter 5: Streaming Your Own Classes . . . . . . . . . . . . . . . . . . . . . . . .619
Streaming a Class for Text Formatting ..................................................... 620 Manipulating a Stream ................................................................................ 623 What’s a manipulator? ...................................................................... 623 Writing your own manipulator......................................................... 626
Book VI: Advanced C++............................................ 631
Chapter 1: Exploring the Standard Library Further. . . . . . . . . . . . . . . .633
Considering the Standard Library Categories ......................................... 634 Containers ........................................................................................... 635 Iterators............................................................................................... 635 Algorithms .......................................................................................... 636 Functors .............................................................................................. 637 Utilities ................................................................................................ 639 Adaptors ............................................................................................. 639 Allocators ............................................................................................ 639
Parsing Strings Using a Hash...................................................................... 640 Obtaining Information Using a Random Access Iterator........................643 Locating Values Using the Find Algorithm ............................................... 645 Using the Random Number Generator...................................................... 647

xviii C++ All-in-One For Dummies, 2nd Edition
Performing Comparisons Using min and max ......................................... 648 Working with Temporary Buffers..............................................................649
Chapter 2: Building Original Templates. . . . . . . . . . . . . . . . . . . . . . . . .651
Deciding When to Create a Template ....................................................... 652 Defining the Elements of a Good Template .............................................. 653 Creating a Basic Math Template................................................................ 655 Building a Structure Template...................................................................656 Developing a Class Template ..................................................................... 659 Considering Template Specialization ....................................................... 662 Creating a Template Library ...................................................................... 664
Defining the library project .............................................................. 664 Configuring the library project ........................................................ 666 Coding the library..............................................................................667
Using Your Template Library..................................................................... 669
Chapter 3: Investigating Boost. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .671
Understanding Boost .................................................................................. 672 Boost features .................................................................................... 672 Licensing ............................................................................................. 673 Paid support ....................................................................................... 673
Obtaining and Installing Boost for CodeBlocks.......................................673 Unpacking Boost ................................................................................ 674 Building the libraries.........................................................................675 Building the Boost tools.................................................................... 678
Using Boost Jam........................................................................................... 680 Using Boost Build ........................................................................................ 682 Using Regression ......................................................................................... 685 Using Inspect................................................................................................685 Understanding BoostBook ......................................................................... 687 Using QuickBook.......................................................................................... 689 Using bcp ...................................................................................................... 690 Using Wave ................................................................................................... 692 Building Your First Boost Application Using Date Time ........................ 693
Chapter 4: Boosting up a Step . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .697
Parsing Strings Using RegEx....................................................................... 698 Adding the RegEx library .................................................................. 699 Creating the RegEx code...................................................................700
Breaking Strings into Tokens Using Tokenizer........................................702 Performing Numeric Conversion...............................................................703 Creating Improved Loops Using Foreach ................................................. 706 Accessing the Operating System Using Filesystem................................. 708

Table of Contents xix
Book VII: Building Applications with Microsoft MFC... 713
Chapter 1: Working with the Visual C++ 2008 IDE and Projects . . . .715
Understanding the Project Types.............................................................. 716 Creating a New Win32 Console Application.............................................717 Defining the project ........................................................................... 717 Adding code........................................................................................ 719 Running the application....................................................................720 Writing Code Faster..................................................................................... 721 Obtaining coding help.......................................................................721 Working with IntelliSense ................................................................. 722 Viewing Your Project in Solution Explorer .............................................. 723 Using the Standard Toolbars ..................................................................... 724 Changing Application Properties .............................................................. 725 Modifying the IDE Appearance .................................................................. 726 Changing toolbars and menus.......................................................... 726 Modifying windows............................................................................ 728
Chapter 2: Creating an MFC Dialog Box Project . . . . . . . . . . . . . . . . .731
Understanding the MFC Dialog Box Project.............................................731 Creating the MFC Dialog Box Project........................................................732 Adding Components and Controls ............................................................ 738
Adding the component or control...................................................738 Creating variables to use in your code ........................................... 741 Defining methods to react to control events ................................. 742
Defining the Dialog Box Code..................................................................... 743 Understanding the Essential Windows ..................................................... 745 Working with Class View................................................................... 745 Modifying the Toolbox......................................................................746
Chapter 3: Creating an MFC SDI Project . . . . . . . . . . . . . . . . . . . . . . . .747
Understanding the MFC SDI Project..........................................................747 Creating the MFC SDI Project.....................................................................749 Understanding the Document/View Architecture...................................756 Adding Code to Your SDI Project .............................................................. 757
An overview of the essential application files................................ 757 Locating Microsoft specified suggested changes .......................... 759 Making resource changes ................................................................. 760 Considering the help file...................................................................763 Registering and unregistering the application............................... 765
Seeing the Text Editor Project in Action .................................................. 766
xx C++ All-in-One For Dummies, 2nd Edition
Chapter 4: Using the Visual C++ 2008 Debugger. . . . . . . . . . . . . . . . . .769
A Quick Look at the Error Application ..................................................... 770 Starting Your Application in Debugging Mode ........................................ 771 Creating the proper build ................................................................. 772 Setting breakpoints............................................................................ 772 Viewing your breakpoints................................................................. 774 Starting the debugger........................................................................775 Working with the Debugging Windows..................................................... 775 Viewing the focus variables using the Autos window...................775
Viewing all of the variables in a method
using the Locals window...............................................................777
Screening specific variables using the Watch 1 window .............. 777 Working with the Call Stack window...............................................778
Chapter 5: Analyzing Your Visual C++ 2008 Code. . . . . . . . . . . . . . . . .779
Using Performance Wizard.........................................................................779 Profiling the Code ........................................................................................ 781
Appendix A: Automating Your
Programs with Makefiles........................................... 785
Compiling and Linking ................................................................................ 785 Automating Your Work ............................................................................... 787 Implying with Inference Rules.................................................................... 788
Using rules that depend on other rules .......................................... 790 Making specific items ........................................................................ 791 Depending on multiple files..............................................................791 Compiling and linking with make..................................................... 793 Cleaning up and making it all ........................................................... 793 Using macros......................................................................................794 Getting the most out of Makefiles....................................................795
Appendix B: About the CD......................................... 797
System Requirements ................................................................................. 797 Using the CD ................................................................................................ 798 What You’ll Find on the CD ........................................................................ 798
CodeBlocks Compiler........................................................................799
Author-created material ................................................................... 799 Troubleshooting .......................................................................................... 799 Customer Care ............................................................................................. 800
Index ....................................................................... 801