--------------------------------------------------------------------------------
Introduction xv
PART 1
GETTING STARTED WITH C++ .NET
CHAPTER 1 Hello, C++! 3
What Is a C++ Program?
3
C++ is a strongly typed language.
3
C++ is an efficient language.
4
C++ is an object-oriented language.
4
C++ is based on C (as you might suspect).
4
C++ is a case-sensitive language.
4
Your First C++ Program
4
The main Function
6
C++ Keywords and Identifiers
7
Creating an Executable Program--Theory
8
Editing the Program Source Files
8
Compiling the Source Files
8
Linking the Object Files
8
Running and Testing the Program
9
Creating an Executable Program--Practice
9
Adding a C++ Source File to the Project
11
Adding C++ Code to the Source File
12
Building the Executable
12
Executing the Program
13
Conclusion
14
CHAPTER 2 Introducing Object-Oriented Programming
15
What Is Object-Oriented Programming?
15
Features of Object-Oriented Programming Languages
16
Encapsulation
16
Inheritance
17
Polymorphism
18
Classes and Objects
19
Benefits to the Developmental Life Cycle
19
A Simple Example
20
CHAPTER 3 Variables and Operators
27
What Is a Variable?
27
The Fundamental Data Types
28
Declaring a Variable
29
Variable Naming
30
Declaring Multiple Variables
30
Assigning Values to Variables
30
Arrays
31
Pointers
32
References
33
Constants
33
Enumerations
34
Typedefs
35
Adding Member Variables to Classes
35
The .NET Framework String Class
36
Operators and Expressions
37
Assignment Operators
37
Arithmetic Operators
37
Relational and Logical Operators
39
Bitwise Operators
40
The Ternary Operator
40
The sizeof Operator
41
Type Casting
41
Operator Precedence and Associativity
41
CHAPTER 4 Using Functions
45
Declaring Function Prototypes
46
Declaring a Simple Function Prototype
46
Declaring Parameters in a Function Prototype
47
Declaring the Return Type in a Function Prototype
48
Declaring Default Values for Function Parameters
48
Defining Function Bodies
49
Defining a Simple Function Body
49
Defining a Function Body That Uses Parameters
50
Defining a Function Body That Returns a Value
52
Calling Functions
53
Calling Functions in the Sample Application
54
Stepping Through the Application with the Debugger
56
Understanding Local and Global Scope
59
Overloading Functions 61
CHAPTER 5 Decision and Loop Statements
65
Making Decisions with the if Statement
65
Performing One-Way Tests
65
Performing Two-Way Tests
69
Performing Multiway Tests
70
Performing Nested Tests
72
Making Decisions with the switch Statement
74
Defining Simple switch Statements
74
Defining Fall-Through in a switch Statement
76
Using Fall-Through in a switch Statement
76
Performing Loops
77
Using while Loops
77
Using for Loops
79
Using do-while Loops
81
Performing Unconditional Jumps
83
PART 2
MORE ABOUT OBJECT-ORIENTED PROGRAMMING
CHAPTER 6 More About Classes and Objects
89
Organizing Classes into Header Files and Source Files
90
Defining a Class in a Header File
92
Implementing a Class in a Source File
93
Creating and Destroying Objects
95
Defining Constructors and Destructors
97
Defining Constructors
97
Defining Destructors
99
Defining Class-Wide Members
101
Defining Class-Wide Data Members
103
Defining Class-Wide Member Functions
105
Defining Object Relationships
107
Defining the LoyaltyScheme Class
108
Implementing the LoyaltyScheme Class
108
Creating, Using, and Destroying LoyaltyScheme Objects
110
Testing the Application
112
CHAPTER 7 Controlling Object Lifetimes
117
Traditional C++ Memory Management
117
Creating Objects
117
Deleting Objects
118
Advantages and Disadvantages of Manual Memory Allocation
118
The .NET Approach
120
Finalizers
121
Implementing a Finalizer
123
A Few Points About Finalize
124
Using a Dispose Method
124
Integrating Finalize and Dispose
126
CHAPTER 8 Inheritance
129
Designing an Inheritance Hierarchy
130
Defining a Base Class
131
Defining a Derived Class
133
Accessing Members of the Base Class
135
Creating Objects
138
Overriding Member Functions
140
Defining Sealed Classes
144
Defining and Using Interfaces
144
PART 3
MICROSOFT .NET PROGRAMMING BASICS
CHAPTER 9 Value Types
151
Reference Types and Value Types
151
The Need for Value Types
152
Properties of Value Types
153
Structures
153
Creating and Using a Simple Struct
154
Investigating the Structure
155
Differences Between Structures and Classes
156
Implementing Constructors for a Struct
157
Using One Struct Inside Another
157
Copying Structs
160
Enumerations
160
Creating and Using an Enum
161
Using Enums in Programs
162
Avoiding Ambiguity
163
Using Memory Efficiently
163
CHAPTER 10 Operator Overloading
165
What Is Operator Overloading?
165
What Types Need Overloaded Operators?
166
What Can You Overload?
166
Rules of Overloading
167
Overloading Operators in Managed Types
167
Overloading Value Types
167
Overloading Operator Functions
171
Implementing Logical Operators and Equality
173
Implementing Equals
175
Implementing Assignment
177
Implementing Increment and Decrement
179
Overloading Reference Types
180
Calling Overloaded Operators for Reference Types
181
Guidelines for Providing Overloaded Operators
181
CHAPTER 11 Exception Handling
183
What Are Exceptions?
183
How Do Exceptions Work?
185
Exception Types
186
Throwing Exceptions
186
Handling Exceptions
189
Using the try and catch Construct
189
Customizing Exception Handling
191
Using the Exception Hierarchy
192
Using Exceptions with Constructors
193
Nesting and Rethrowing Exceptions
194
The ----finally Block
196
The catch(--) Block
197
Creating Your Own Exception Types
198
Using ----value Classes
200
Using ----try--cast for Dynamic Casting
201
Using Exceptions Across Languages
202
CHAPTER 12 Arrays and Collections
207
Native C++ Arrays
207
Passing Arrays to Functions
210
Initializing Arrays
212
Multidimensional Arrays
212
Dynamic Allocation and Arrays
213
----gc Arrays
215
Using the ----gc and ----nogc Keywords
216
Arrays and Reference Types
216
Multidimensional ----gc Arrays
217
The .NET Array Class
218
Basic Operations on Arrays
219
More Advanced Array Operations
221
Enumerators
224
Other .NET Collection Classes
225
The ArrayList Class
226
Other ArrayList Operations
228
The SortedList Class
228
Other SortedList Operations
230
The StringCollection Class
230
CHAPTER 13 Properties
233
What Are Properties?
233
The Two Kinds of Properties
234
Implementing Scalar Properties
235
Errors in Properties
236
Read-Only and Write-Only Properties
237
Implementing Indexed Properties
239
The Bank Example
239
Implementing the Bank Class
239
Adding the Account Class
242
Creating Account Class Properties
243
Adding Accounts to the Bank Class
244
Implementing the Add and Remove Methods
244
Implementing an Indexed Property to Retrieve Accounts
245
CHAPTER 14 Delegates and Events
249
What Are Delegates?
249
What Do Delegates Do?
250
Defining Delegates
251
Implementing Delegates
251
Calling Static Member Functions Using Delegates
252
Calling Non-Static Member Functions Using Delegates
253
Using Multicast Delegates
253
What Are Events?
257
Implementing an Event Source Class
258
Implementing an Event Receiver
259
Hooking It All Together
261
PART 4
USING THE .NET FRAMEWORK
CHAPTER 15 The .NET Framework Class Library 267
What Is the .NET Framework?
267
The Common Language Runtime 268
Intermediate Language 268
The Common Type System 269
The Common Language Specification 269
The .NET Framework Class Library 269
Assemblies 270
Metadata 271
The .NET Framework Namespaces 273
Using Namespaces in C++ Programs 274
The System Namespace 275
The Collections Namespaces 277
The Collections Interfaces 278
The Diagnostics Namespace 278
The IO Namespace 279
The Drawing Namespaces 280
The Forms Namespace 280
The Net Namespaces 281
The Xml Namespaces 282
The Data Namespaces 282
The Web Namespaces 283
CHAPTER 16 Introducing Windows Forms 285
Windows Forms Applications 286
Windows Forms and Designers 286
Windows Forms vs. MFC 287
A Word About ATL 288
The System::Windows::Forms Namespace 288
Creating and Using Forms 289
Creating a Simple Form 289
Using Form Properties 291
Form Relationships 296
Placing Controls on the Form 297
Handling Events 298
Using Controls 300
Label 301
Button
303
CheckBox and RadioButton
304
Using Radio Buttons as a Group 305
ListBox and ComboBox
305
TextBox
310
Using Menus 314
More About Menus 317
Displaying a Context Menu 317
CHAPTER 17 Dialog Boxes and Controls
319
Using Dialog Boxes
319
The DialogResult Property
323
Using Data with Dialog Boxes
324
Setting Tab Ordering
327
Using Common Dialog Boxes
327
More About Controls
329
Using the TreeView Control
331
Adding Directory Browsing
335
Using the ListView Control
340
Displaying Directory Details
343
Using Splitters 347
Using Toolbars
348
Using Status Bars
353
CHAPTER 18 Graphical Output
357
Graphics with GDI+
357
The System::Drawing Namespaces
358
The Graphics Class
359
Creating Graphics Objects
359
Drawing Objects
360
Standard Pens and Brushes
361
Drawing Operations
361
Paint Events
365
Using Color
368
Using Fonts
369
Handling Images
372
Printing
373
CHAPTER 19 Working with Files
379
The System::IO Namespace
379
Text I/O Using Readers and Writers
381
Using TextWriter
381
The FileStream Class
383
Using TextReader
385
Working with Files and Directories
387
Getting Information About Files and Directories
387
Binary I/O
396
The BinaryWriter Class
396
The BinaryReader Class
397
PART 5
DATA ACCESS
CHAPTER 20 Reading and Writing XML
405
XML and .NET
405
The .NET XML Namespaces
406
The XML Processing Classes
406
Parsing XML with XmlTextReader
407
Verifying Well-Formed XML
413
Handling Attributes
414
Parsing XML with Validation
414
Writing XML Using XmlTextWriter
419
Using XmlDocument
424
The XmlNode Class
427
CHAPTER 21 Transforming XML
435
Using XSL to Transform XML
435
Using XPath
437
The XPathNavigator Class
437
Using XPathNavigator
439
Using XPath with XPathNavigator
442
Using XSL
444
CHAPTER 22 Using ADO.NET
451
What Is ADO.NET?
452
ADO.NET Data Providers
452
ADO.NET Namespaces
452
ADO.NET Assemblies
453
Creating a Connected Application
454
Connecting to a Database
454
Creating and Executing a Command
456
Executing a Command That Modifies Data
457
Executing Queries and Processing the Results
458
Creating a Disconnected Application
459
Creating the Form
461
Creating and Configuring the Data Adapter
462
Creating and Filling the DataSet
465
PART 6 CREATING DISTRIBUTED APPLICATIONS
CHAPTER 23 Building a Web Service
471
What Are Web Services?
471
A Web Service Scenario
472
Web Services and the Future
472
Web Service Architecture
473
Data Formats and Protocols
473
Web Service Description
474
Web Service Discovery
474
The Web Services Namespaces
475
Creating a Simple Web Service
476
Using the Web Service from a Browser
479
Using the Web Service from Code
480
Debugging Web Services
484
If You're Not Using Visual Studio .NET
484
CHAPTER 24 Introduction to ATL Server
487
What Is ATL Server?
487
Coding with ATL Server
489
Creating Web-Based Applications Using ATL Server
490
ATL Server Architecture
490
More About Server Response Files
492
Writing a Web Application Using ATL Server
493
Using the Web Application from a Browser
497
Creating Web Services Using ATL
497
Writing a Web Service in ATL
497
Creating the Code Skeleton
497
Modifying the Interface
498
Providing the Implementation
500
Using ATL Server
502
PART 7 ADVANCED TOPICS
CHAPTER 25 Working with Unmanaged Code
507
Managed vs. Unmanaged Code
507
Mixed Classes
508
GCHandle
509
Pinning and Boxing
511
Pinning Pointers 512
Boxing and Unboxing
513
Boxing
513
Unboxing
514
Using PInvoke to Call Functions in the Win32 API
517
The DllImportAttribute Class
520
Passing Structures
522
CHAPTER 26 Attributes and Reflection
527
Metadata and Attributes
527
Using Predefined Attributes
530
The AssemblyInfo.cpp File
530
Using the Predefined Attribute Classes
531
Defining Your Own Attributes
536
Attribute Class Properties
537
Design Criteria for Attribute Classes
538
Writing a Custom Attribute
538
Using Reflection to Get Attribute Data
542
The Type Class
542
Accessing Standard Attributes
544
Accessing Custom Attribute Data
545
CHAPTER 27 Living with COM
549
COM Components and COM Interop
549
Using COM Components from .NET Code
550
How Do RCWs Work?
550
Creating and Using RCWs
552
Handling COM Errors
554
Late Binding to COM Objects
555
Using ActiveX Controls in Windows Forms Projects
557
Calling Control Methods
559
Using .NET Components as COM Components
560
What must .NET types implement to be used as COM objects?
561
INDEX 563
