C++ In Action: Industrial Strength Programming Techniques (With CD-ROM) [Paperback]

Bartosz Milewski (Author)

Book Description

ISBN-10: 0201699486 | ISBN-13: 978-0201699487 | Publication Date: June 1, 2001

C++ in Action introduces state-of-the-art C++ programming and problem-solving techniques for developing efficient, powerful, scalable software systems. Renowned software architect Bartosz Milewski starts from two key premises. First, programs aren't written for computers: they're written for other programmers who will have to integrate and maintain them. Second, software development languages aren't ends in themselves: they're tools to solve problems. Starting from these principles, Milewski presents a comprehensive guide to C++ software engineering for maximum performance, reliability, and maintainability. He shows how to use resource management and exception management together to build more reliable code. Next, he introduces new techniques that simplify Windows development despite the complexity of the Windows API and libraries. The book also includes detailed coverage of large-scale software and scalability, encompassing development strategies and tactics as well as management, planning, and project dynamics. An accompanying CD-ROM and a companion web site contain an extensive source code library.

Editorial Reviews

From the Inside Flap

Why This BookWhy This Book?

Indeed, why YABOC11 (Yet Another Book on C11)? There are already many excellent books describing all imaginable aspects of C11. As far as learning the language and all kinds of programming tricks, the market is pretty much saturated. This book is not a language reference or a collection of clever tricks and patterns. This book is about programming.

Teaching programming is very different from teaching a language. A programmer is usually faced with a problem that he or she has to solve by writing a program—not with a language feature whose use he or she wants to illustrate. In this book I try to show, as much as possible, how to use the language as a tool to solve programming problems.

I center the presentation around various software projects. In each project I first describe a problem to be solved. Then I discuss what the program should do, what it should look like, and how it should react to user input. Based on that I build a scaffolding that captures the structure of the program without implementing its functionality. Finally, I implement the functionality, component by component.

But programming doesn’t stop there. What follows in this book is a long series of code reviews each followed by a rewrite. "How can this be done better?" is a question a programmer asks himself or herself constantly. And then another question becomes more and more relevant, "How do I write code that can be easily revised?"

In programming, as in life, there is never a single way to do something. That’s why being able to argue about various solutions is extremely important. Programmers who don’t know how to argue end up bitter and frustrated. I remember my own frustrations when faced with an argument like, "Because it’s always been done like this." In this book I argue a lot. I try to find the pros and cons of every solution, and in many cases I manage to settle on something I consider "elegant." However, I never use elegance as an objective criterion. I believe that one can always uncover some very practical arguments that are hidden behind the subjective impression of "elegance." An elegant solution in many cases catches a very good abstraction or generalization. It results in code that is easy to understand, modify, and debug.

Finally, in this book I emphasize the human factor in programming. My credo is "programs are written for programmers, not computers." Programmers want to write better programs not in order to make them more understandable to computers, but to make them more readable to humans. Program maintenance is impossible without program understanding. This may seem like an obvious thing to say, but many programmers overlook this self-evident truth.Why You?

Who are you, the reader of this book? You might be a relative beginner who has picked up some programming but wants to learn C11. You might be a student who wants to supplement his or her college education. You might be a well-trained programmer who is trying to make a transition from the academic to the industrial environment. Or you might be a seasoned programmer in search of new ideas. I hope this book will satisfy you no matter which category you are in.Why Me?

Why should I, of all people, write a book about programming in C11? You, the potential reader of this book, have the right to ask about my credentials, especially because I’m not a computer scientist by education.

I have a Ph.D. in theoretical physics—my thesis was about supersymmetric nonlinear sigma models. I used to be pretty good at calculating supersymmetric Feynman diagrams. Then, around 1986 I fell in love with computers, quit my postdoc position, and began programming.

A physicist is somebody who’s in between a mathematician and an engineer. A physicist is used to constantly moving between theory and practice. He or she is not expected to believe in a theory unless it has proven itself in practice, and will always try to generalize every aspect of experience in order to find an underlying principle. And, most of all, a physicist is not supposed to take anything for granted.

Unlike a mathematician, a physicist has to be more realistic and care more about the process than the formal theory. The process in physics is performing calculations. In programming, it’s software maintenance. So, since I’m a physicist, it should come as no surprise that this book focuses more on rewriting programs than on creating them.

I started teaching C11 and writing this book in 1994, while still working at Microsoft. I took a sabbatical to visit my alma mater, the University of Wroclaw in Poland. It turned out that I would visit that institution several more times, and each visit would prompt me to write a few more chapters. At some point I started converting the book to HTML and posting it on the web. Since C11 was still evolving, I had to rewrite many chapters over and over again. For example, when STL became part of the C11 standard library, I had to go back and rethink the implementation of most code examples in the book.

A lot of techniques described in this book were developed while I was working at Microsoft, designing and leading the development of the Index Server. After that, my new company, Reliable Software, turned out to be a great lab for testing new programming methodologies. All the techniques described in this book have been incorporated into our own products. In fact, we keep rewriting our code every time a new, better idea comes along.

Being a physicist makes me both a good programmer and a bad programmer. Good, because I constantly revise my techniques, search for new generalizations, and discuss every aspect of programming to death. Bad, because when I find a better solution I want to rewrite everything (I will try to convince you that it’s actually not such a bad idea). Managers on my previous jobs always had problems with me, because I questioned every decision, convention, and custom. I hope the same qualities will make me a good writer.

If you, the reader, find a better way of doing something described in this book, please let me know, so I can start rewriting this book for the nth time. My e-mail address is [e-mail]

I am most grateful to my students from the University of Wroclaw and from the Digipen Institute of Technology, because the best way to learn something is to teach it. Thanks go to Professor Jerzy Lukierski, who invited me back to the university to teach computer science. I am also indebted to my coworkers at Microsoft and Reliable Software, who were the first to try and improve many techniques described in this book. My wife, Pam, besides supporting me in all my endeavors, helped me edit the first chapter of this book, making it so much easier to understand. Many thanks to editors from Addison-Wesley, especially Debbie Lafferty. 0201699486P05242001

From the Back Cover

charset=iso-8859-1"> C++ In Action: Industrial-Strength Programming Techniques picks up where the standard tutorial leaves off, providing a fresh pe

C++ In Action: Industrial-Strength Programming Techniques picks up where the standard tutorial leaves off, providing a fresh perspective on the language for both the novice and seasoned C++ programmer. Focusing on programming technique, this book captures the essence of expression in C++, promoting a methodology that delivers robust, reliable, and elegant code.

This project-based tutorial begins with an overview of the language, stressing "conversational C++." Focusing on technique, C++ In Action describes how to avoid pitfalls and how to understand, modify, and debug C++. This book teaches the programmer how to write small, fast, reliable, and scalable programs within a sensible timeframe. In addition, it provides extensive coverage of Windows programming in C++ and the development of large-scale projects with the language.

Throughout this unique and comprehensive guide, the author offers tried and tested techniques for working with C++, including:

* How to make efficient use of the Standard Template Library in C++
* Implementation strategies in C++, including top-down object-oriented implementation
* Plusses and pitfalls of C++ for programmers with C or Java programming backgrounds
* Resource management and the use of exception handling in C++
* Windows programming in C++, including encapsulating the Windows API into C++ classes, namespaces, and templates
* How to refactor your program so that it can be ported from Windows to other platforms such as Linux
* The dynamics of large software project management–from conception to shipment
* How to coordinate the development of a team programming environment in C++

The accompanying CD-ROM contains all of the source code referenced in the book along with the Code Co-op™ serverless version control system (VCS), which will run all of the projects in this book. The companion Web site at relisoft/book contains updates and additional code samples.

Offering a unique perspective on C++, today’s language of choice for general-purpose programming, C++ In Action facilitates the transition from "weekend programmer" to "industrial-strength programmer" in a way no other tutorial can. 0201699486B04172001

See all Editorial Reviews

Product Details

• Paperback: 485 pages
• Publisher: Addison Wesley Publishing Company (June 1, 2001)
• Language: English
• ISBN-10: 0201699486
• ISBN-13: 978-0201699487
• Product Dimensions: 9.6 x 9 x 1.4 inches
• Shipping Weight: 1.8 pounds
• Average Customer Review: 4.4 out of 5 stars  See all reviews (9 customer reviews)
• Amazon Best Sellers Rank: #1,600,914 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

27 of 33 people found the following review helpful:

3.0 out of 5 stars I was very disappointed with this book, August 26, 2001

By 

Zachary Turner (San Francisco, CA) - See all my reviews

Amazon Verified Purchase

This review is from: C++ In Action: Industrial Strength Programming Techniques (With CD-ROM) (Paperback)

I had very high hopes for this book. Moreso than I've had for another book in quite a while. I guess the fact that my hopes were so high is what ultimately led to me being so disappointed. The reason I was so disappointed is not because the content of the book was useless or wrong, but rather because I expected the book to be something it was not. I consider myself a very advanced C++ programmer, and I expected the book to still be able to teach me some new tricks here and there. The ToC seemed to hint that the book was in fact fairly advanced, and covered applications of C++ in real world programming situations which I may not have come across yet. Unfortunately, the book really did not teach me very much. The first half of the book was very odd in my opinion. He went over such basic things as for loops, if else structures, etc, yet by the third chapter he is building a stack based calculator based on an object oriented lexer and parser. I'm not exactly sure who the target audience of this book is. Certainly not for people who have never programmed C++ before, because they would be completely dumbfounded by the speed at which he moves through the basic fundamentals of the language. Yet it can't possibly be for people who have been around the world and back with C++, or even for intermediate C++ programmers, because they know that stuff like the back of their hands. It seems almost like the whole first few chapters are just a primer on basic C++ "because it seems like the cool thing to do". If you actually learn something from that part of the book, the rest of the book will be too advanced for you. And if you understand the rest of the book, the first part will be useless to you. In my experience, any book that tries to be everything to everyone has ended up being a failure, and in my opinion this book is no exception. That being said, the book does cover some very useful techniques and idioms, provided your knowledge of C++ is not too elementary, and not too advanced. I think the entire part of the book devoted to wrapping the Windows API is interesting, but something about it doesn't sit right with me, and I personally don't find it to be useful in the real world in the slightest. So, if you're a beginner don't get this book. If you're advanced don't get this book. But if you're right in the middle you can probably find some useful, applicable information from the middle portion of the book.

3 of 4 people found the following review helpful:

4.0 out of 5 stars Not Big Enough, Not Deep Enough, January 5, 2003

By 

Mohammad B. Abdulfatah - See all my reviews
(REAL NAME)   

Amazon Verified Purchase

This review is from: C++ In Action: Industrial Strength Programming Techniques (With CD-ROM) (Paperback)

For any developer that have had the displeasure of working with Win32 API and/or MFC in C++, this book strikes a very sensitive cord. For the uninitiated, Win32 is an OO programmer's nightmare, and trying to build a decent OO framework on top of it is a Herculean effort that few has dared to attempt. MFC is better, but marginally so, as it ascends Win32 from a nightmare to a very bad dream. The lack of proper standard libraries for other facilities such as threading, sockets, etc. only adds to the hurdles that a C++ developer needs to overcome in order to implement the most trivial functionality in his or her program.

And along comes this book with the attempt to build an OO layer that encapsulates the horrendous details of the Windows API. Of course, only a limited subset of this monolithic API is addressed in the book, which is understandable. One might consider the whole subject of the book a case study rather than a shrink-rapped solution, which is well-worth the time and money spent on it. If you have programmed with either Win32 or MFC before, and have being stung by their awkward design, or lack thereof, then consider this book a mandatory reading assignment.

However, the main problem with this book is that it attempts to be a one-size-fits-all material. The first chapters vainly try to introduce the reader to the C++ programming language. And the remaining chapters are bloated with subsections covering the finer details of the language as they are needed. The whole assumption that a total C++ novice can understand the Win32 API (the problem), the OO layer (the solution), AND the C++ programming language along the way is a very ludicrous one. A novice will struggle endlessly with it, and will ultimately find him or herself given up and reverting to more classical texts on C++ and OOP before being able to stomach reading this book again. Alas, the wasted space on introducing C++ could have been put to better use by adding more depth to the material.

So, you might ask why the four stars. The subject matter is unique and direly needed. And the coverage is adequate if you realistically set your expectations. By all means, buy it and read it. You might find it useful or at least enlightening. I know I did. But don't come unprepared.

4 of 6 people found the following review helpful:

5.0 out of 5 stars this is the one, June 1, 2002

By 

"[e-mail]" (Sydney, NSW Australia) - See all my reviews

This review is from: C++ In Action: Industrial Strength Programming Techniques (With CD-ROM) (Paperback)

This is the ONLY book I could get hold of that actually attacked head-on the problem of using C++ and Windows without abandoning object-oriented design and sanity in coding. Maybe Jeffrey Richter has done something as good - I don't know - but I bet he takes three times as many pages to do it. You can work through this book or just read it but either way, your C++ & Win32 skills will be greatly consolidated.

The associated ReliSoft website is well worth a look, with some lovely sarcasm about MFC that didn't make it into the book (plus extra stuff on threads, etc.)