All other 90 plus programs work fine with the exception of 3 programs that use the slider control: Ex07f-sliders, Ex08e-DialogMsgMap, Ex08f_DialogMsgMapIcon.

The compilation error in the function OnVScroll() can be fixed by replacing the type CWnd* with CScrollBar*.

Hope this helps

Obviously, this book demands proficiency in C++. But when you complete this book, you'll be most satisfied with your proficieny in MFC.

The examples in the book are too good and very representative.

I recommend Prosise in addition to this text.

Then there's the missing parts. There is absolutely no documentation on how to build custom controls in MFC. MFC is easy if you build just the stuff that Microsoft intends you to build. If you want something custom, then things get difficult. Nowadays, almost every MFC project has some amount of custom controls. It would have been nice to at least have a chapter or two on custom controls.

Overall the book teaches you how to build limited, plain looking GUIs. This leaves one feeling in want as one has no idea how to bridge the gap with the feature rich MFC GUIs in distribution.

Richard Jones writes an incredible introduction to MFC. He explains everything in a very concise, simple, and easy way to understand. His teaching technique is more effective to beginning MFC programmers of all levels because he explains and shows the transition from core C++ to MFC. You will see a gradual change from core C++ to MFC. Furthermore, he does not go into too much detail of the vase GUI tools that MFC and Win32 API offers. I believe new MFC programmers without Win32 API experience sometimes find the GUI tools overwhelming. This book is a bridge from core C++ to beginning MFC.

I highly recommend Introduction to Programmng MFC with Visual C++.

Kuphryn

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.

Now, ready for jump school, private? You will be on a plane, you will take off, and you will jump. No kidding, this is an MFC assault book for the beginner. You won't believe the ground you've covered in one week. Schedule yourself extra time to play around with the examples provided.

Luckily I read this before Prosise 'Programming MFC' and was glad that I did. This book basically outlined most of what you can do with MFC, Prosise provides the details of how MFC works and what the 'gotchas' are.

If you are shopping and buying TODAY, place this book and Jeff Prosise 'Programming MFC 2nd Ed.' in your cart.

Good luck.

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!!

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.

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.

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.

I wish it were longer, a couple more chapters giving overview on DDX, DDV, ActiveX and COM. Otherwise, I would've given a 5 stars.

If you want something that will get you started with the basics and act as a thorough reference for the future, check out Jeff Prosise's Programming Windows With MFC. Although Prosise's book may seem intimidating at over 1000 pages, it will get you started and keep you going.

It's possible that the level of detail Jones offers is just right for you though. In which case I say, go for it. It may be exactly what you need.

Any time you have a choice of which programming book to buy (i.e. your boss or professor isn't assigning it), go to brick and mortar land or find a friend with the book(s), and make an investment of 15-20 minutes per title and see which one has the content and style that suits you.

My feeling is that Prosise is just as strong on the basics as Jones with plenty of readable examples. Once you get past the basics Prosise's book will provide depth and reference material to keep you busy for a long time.

If you know NOTHING, then this book may be an appropriate starter.

Excellent text, but a pity about the very poor quality cover which is folding and peeling despite my best efforts to preserve it.

My only complaint is that there are a number of typos in it, and a few minor errors in the code examples. This, however, is more a fault with proofreading than with content; if you can forgive the typos you'll be very satisfied with the book.

I read 20 pages of this book the first night I got it, and the next day immediately applied some of what I had learned.

THANK YOU RICHARD JONES!

P.S. This book is full of minor typos. If you can't get over the typos, don't buy it.