Customer Reviews

Programming Windows with MFC, Second Edition

5 star:		(64)
4 star:		(6)
3 star:		(7)
2 star:		(2)
1 star:		(2)

 

 

If I were a practising MFC programmer at the junior or intermediate level, I'd definitely want to have this book as a reference. It is one of the most complete MFC books around, and I like the author's approach of starting off with MFC basics and wrapper classes before moving onto application framework stuff and wizards. This is one of the few books that tells you what's behind some of those macros like DECLARE_DYNCREATE and tells you where to look for it in the source code of MFC itself.

However, if you are new to Visual C++ or have never heard of MFC, this is not the book I would recommend. I would suggest picking up Ivor Horton's Beginning Visual C++ 6 instead. Real beginners need a book that tells them how to use the IDE, debug programs, and use the wizards. So what if after reading it, all that wizard generated code becomes a blur to you. That's what Prosise and other more advanced books are for.

I'm an experienced C++ developer and I had read two MFC books (Beginning Visual C++ 6, MFC Programming by Alan Feuer) and Petzold 5th ed before reading Prosise and I still found it a little difficult reading, mostly because it starts off kind of slow (as someone else mentioned too). The chapter I found most difficult was the one on OLE clipboard/drag & drop.

I really recommend reading Petzold 5th ed before reading this or any other intermediate/advanced MFC book. Petzold is more of a beginner's book for Win32 SDK-style GUI programming.

This is the best MFC book ever. Conversational style, and authoritative reference. He puts logic into the nonsensical, and starts slow (no appwizard shtuff and confusion until chapter 4) so everyone can understand. In chapter 4, he slowly walks you through your first simple program involving Visual C++ 6.0's mfc appwizard. This book was made for those who have no clue about the MFC tutorials (95% of those who use Visual C 6.0) in the MSDN library, but yet want to understand MFC someday.

However, know your inheritance of classes in C++ before reading. Reading Programming Windows 5th Edition by Charles Petzold before this isn't a bad idea either, but it isn't required, it just makes a much greater appreciation of MFC. MFC still doesn't stand totally on it's own without the win32 API either, but it comes pretty close. The last word of warning is that it is geared to the Visual C 6.0 compiler. So for those with Insprise, you aren't out of luck (it facilitates understanding 1000% still), just some of the stuff about using appwizards (which, come in handy) isn't going to apply to you. Prosise makes compensation for those with other compilers.

At the end, he goes into a pretty good COM ActiveX, and OLE tutorial (and how they apply to MFC) but nothing huge (a mere 220 pages).

This book covers MFC in great detail. That can be a plus or a minus, depending on how you look at it. If you're a beginner, I would not recommend this book. Interestingly enough, in the book's introduction, the author writes: "[This book] was written with two kinds of people in mind: (1) Windows API programmers who want to learn MFC; (2) Programmers who have never before programmed Windows." I strongly disagree with (2). If you want to spend hours and hours reading this book at a snail's space, and then going back and continually reviewing what you read, then I guess it's possible for you as a beginner to learn MFC from this book. For the majority of beginners, however, starting out with this book would not be the best way to learn MFC. (Of course, the author's job is to sell copies of his book, so why wouldn't he claim that it's for beginners too?)

The best part about this book is its comprehensiveness. So, if you're looking for a good reference, this book definitely gets a thumbs-up. But if you want clear discussions of fundamental MFC concepts, this book falls short. When you read this book, in many ways you can't see the forest for all the trees. That is, Prosise does a rather poor job of separating key, high-level concepts from more advanced, low-level details. The result is a book that is very dense and not so readable.

Even when he isn't getting bogged down in details, Prosise doesn't always present topics effectively. At some places his discussions are pretty good, but at others they aren't so clear. Frankly, although Prosise is a brilliant programmer, I don't think he's that gifted as a teacher. He no doubt understands the material himself, but he isn't nearly as skilled at presenting it to someone with little exposure to it.

If you're an intermediate MFC programmer--or, even better, an advanced one--this book can be a valuable resource. But if you're trying to navigate the waters of MFC/COM for the first time, try another book--and come back to this one after you've already learned the ropes.

When I started to learn MFC, I bought many books. Well, after I read all of them, I can create application myself without understanding the concept of MFC. Most of other MFC books just tell you to insert this and that to the .cpp and .h files without even mention what those lines mean. But this book is really fantastic in explaining all the codes in MFC, from the auto included codes done by visual C++ to all the codes that the book tells you to insert.
Besdies, the examples of this book are very illustrative. Though the examples are more complicated than other MFC books, the author explains them really well, and from the example, you will actually catch the concept of MFC programming.
One little flaw about this book is that it's not written as a reference book. it's more like a tutorial to someone who's new or intermediate to MFC but have some knowledge on C++. Thus, after 1 or 2 years in MFC, you might want to look for another MFC reference book.

The is no doubt that this is a must read book for the MFC programmer. As a reference book, it is excellent, but for the beginning MFC programmer, this book falls short as a tutorial.

My biggest complaint with the book is this:

Prosise repeatly states that learning MFC using wizards is a bad idea, and stresses the importance of learning to code MFC by hand. I couldn't agree more. In fact, I bought his book so that I could learn MFC without relying on code generators.

However, Prosise's "let's not use 'wizards'" attitude lasts only until chapter 4 - at which point, it's wizards all the way.

Why is it so difficult to find a MFC book that doesn't use wizards? These wizards generate code that is extremely obscure.
Even the simplest code that these wizards generate, requires an understanding of documents and views, a fairly complex subject in itself.

I just resently bought Herbert Schildt's "MFC programming from the ground up". This book seems to be the only truely wizard free MFC programming book on the market. The examples are hand coded and start forward. The beginner programmer would probably be better off, reading Schildt before going to Prosise.

I'm starting to believe that part off the reason MFC is so difficult is that all the tutorials drown the reader in wizard generated code. It should not take a brain surgeon to get a dialog box up and running.

This book covers a great deal of MFC development. The book starts with a little work with how Win32 programming is done in standard C (see, Charles Petzold's Programming Windows for more). The book clearly defines the inner workings of the "windows message pump" and gives the reader a sense of what environment they are heading into.

Warning: If you are not good in Object Oriented Programming this book is not the first step. First learn up on C++ and then think about jumping into MFC.

The writing is made clear and understandable at a "user level". The code is sometimes not fully completed (and can be obtained from the included CDROM), but all examples are clearily described line by line on what is going on in them.

The API's that are described throughout the book will definatly get you on your way to writing a class A application. The writer covers the use of GDI for graphic drawing, Single and Multiple Document interfaces, and works through almost every control that you have available in Visual C++ including Rich Edit Controls and Rich Edit Views. You can learn to print, write to disk, and access the windows registry (and much much more)

This books constantly gets passed between friends as they all have begun learning the inner workings of MFC and have left the days of the "win32 console application".

The book also includes a nice object oriented hierarchy diagram on the inside front cover of the Foundation Classes at your disposal.

Drawbacks: 1. Some examples use the Class Wizard, and other Visual C++ "helpers" which lead to some odd comments in the code, and less "handwritten" appeal.

2. The book is HUGE. Pretty heavy, and not always easy to read in a comfortable way.

3. Does not give you a 100% understanding of how MS Windows works internally. It has a good introduction, but if you want to know how it all works using MFC to encapsulate the more difficult functionality is probably not in your best interest.

-

I suggest both this book and "Programming Windows 5th Edition" by Charles Petzold for both C++ "MFC" and standard Win32 C programming. However, with this book you can write quick and dirty applications in no time flat!

I bought this book instead of one of Mike Blaszczak's "Professional MFC With VC++6". I like this author's writing style of presentation better than the chatty style of Blaszczak. Prosise starts with the basics, building an MFC application by hand and then shows you how to automate that process with the Wizards.

"Wizards" are just code generators, but once they generate the code it is YOUR code and you must understand, modify and maintain it as necessary. This is why I really like Prosise because he explains the basics to you so that when you generate code with the Wizards, it makes sense and doesn't look like 'magic' anymore.

I've read about half of this book since I got it and the quality has been excellent. I haven't found a single typographical or grammatical error so far and Prosise's explanations are concise (he treats the reader like an adult) but not so terse that you're left scratching your head. He gives good advice on style and code organization for MFC applications and provides hints on how to achieve specific results without trying to be an exhaustive cookbook on MFC tricks.

MFC is a big subject and I'd suggest that any reader be comfortable with programming. Being familiar with writing small Win32 SDK applications helps but isn't a strict requirement. If you haven't programmed in C++ very much, start with Stroustrup "C++ Programming Language", 3rd edition, and then move on to MFC.

This book will give you a solid foundation in MFC.

After reading all the pages in the book (and others books about mfc). I can say now that it a really good book and worth the money and the time investing to use it to learn MFC.

This Book is more like the bible of MFC not just a typical vc++ book or MFC book , it teach you from the ground the MFC blocks and to understand what take happen inside. if you considering taking the MSCD exam i will say buy this book first .

c/c++ level : for reading this book you have to know the c and c++ language but not as an expert but more then the basic.

about the chapters : each of chapter(s) or subject(s) are very well organize is like you sitting in a private course and hearing the lecture from the pages and view the examples. you can find a lot of information about (not using the wizard!) : Drawing in windows,...,the MFC collection class ,File I/O Controls,Scroll view ,HTML View,Multiplie Documents and views,...,Toolbars Timers and idle processing,...,Thread and Thread synchronization... some ole and Active X,...,and alot more.

the English level : is very easy to understand , how ever there is a 1291 pages to read so find the time .

I purchased this book a number of years ago when I started a new job which required me to program using MFC. I had never done any programming for Win32, let alone using MFC (which wraps around the Win32 API). Coming from this state of ignorance, it only took a short time of working with Prosise's book for me to gain enough confidence to start writing MFC programs on my own.

The book covers most of the major areas that an MFC programmer would have interest. Topics such as dialog based applications, the potentially confusing document / view architecture, property sheets, mouse and keyboard IO, menu management, creation of custom controls, bitmaps, UI and worker threads - all are explained with exceptional clarity thoroughness. After reading a given section I felt a true understanding of the material - the information is taken to a depth which seems to be uncommon in many windows programming books.

At its core though, this is a windows programming book and through its many examples it succeeds in providing an excellent foundation. One may question the usefulness of some of the examples but keep in mind that they were not written for practical usefulness but instead they were intended to solidify the concepts presented in the chapter - which they usually do quite successfully.

More recently, others at my company have found it necessary to program for Win32 and my first piece of advice for them is to sit down and read through the first chapter of Prosise for a day or so. After that, answers to most questions can be found within the remaining 1200 (!) pages of the book.

Note that the CD which came with the book worked fine on Windows NT and Windows XP. Also, the book targets Visual Studio 6.0 but most of the topics are still valid in Visual Studio .NET.

So why review a book that is almost seven years old at the time of this writing? I felt like I owed Prosise for creating such a comprehensive and understandable work and writing a positive review seemed a nice way to say "Thank You".

I bought this book because it was highly recommended, but I was wary because of previous experience with similar books. However, as an intermediate Windows programmer, I was NOT disappointed. It is an excellent book for learning MFC, and teaches both the why and the how. It also tells what goes on behind the scenes, which can be very important.

For a beginner, I would recommend you learn some basic windows concepts, maybe with Petzold's Programming Windows 95, and have a good understanding of C/C++. Then go out and pick this book up if you want to learn MFC. (It does assume a knowledge of C++ and basic Windows)

This book is very thorough, and is an excellent teaching tool as well as a great reference.

Highly recommended.. 5 stars!