Customer Reviews

Visual C++ MFC Programming by Example

5 star:		(8)
4 star:		(1)
3 star:		(0)
2 star:		(3)
1 star:		(2)

 

 

I have been writing C/C++ programs for a long time, and I bought this book looking to go from console programs to graphical interfaces. I would not recommend this book for someone in this position. It has basic descriptions of various MFC classes and what they do, but not exactly how to use them. There is a gap between explaining the classes, and the examples, as the examples are complete programs that uses many classes put together.

For example, dialog boxes and control classes are described in Chapter 2, but the first example PROGRAM is in Chapter 5, after drawing, messaging, etc. I would have liked the book to say "Here is this drawing function, and this is how you intialize all of the MFC stuff to be able to use it." In fact, the book is more like "here is a list of drawing functions, some are used in Example X on page Z."

I suspect this book would be useful for a somewhat experienced MFC programmer but I wouldn't buy it as your first foray into MFC.

"Visual C++ MFC Programming by Example" by John E. Swanke serves both as an introduction to the MFC programming paradigm and an encyclopedia of how to solve 85 common application problems. In this sense, the book does apply to both beginning and experienced developers as advertised. Swanke assumes a working knowledge of object-oriented design concepts such as inheritance and polymorphism. Developers who dive into MFC without this background are likely to become confused quickly.

The introductory text covers messaging thoroughly, which is the single most important thing you need to know about how MFC works. This includes essential topics such as subclassing, superclassing, message pumps, reflectors, and window hooks. Each of these fairly abstract concepts are grounded in practical usage considerations. Many data-flow diagrams are used to good effect. However, the use of font sizes as small as six points makes them painful to read. Since the introduction to MFC is only a little more than 100 pages, only messages and drawing are covered in depth.

The remainder of the book forms an encylopedia of 85 user-interface examples. The layout of each example includes an Objective, Strategy, Steps, and Notes section. These run the gamut from the simple (Example 54: "Drawing text in your view") to the tricky (Example 47: "Customizing a Common Control Window with Subclassing"). Lots of them are going to be essential to any nontrivial MFC application (Example 28: "Adding NonButton Controls to a Toolbar). These will get you on your way, though a few may be too brief, such as the DAO which is only 8 pages. Overall, I believe the approach will be most helpful to either novice MFC developers going in to do maintenance on an MFC app or Windows developers from a different background who are converting to MFC (e.g. VB or Delphi).

Approximately the last 100 pages are miscellaneous appendices of which the most useful concerns window styles for all MFC supported controls. Many examples are included, which can save some trial-and-error in setting those often pesky flags. The accompanying CD-ROM has 4.6MB of the samples from the book. However, with many examples being fewer than 20 lines of code, the CD-ROM is overkill. A single ZIP file on an FTP site would have been better.

Any half-dozen of the 85 examples is likely to save you more than a couple hours of research or worse yet doing things the wrong way. Unless you're the most grizzled MFC veteran, I think you'll learn something from "Visual C++ MFC Programming by Example".

I've been programming in Visual C++ for 6 or 7 years and I'm the project manager for a fairly large project. This book is perfect for most of my developers, especially the newer ones, but even I have taken away some great knowledge from this book. In fact, the reference card in the front was worth the value of the book itself.

I'm always forgetting the exact sequence of messages and overrides for Window and Dialog creation and destruction. I used to have my own copy written down years ago and lost it, and I've never taken the time to go through it again. Having that is terrific. I have it hanging from the lamp on my desk.

Great book. Well written, and solid examples of writing good MFC code.

Judging from this book's title I was hoping for some good examples of programming with MFC. While I found this book to be complete and thourough in its information, it was disapointing with its lack of concrete examples. This is not the book for you if you are looking for step by step instruction to learn MFC programming techniques by example. The only reason much of this book made sense to me is because I have already been using MFC on and off for a couple years. The examples provided leave the user to make too many decisions and are vague. There is no rescue if you get backed in to a corner.

I read this book just out of curiosity and not to buy it because I had learned it through lots of frustration from other books. I always had the suspicion that there must be a better way to teach a beginner in MFC come up to speed quickly. After I read this book, I definitely believe it is the right book and bought it just to support the author. This book and perhaps VC++6 in 24 hours is probably all that one needs to quickly start rolling out powereful GUI applications. I don't think there is a book that covers runtime modifications of menus etc. and real life programming, in as short a time as John's book manages to accomplish. I have read at least 5 big volumes on MFC and VC++ programming and none come close.

For those who attempt to downgrade this book, go try a 24-hour one. If you have a good grasp on VC++ but need solutions to common problems, then this book is the missing key. The author's approach is direct, precise and exactly what I was looking for. It was initially to be a cross-reference manual, but I ended up reading it cover-to-cover twice due to the many helpful strategies that I learnt. Make the investment and achieve things that no other books cover.

Although I've been programming with MFC for a number of years, I learnt things from this book I didn't know or fully understood before. It is obvious from the way the author explains the material, he clearly knows what he is talking about. It is the kind of book I wish I had years ago when I had just started out programming with MFC, and it is the first one I now reach for when I need to check out certain things (just look at the copious amount of helpful diagrams he includes). In the way of TIME SAVED from the knowledge I obtained from it, I have already gotten back what I spent for it many times over, and am definitely looking forward to his next topic.

Sometimes the author shows the code you need to create a certain result and where to put it. Sometimes he does not. You have to do a lot of second-guessing when you read this book. I even tried looking through the CD to see if I could get the source code in context with the example application--na da, zip! Some of the code is outdated. If you are using Visual Studio 6 or later, forget this book. You will have tons of error messages. This is not the author's fault. This is the fault of those pointy-headed pinheads at Microsoft. They actually think changing the names of classes and functions is some sort of upgrade(lol). The book would be a lot better if it started with a simple application and expanded on that application showing where all the little code snippets go in the source files and how they work. Wouldn't that be nice?

This book paid for itself the day I bought it. I found a solution to a problem which I had already spent a few hours on and had put aside. Swanke's solution was simple and clean. The book is packed with useful information and I like the way it is organized. I can find specifically what I need very quickly. The examples are explained very thoroughly so that you get depth of understanding in bite size chunks with each example rather than just a cut-and-paste solution. I have several MFC books and this is one of the few I take to work with me.

Coming from a Visual Basic and Java development background, programming with MFC is more of a matter of dealing with exceptions to rules, rather than simply following them. Spending late night hours in the MSVC help files is no picnic, especially when I am researching basic concepts. Thanks to this book, I feel like I've learned a terrific amount and am now prepared to dig more deeply. Every demonstration project I've tried on the CD has worked without a hitch, even in MSVC 6.0. One thing though, there are some grammatical errors in the text (then -> than, etc.), but despite that, this book is a must-have for MFC developers who are just starting out. With this book, someone has actually made MFC digestable for beginners. Where's the encore? Kudos from Munich, Germany!