Microsoft Visual C++ .NET step by step by Julian Templeman, Andy Olsen

Microsoft Visual C++ .NET step by step

  • Author: Julian Templeman, Andy Olsen
  • Softcover: 608 pages
  • Publisher: Microsoft Press(Apr 23 2003 12:00AM)
  • Book dimensions: 9.2 x 7.3 x 1.6 inches
  • ISBN: 0735619077
  • ITBookworm score: 3.0 /5

Score Reasoning

I really think this book’s lack of explanation and lack of practice exercises really held it back. If it would have gone for the beginning programmer it would have done a much better job.


Overall I’d have to say it’s a thorough coverage of the basics. Its tutorial style method makes it easy to follow along, and while I didn’t compile every example in the book, the ones I did compile ran just fine. It’ll also make a good reference should you need to look up any specific syntax as I find the .NET help files to be really way to cumbersome to actually use for this purpose. One thing that disappointed me though was the lack of exercises at the end of the chapters. It seems to me that if you’re going to have this type of book you should give students problems at the end to help develop their skills. I found myself wanting to try out different things, but it was difficult to think of things to try, so I ended up just moving on instead. I think some good solid practice would have made me more confident in what I was learning. I do like the review at the end of each chapter though. It bullets exactly what you learned and it’s really helpful to review this section. A couple times I found that I had skipped over a section and having it in the review section made me realize it so I could go back and read that section. I also found it to be pretty short on explanations sometimes. I really wanted more discussion or more examples to help drive the point across. Also annoying was the section on pointers where it showed the syntax and then a bit later used a completely different syntax that I still can’t quite make out. I don’t think it ever really explained the reason for the two different methods and when someone is learning something like this for the first time, you really shouldn’t change syntax on them in mid-stream like that. That’s one of the reasons I say it’s not for beginners. In all though, I think it’s a decent book. I think that if I were to go pick up a true beginners book and more thoroughly understand those basic concepts and then come back and pick up this book, I would get a lot more out of it.

Who is this book really for?

This book doesn’t really say who its intended audience is, but it’s quite clear it’s not the beginning programmer. Those who are already familiar with OOP concepts may find this book a little simple while complete beginners may find it too lacking. A lot of the concepts don’t get covered thoroughly enough for a beginner to really grasp and discussion doesn’t go deep enough to hold experienced programmers. I think what you’ll find is that beginners can use this book in conjunction with other resources and do just fine. Experienced programmers will skim through a lot, but will be able to take advantage of the topics on the new features of the language. In short, if you already know how to program fairly well and just want to learn this particular flavor then you’ll be right at home here.

Writing Style

I wouldn’t say it really has a writing style. It’s just tutorial style format with no extra words or anything to really make it interesting. If your goal is to dig into the language and you don’t need any of the extra entertainment or clever examples then you’ll love this. Otherwise, it can easily come off as pretty dry.


This is a very solid book. I tortured it beyond reason and it held up very well. The spine is still in great shape and the pages are still holding together just fine.

Table of Contents

Chapter 1: Hello, C++!

OK, getting past the obvious clichés with the ‘Hello World’ program that’s plagued the programming world since programming was programming. Anyway though, here you start out talking about C++ a little and then jump right into your first program. I don’t think I have to tell you what it is. It does discuss the very basics of the language by discussing the main function, keywords, etc. It talks about compiling, linking and running programs too.

Chapter 2: Introducing Object-Oriented Programming

This starts out with a discussion on what OOP is, and its advantages. Encapsulation, inheritance, and polymorphism are all discussed, as well as classes and the development lifecycle. It then walks you through a quick example with code.

Chapter 3: Variables and Operators

More basics here. Datatypes, and declarations are both covered pretty well and then it jumps right into arrays, pointers, and constants. After that it breaks out into the .Net string class and logical operators. There are other minor topics covered that only get mentioned briefly. I really wish it had a better discussion on pointers though. I walked away knowing what they were, but possibly a few more examples and possibly a bit more discussion on the topic. I find that with something like this, you can never discuss it too much.

Chapter 4: Using Functions

I think this chapter pretty much speaks for itself. Declaring function prototypes, parameters, and bodies are all covered. There are some good examples so it’s worth a look. Calling functions gets a little time, but then it goes straight into how to use the debugger. It walks you through with screenshots and everything. The much needed discussion of scope is addressed along with overloading.

Chapter 5: Decision and Loop Statements

I don’t think I have to talk about this too much. These types of statements are the heart of every language in existence, so it goes without saying that this is important. This chapter covers the topics very well.

Chapter 6: More About Classes and Objects

This is the first difficult chapter. It starts out discussing how to organize classes into header and source files. It does a good job discussing it, but I really wish it would have given a few more examples and discussion. Constructors and destructors and discussed and given good enough ink to be effective. There are other topics discussed, and it’s really a good chapter. I just wish it had some more detail on some things.

Chapter 7: Controlling Object Lifetimes

This is good because it starts out talking about traditional C++ memory management and how to work with it. This is important discussion so you appreciate what .Net does for you. Then it gets into .Net garbage collection and finalizers. It’s a short chapter, but it does the trick.

Chapter 8: Inheritance

Here you talk about inheritance hierarchy, and defining base classes. Then you get into accessing members in base classes. Creating objects is next and then overriding member functions. It finishes with defining sealed classes.

Chapter 9: Value Types

Here you start out talking about value types and why they’re necessary. Then you get into structures. It’s actually a pretty thorough discussion on structs so you’ll get a lot out of it. You now get into enumerations and while the discussion isn’t as long as it was for structs, it’s still adequate.

Chapter 10: Operator Overloading

Of course the basics of what overloading is, and where you can use it are covered first. You then get into overloading managed types. There’s a brief discussion of overloading in unmanaged C++ for completion purposes. The rest of the chapter discusses different aspects of overloading and implementing it. I found the detail to be good enough to get an understanding of the topic.

Chapter 11: Exception Handling

I probably don’t have to tell you how important this topic is in programming any language. Here you start out with basic definitions again, and a discussion on how exceptions work. Then a quick blurb on what can be thrown that jumps right into how to handle them carries a few pages. You then quickly get into custom exceptions and hierarchy. Specific exception methods are discussed before getting into creating your own exception types. It ends with a quick talk about exceptions across languages.

Chapter 12: Arrays and Collections

Here you start out with native C++ arrays and a pretty good discussion on how they work and passing them into functions. Next comes dynamically allocating arrays and a nice discussion of __gc arrays. Now you get into the heart of it with a discussion of the .Net array class. There are other array topics covered like enumerators and other .Net collection classes. This chapter suffers from the same affliction that some of the others do in that some of the topics could really stand to be fleshed out a little more.

Chapter 13: Properties

Here it’s all about properties. It’s a fairly short chapter, but it goes over the reasons for properties as well as the 2 types there are. It’s a short discussion, but there’s plenty of code to explain the theory.

Chapter 14: Delegates and Events

Yes, what are delegates and what do they do? This chapter explains it well enough. As always, I think I’m left with some questions, but at this point I’m not sure. However, if I walk away thinking I may not understand it fully, then it’s likely I don’t. However, they are discussed in decent detail. After that there’s a short section on events. It doesn’t last long, but it’s pretty easy to understand anyway.

Chapter 15: The .NET Framework Class Library

We’re finally getting to the meat of the managed portion of our show. The framework is the key to this whole thing and where you’ll find the most useful stuff. Here it explains the system classes, metadata, assemblies, etc. it overviews some of the different namespaces like system, I/O, drawing, forms, and the like. However, it’s just an intro. It doesn’t really go into any detail on how to use the namespaces.

Chapter 16: Introducing Windows Forms

Here you start out talking about forms and designers and the difference between Forms and MFC. The properties of the forms namespace are listed and then you jump right into some code for creating a simple form. It pretty much walks you through the entire process with screenshots. A lot of the different elements are discussed like list boxes, buttons, and checkboxes. Then you get into using menus and there are more screenshots to guide you along the way. It’s all pretty straight forward.

Chapter 17: Dialog Boxes and Controls

This teaches you how to use dialog boxes and gives a nice tutorial-style walkthrough that guides you step by step. Then you get into controls with all the properties listed and screenshots shown. It has a nice discussion on accessing directories as well as using splitters. Overall a very nice chapter.

Chapter 18: Graphical Output

This is one of the topics I was looking forward to. Graphical output is something I’ve always had trouble with so I was disappointed to see how this chapter handled the topic. It explains how to use the namespace, but there isn’t anything really useful though. It’s too basic, but it does go into using color and different fonts. It finishes up with handling images.

Chapter 19: Working with Files

Raise your hand if you’ve ever written a real business application and didn’t have to work with files. It’s so common that I almost think it should have been earlier in the book, but that’s unimportant. It gets right into the IO namespace and teaches you how to use readers and writers. Next, FileStream is covered along with TextReader. Then you get into working with files and directories. It covers the topic with lots of sample code and I think it does a fine job.

Chapter 20: Reading and Writing XML

Working with XML in .NET is a lot easier than I thought. One thing I like about this chapter is it doesn’t go out of its way to explain what XML is and why it’s useful. Let’s just assume that we all know what it is and get on with it. There’s a lot of good useful code in here that I’m sure I’ll be using in the future.

Chapter 21: Transforming XML

This is one of my favorite topics. XSL is the very heart of XML and it’s what makes it so versatile. You get started with XPath and then move into XSL and it’s got a nice explanation of what it is and how it’s best used.

Chapter 22: Using ADO.NET

This is the new method for connecting to the database and carries a lot of advantages over ADO. The namespaces are gone over and then the assemblies. It’s a nice basic chapter on how to work with ADO.NET.

Chapter 23: Building a Web Service

I know so little about web services and I was really interested in this one. It starts out with an explanation of what web services are then moves into SOAP. It walks you through creating a simple web service. There are plenty of screenshots.

Chapter 24: Introduction to ATL Server

Starts out here talking about what ATL servers are, and writing ISAPI applications. It then gets into the different aspects of working with ATL.

Chapter 25: Working with Unmanaged Code

Here you go into different advanced topics of unmanaged code like pinning and boxing, and casting. It’s not a very long chapter though.

Chapter 26: Attributes and Reflection

It’s just what it sounds like. Many aspects of working with attributes and reflection.

Chapter 27: Living with COM

Working with COM in .NET code is discussed. It’s ok, but a little too advanced for me.

-Sean McCown,

Tags: ,

Leave a Reply

Your email address will not be published. Required fields are marked *