Microsoft Visual C++ .Net Step by Step : Version 2003

by Templeman, Julian; Olsen, Andy

• ISBN13: 9780735619074
• ISBN10: 0735619077
• Edition: CD
• Format: Paperback
• Copyright: 2003-04-23
• Publisher: Microsoft Pr

Summary

Description: 25-Word Description Teach yourself Visual C++ .NET version 2003--and begin developing Microsoft .NET-connected applications--one step at a time. Master core skills with step-by-step lessons and challenge yourself with simple to complex coding problems. 75-Word Description Teach yourself Visual C++ .NET version 2003--and begin developing applications and services for Microsoft .NET--one step at a time. This practical, hands-on tutorial expertly guides you through the fundamentals--from writing managed code to running and debugging your first .NET-ready programs. Work at your own pace through easy-to-follow lessons and hands-on exercises to learn essential techniques. And accelerate your productivity by working with instructive code and best development practices for Visual C++ .NET version 2003. Topics include inheritance and object-oriented programming (OOP) techniques, debugging, exception handling, operator overloading, the .NET Framework version 1.1, integration with Microsoft Windows(R) .NET Server 2003, Windows Forms, Web services, ATL, data access with XML and Microsoft ADO.NET, migrating legacy applications, and more. The authors are highly respected C++ programmers, trainers, and consultants who know how to quickly advance your expertise. Positioning Statement: Your hands-on, self-study guide for building applications and services with Visual C++ .NET version 2003

Author Biography

John Sharp is a principal technologist at Content Master Ltd. Jon Jagger is a technology specialist for Content Master Ltd.

Table of Contents

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