Introduction to MFC Programming with Visual C++

Rating:
Summary: Overall an Excellent Book
Review: I am a professional c++ programmer with lots of experience in Unix X Windows programming. Recently, I migrated to win32/windows application development. My transition was made easier by this book.
"Introduction to MFC Programming" is truly an excellent book. It provides a good introduction to the fundamentals of MFC programming before proceeding to advanced topics. Most other MFC/Windows programming books I have read were "cookbooks". But this book is structured very well starting with an introduction to Utility classes using console applications, followed by event handling and handcrafted MFC programs before moving onto advanced topics. Knowledge of c++ is assumed.
Overall an excellent book.

Rating:
Summary: A Professor's Class Notes in your Hands
Review: This book is amazingly easy to read. It's as if my college professor gave me the lecture for the entire course. If you are a student who wants to learn MFC, take a 101 course first, then read this book. You will need the 101 course to get familiar with the syntax, format, and features of C++. After reading this book thoroughly, you will have a decent grip on the basic as well as intermediate concepts of MFC.

Rating:
Summary: Great MFC Book!!!
Review: This is a great book on MFC. It actually teaches you MFC; instead of telling you to use the wizards. By the time you're about half way through, you can decipher the code that the wizards make. I would highly recommend this book to anyone wanting to learn the Microsoft Foundation Classes.

Rating:
Summary: A great book for starting out in MFC
Review: An excellent resource for those learning MFC with Visual C++. It doesn't just list the topics and go into each topic in depth. That style is for those interested in reference material. This book walks you through the process of MFC programming with Visual C++ 6.0. Each chapter builds on the ones before.

Totally worth the purchase price. Written clearly, _with_ screenshots showing you the steps. And very importantly, there is plenty of whitespace for you to pencil in your notes on the material. It's also quite easy to find among your computer books, because it's not the standard size of the computer books (you all know what i mean, the textbook size). It's 8.5 x 11, which makes it a breeze to yank it from a messy pile on the floor. Not that it's that big of a problem, cuz this book will be on the top of my pile for quite a while.

Rating:
Summary: Kudos to Richard M. Jones
Review: I was a bit sceptical about this book. Simply because I have no experience whatsoever with Windows Programming, I was looking for a book to introduce me to Windows Programming and I happend to find this book, which dealt with MFC.
The illustrations are wonderful, I did find a bug in a code listed in the book at a couple of places eg.Pg43 Function declared as CClient* GetAt(int idx) but defined as CClient& GetAt(int idx). However looking into the code in the CD-ROM solved all my problems. Another shortcoming which drove me crazy was why headers are sometimes included/not included in Chapter 3, there is no explanation to that, and the changes are not visible in the examples... once again CD-ROM to the rescue.
Despite these few shortcomings, this book seems well written, well explained and well illustrated. Wonderful book... my favorite chapter was Chapter 3 explaining Templates(despite the unexplanation of the headers). The effort the author took to show what templates actually are is truely praiseworthy.
But be warned, solid C++ experience is needed, note C++ not Visual C++. An understanding of pointers, linked lists, stacks, qeues etc is highly recommended in order to get the most out of this book. If you are a newbie to C++ then don't even bother buying this book, I doubt if you'll make it past chapter 1(rating on the back of the book says 'Intermediate programmer').
All in All, this book was great for me and I would recommend it to anyone with the proper background.
L8r

Rating:
Summary: First rate presentation of Visual C++
Review: Two weeks into the fall term of 2001, the sudden death of a professor placed me in the spot of having to jump in with both feet to complete a course that several students needed for graduation. While I had taught Visual C++ before, it was a difficult assignment in many ways. My task was made much easier by my predecessor having selected this book as the text. The nuances of Visual C++ are well-covered and the source code is easy to follow and available for examination. It was also very easy to give regular programming assignments to the class and there were very few questions from the students asking me to further explain the meaning of a statement in the text or a section of code. Their performance on the programming assignments is proof that the lack of questions was not due to a lack of understanding.
No lesson is very lengthy, as many fit on a page with space left over for an image of the appearance of the screen when the code is executed. It was a rare occasion when it took longer than one fifty minute lecture period to demonstrate a lesson.
The first section of the book deals with the construction of code by starting with an empty project. After that, the wizards for dialog and document based projects are demonstrated. This is without question the best way to do this. Starting with the wizards is extremely confusing to beginners, so seeing similar code that was not generated by a wizard before that from a wizard is the best approach.
There are many "teach yourself' books on the market today, although few can effectively be used by a novice. Visual C++, with the convoluted syntax and the numerous gotcha's, is a difficult language and platform to master. This is the best teach yourself Visual C++ book that I have encountered, and I highly recommend it to anyone who wants to learn how to use Visual C++.

Rating:
Summary: Finally! MFC presented in an understandable way!
Review: I was looking for a book that would take me from a basic knowledge of C++ to programming Windows applications. Well here it is. Other books I'd tried were needlessly complex, but this book keeps things within the beginner's reach. Oh sure at times you may find something that just makes no sense at all to you as a beginner, but if you press on and work through the examples you will be able to learn MFC programming. The book also teaches a lot about object oriented programming, so you need not be a C++ expert to use it. For the total beginner, I'd recommend a basic C++ book like "learn C++ in 24 hours", and then go to this book and you will be writing Windows programs.

My only complaints are that for the exercises, there seems to be no place to get the "answers"; there is code on the disk for the samples that are illustrated in the book, but for the exercises if you get stuck you are on your own. This is not as bad as it sounds though because it makes you really work through things rather than cheating and looking to see how the book did it. Also, the paperback book is a bit flimsy. But I still give it 5 stars as it was EXACTLY what I was looking for!!

Rating:
Summary: Quite possibly the best programming book I've read yet!
Review: Just so you have some background on who I am. I'm 16 years old and the only programming coarses they offer at my high school are VB (gag) and C++. VB is a prerequisite for C++ so I'm taking that now. Anyway because of this general situation I've been in for my whole life, I've had to teach myself pretty much every programming/scripting language I know, from JavaScript to Perl to C++ to Q-Basic. And of all the books I've read, this one is the best by far.

Richard M. Jones assumes you have a basic knowledge of C++ before reading this book which makes sense. He starts out by teaching you some of the basic classes used in MFC such as CString, CPoint, CSize, and CRect. What I love about this author is that he makes reaching the book like taking a formal class. He starts by teaching you a firm basis, and then builds each lesson thereafter on the one before. By the end of the book (it took me approximately two weeks to finish). You're writing code for menus, toolbars, status bars, buttons, edit and static controls, etc.

This book is great, period. If you've never had any MFC experience and want to learn it from scratch I recommend this book.

Rating:
Summary: Great Book (Best of the lot, and I have 12 books on MFC)
Review: Buy this book. The best of the lot, by far. Trust me, I have a dozen books on MFC, and this one finally cracked the code.

The author is an old timer and he states he has seen a number of approaches to MFC and knows what works and what does not work. Reminds me of the whimsical adage about how when an old man (like the author) says something positive, you can believe it will happen, whereas if an old man says something is impossible, or will never happen, you can believe it will probably happen. This author is an experienced teacher of MFC C++ and he knows how to open students eyes, starting from Console Programming, moving to a simple MFC, and then to the Wizards-generated code.

Rating:
Summary: Good introduction with many code examples
Review: For reader who has a fairly good background in C++, this book is a good introduction to MFC programming/Visual C++. It is written for individuals who want an in-depth practical understanding of MFC programming, and who are willing to put the time and effort into the learning of it. The book includes a CD which includes the 90 different sample programs in the book.

In chapter 1, the author introduces MFC utility objects in console applications. The three utility classes CString, CPoint, and CRect are used to create a simple Windows application. The author is careful to distinguish between a console application, which has the main() function, and a windows program, which does not. The CString class is used, instead of the standard C++ library class, and this is standard in MFC programming. The author advises the reader to think of CString objects as an actual object, and not as a pointer to a string. This is an example of value (or "copy") semantics, wherein the value is copied, and not just the pointer. Programmers concerned about performance issues commonly use this feature of C++. The author gives an interesting method to extract a string from a stream into a CString object, and how to use the Format() function to convert a value to a string for eventual display in a window.

A review of classes in C++ is given in Chapter 2, with emphasis on how virtual functions get executed in windows applications. The author shows explicitly how to use Visual Studio to add a class and member functions, and a good discussion is given on the difference between passing parameters by value, by reference, and by pointer. The role of the member function "this" is discussed also.

Chapter 3 could be skipped by the reader interested only in MFC windows applications, according to the author, where he discusses collections and class templates. Object and pointer array collections are treated via the code examples. The author discusses the three different ways of performing tasks on collections, and discusses how to use pointers to objects, which is very advantageous from a memory management point of view. He is also gives an interesting discussion on serialization.

The actual building of MFC Windows programs begins in Chapter 4, without using the AppWizard. The event handling via keyboard and mouse input is given the main emphasis, and the author gives a detailed discussion on the steps taken by a window event. The different types of member functions in the CMainFrame class are given a thorough treatment. The reader is first asked to use an MFC virtual function in this chapter.

In the next chapter, the author shows how to get graphics shapes in the windows, via device context attributes. This is followed in Chapter 6 by a discussion on how to use the mouse and keyboard to make changes to text and graphics.

The window controls are then discussed in Chapter 7, and the author gives a very detailed discussion on how controls fit in to CMainFrame. The process by which event and notification messages are handled is summarized in a diagram. List boxes, combo boxes, and scroll bars are all treated in detail using the example programs. This is followed naturally in Chapter 8 by a discussion of menus and dialog boxes in the context of resource editors.

Finally in Chapter 9, the author uses the AppWizard to generate an application. A simple program example begins the discussion, followed by a non-document application. The author carefully explains the steps used in the AppWizard to give the reader more insight on just how it is able to do its job. Then in Chapter 10, the AppWizard and the ClassWizard are used to refine and extend the discussion on menus, toolbars, and dialogs. A good program example is given for a dialog-based application.

Time-dependent messaging and XOR drawing mode are the subjects of the next chapter. The three functions for timer control are discussed, along with a discussion of animation. This is followed in Chapter 12 by a treatment of bitmap graphics, with bitmap editors via MS Paint discussed.

Messaging via the MFC functions SendMessage() and PostMessage() is discussed in Chapter 13. These functions are discussed in a setting more general than modeless dialogs. Modeless dialogs are however discussed in detail in the chapter, and the difference between modal and modeless dialogs clearly explained.

The next chapter of the book discusses how to use the document view architecture and the author shows in detail the major classes involved in its use. The reader can see the CMainFrame object as a container object, which will adjust the sizes of the windows it contains if the mainframe window is resized. The document and view classes are derived from the CDocument and CView classes. The discussion is helpful in that it shows how to use the member functions in these classes to propagate information to all views. The author also shows how to serialize the document objects.

In the last chapter the author shows the reader how to use Visual C++ to manipulate an existing ODBC database. The discussion is very brief, but it does the reader with database knowledge of how to generate code to interact with these databases.