Microsoft® Visual C++® .NET Step by Step--Version 2003 (Step by Step (Microsoft)) [Paperback]

Julian Templeman (Author), Andy Olsen (Author)

Book Description

Series: Step by Step (Microsoft) | Publication Date: April 23, 2003

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

Editorial Reviews

About the Author

As a professional consultant, trainer, and writer, Julian Templeman has been involved in using, teaching, and writing about COM for five years. He's taught COM courses to hundreds of students throughout the United Kingdom and Europe, and as a result he knows how to explain complex COM issues to programmers. As a consultant, he's advised large and small companies on COM technology, and he has a firm grasp of the practicalities involved in the everyday use of COM in Windows-based software development.

Julian has also been sole or joint author of 10 programming books, so he has expertise in explaining programming topics in writing. Two of these books concerned COM: the first was the only detailed book on using COM with the Microsoft MFC library, and the second was the best-selling Beginning ATL COM Programming from Wrox Press. Julian's most recent book, published through Microsoft Press®, is Microsoft Visual C++® .NET Step by Step.

On the .NET side, Julian has been using .NET since the first alpha version was handed out at the Denver Professional Developers' Conference in 1998. At the time of writing (April 2002), he has contributed to three .NET books on the market, and he has an in-depth knowledge of the .NET technologies at both overview and detailed levels. In addition, he has recently coauthored Microsoft Official Curriculum course 2558 on writing .NET code using Visual C++ .NET. Julian is also currently running .NET programming courses and doing a small (but increasing) amount of .NET consultancy work.

John Sharp is the author of Microsoft Windows Communication Foundation Step by Step and Microsoft Visual C# 2008 Step by Step. John is a principal technologist for Content Master Ltd., where he works on technology and training projects for a variety of international customers.

Product Details

• Paperback: 608 pages
• Publisher: Microsoft Press (April 23, 2003)
• Language: English
• ISBN-10: 0735619077
• ISBN-13: 978-0735619074
• Product Dimensions: 9 x 7.3 x 2.7 inches
• Shipping Weight: 5.1 pounds
• Average Customer Review: 3.1 out of 5 stars  See all reviews (27 customer reviews)
• Amazon Best Sellers Rank: #941,179 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

123 of 130 people found the following review helpful:

2.0 out of 5 stars What's the target audience?, July 27, 2003

By 

Rick Pierson (Dothan, AL United States) - See all my reviews
(REAL NAME)   

This review is from: Microsoft® Visual C++® .NET Step by Step--Version 2003 (Step by Step (Microsoft)) (Paperback)

First off...the reviewer who criticized the editor for having the wrong book is the one who is wrong:this is C++, not C#. So that reviewer's dismissal should be dismissed. Second, as the editor pointed out, some reviews were for the wrong edition: they too should be dismissed. However...

I do not recommend this book for beginners. A lot of its "teaching" is done by cookie-cutter programming: find this line of code in the program...don't worry about what it actually means...now type these things under it...now compile. The reader gets working programs without fully understanding what x, y, and z mean.

And the authors don't know how to teach step-by-step, despite the book's title. It's as if they can't decide what their target audience is. Are they writing a step-by-step book (as the title implies) that gradually walks beginners through from beginning to end, holding their hands and easing them along? Sometimes. Or are they writing a book for people who already know C++ and just need to learn how to apply it to .NET? Sometimes. The worst part is that while it is possible to do both in one book, I don't feel the authors managed to do either. Beginners will be confused by the disorganized introduction of material (pointers and classes in chapter 2) and lack of explanations, while already-proficient-in-C++ programmers won't learn enough new stuff to make the book worthwhile (unless they are new to programming .NET with C++: then the later chapters will give them new stuff).

Here are some details, looked at from a newbie's perspective.

*********************************
"... (the endl stream manipulation operator inserts a new-line character in the stream.)" (p5)
*********************************

What the heck is a `stream', an `operator', and a `new-line', and what in the world does it mean for an operator to manipulate a stream? A newbie could be confused already...only 4 pages into the book.

********************************
"How does the compiler know which function should be called first? ... The rule is that the compiler will always generate code that looks for a function named main. If you omit the main function, the compiler reports an error and doesn't create a finished executable program." (p6)
********************************

That alone is not a problem. The problem arises when the rest of the book violates the rule just provided, without explaining why!

Only the first program in the book - the trivial "Hello World!" program -- uses Standard C++ (iostream, cout, etc.). The second and subsequent programs don't include a main() function!

The book has the reader "blindly" begin typing the second program on page 20, and that program contains several non-Standard C++ entries and omits several of the most common Standard C++ elements.

(1) The program does not have a main() function but does have a _tmain(). What exactly is a _tmain() function anyway? The book doesn't say.

(2) The program does not have the typical #include <iostream> directive but does have #include "stdafx.h". So what exactly is the "stdafx.h" anyway? The book doesn't say. And why is this one surrounded by double quotes instead of by angle brackets? The book doesn't explain that either.

(3) The program does not have the typical using namespace std; statement but does have #using <mscorlib.dll>. What exactly is the <mscorlib.dll>? The book doesn't say. And why is the typical using statement (such as using namespace std;) not prepended with a pound sign while the program's #using <mscorlib.dll> is? The book doesn't say.

(4) Related to the above, the program has a using namespace System; statement. So what exactly is the System namespace? The book doesn't say.

Here's another newbie-stumper.

***************************
"To access the member variables and functions, you have to dereference the pointer in one of two ways. You can use the dereferencing operator, an asterisk (*) followed by the dot notation - for example, (*cat).legs. " (p23)
***************************

Dereferencing a pointer? What the heck is a pointer? What the heck is dereferencing? The book hasn't explained either yet.

And why in the world is the book already talking about classes? Functions haven't even been covered, nor have variable types, looping, selection, scope, pointers, etc.

***************************
"The lifetime of an object instantiated from the class will be managed by the .NET Framework's garbage collector. When the object falls out of scope, the memory used by the object will be garbage-collected and no explicit calls to delete will have to be made." (p22)
****************************

What the heck does "fall out of scope" mean? A newbie wouldn't know from reading the book. What the heck is delete? And should the book really be discussing topics like dynamic memory allocation on the heap and memory management when less than 2 dozen pages in?

Now note the difference between these two.

****************************
Console.WriteLine("Animal 1"); (p25)
****************************

and

*****************************
Console::WriteLine(S"Welcome to your friendly Investment Planner"); (p49)
*****************************

Why does the second one prepend a capital `S' to the string while the first doesn't? The book doesn't say.

So far I've been disappointed with several of the Microsoft Press books I have purchased. It is almost as if MS is just pumping books out one after another...each one quickly thrown together...just to get presence on the shelf (or to flood the shelves with their books): knowing that people are more likely to by an authentic Microsoft book on Microsoft products.

26 of 27 people found the following review helpful:

5.0 out of 5 stars Response to Jason E. Trout, April 29, 2003

By 

Eric T. Dettinger (Seattle, WA United States) - See all my reviews

This review is from: Microsoft® Visual C++® .NET Step by Step--Version 2003 (Step by Step (Microsoft)) (Paperback)

I wanted to write in response to Jason E. Trout's review. First, I need to state up-front that I was the Technical Editor on the 2003 edition of this book.

The two errors that Jason points out indicate that he is reviewing the old (first edition) of Visual C++ .NET Step By Step. I double-checked the 2003 edition of the book and found that both these errors were caught and fixed.

The 2003 edition includes updates that reflect changes introduced with version 1.1 of the .NET Framework and Visual Studio .NET 2003. The chapters on Windows Forms have been entirely rewritten to reflect the inclusion of designers with Visual Studio that create forms coded with the Managed Extensions for C++. This means developers can now create Windows Forms using designers, just like a Visual Basic or C# programmer would, instead of needing to hand code them. Julian also rewrote the chapter on ADO.NET so the sample projects require Access instead of SQL Server.

So give the new edition a look if you have the chance. I am confident you will find the updates and new information handy, and that errors like the ones Jason mentions have largely been eliminated.

I would have preferred to post this review without rating the book, but Amazon's submission forms don't allow it.

Thanks,
Eric Dettinger

12 of 12 people found the following review helpful:

5.0 out of 5 stars Much better than expected, May 19, 2003

By 

Kevin D Runion (Savannah, GA United States) - See all my reviews

This review is from: Microsoft® Visual C++® .NET Step by Step--Version 2003 (Step by Step (Microsoft)) (Paperback)

I was a little bit worried that a Microsoft Press book might read like a dictionary. That was not the case. I find this book extremely easy to read, filled with very good analogies and explanations. I've always had issues understanding Object Oriented programming, mainly because most books only lightly explain it, and by the time they get to it you're reading chapter 83 and dealing with other complex concepts. I was overjoyed to see that object oriented programming was explained in Chapter 2 (right after the hello world exercise). Needless to say, I was able to understand it right away, for the first time.

Programming books are always hit and miss, sometimes they start too slow and then all of a sudden you're lost in advanced, unexplained topics, and don't know how you got there. Sometimes, the chapters just seem to drag on forever and it becomes easy to lose motivation on over covered material.
This book however is a work of art, the chapters are nice and short, easy to follow and have just the right amount of info to cover the topic. Every time a question flag gets raised in my mind, the answer is on the next line.

This book is worth the money and the time.