Enter your mobile number below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
Getting the download link through email is temporarily not available. Please check back later.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Taming C++: Pattern Classes and Persistence for Large Projects

4.5 out of 5 stars 2 customer reviews
ISBN-13: 978-0201528268
ISBN-10: 0201528266
Why is ISBN important?
This bar-code number lets you verify that you're getting exactly the right version or edition of a book. The 13-digit and 10-digit formats both work.
Scan an ISBN with your phone
Use the Amazon App to scan ISBNs and compare prices.
Have one to sell? Sell on Amazon
Buy used
In Stock. Sold by Better World Books: West
Condition: Used: Acceptable
Comment: Shows definite wear, and perhaps considerable marking on inside. 100% Money Back Guarantee. Shipped to over one million happy customers.
Access codes and supplements are not guaranteed with used items.
20 Used from $0.01
+ $3.99 shipping
More Buying Choices
8 New from $35.35 20 Used from $0.01
Free Two-Day Shipping for College Students with Prime Student Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student

ITPro.TV Video Training
Take advantage of IT courses online anywhere, anytime with ITPro.TV. Learn more.
click to open popover

Editorial Reviews

From the Inside Flap

Along with many other managers and software designers, I am painfully aware of the problems software engineering is facing today. This book presents design and coding techniques which can lead to an improvement in both productivity and quality of the resulting software, especially on larger projects. The book deals with the basic questions of class design and interaction, and it should be of interest to students and experts alike. Numerous examples demonstrate the ideas, with emphasis on complex problems which occur in real-life applications. You should have at least some knowledge of the C++ language before you start to read; this is not a C++ textbook.

This text evolved through several stages before it took on the form presented here. Starting from my observation that a number of negative experiences with early C++ projects were caused by poor class organization, I originally planned to focus the book on C++ and large projects. The idea was to discuss code organization issues that do not show up in small examples usually published in books. Later on, I decided to include a discussion of data persistence, because most larger projects need this difficult-to-implement feature and there is a close connection between pointer-based data structures and persistent data.

During the initial planning of the book, my friend Craig Hubley suggested that several case studies describing technical details of large application projects would be of interest to many readers, and would complement the text well. Three coauthors willing to contribute large case studies on interesting commercial projects joined the project: Jim Coplien (AT&T prototype switching system), Rob Bartel (Mentor Graphics CAD database), and Bill Welch (Wall Street financial application). However after the first drafts were in we discovered that we were emphasizing entirely different issues--from the organization of C++ code to the organization of human groups--and we abandoned the idea of collaborating.

The discussions with the three would-be coauthors greatly improved my original text and caused me to add entire chapters, and many examples, and to more thoroughly explain many other parts. Thanks to these discussions I was motivated to collect six shorter application studies which would demonstrate the use of programming techniques described in the book. These short case studies eventually became Chapter 9. The text was also enhanced by the comparison of two different library styles, including an example coded by Keith Gorlen (now Section 6.3). The title gradually evolved to C++, Large Projects, and Persistent Data.

The final stage began with an observation from Marjan Bace of Manning Publications that there may be similarities between what I was calling data organization and the concept of design patterns recently discussed at the OOPSLA conferences and in a couple of soon-to-be-published books. It turned out that he was right. The two concepts that are soon to be published are very close, though not identical. However, I could not find in the literature anything equivalent to what I originally called hyper-class: a special class which represents an entire pattern. This lead to further research and private discussions with Ralph Johnson, Erich Gamma, Bruce Anderson, Craig Hubley, and many others. Thanks to their generous input, I was led to the final form in which to present pattern classes (Section 2.5 and 2.6) as well as to the final title.

A discussion with Trygve Reenskaug of Taskon in Norway, centered on the differences in approaches to programming in C++ and in Smalltalk. From this comparison, we hoped to discover possible ways to improve the C++ coding style. The idea sounded interesting, and with Trygve's and Craig's help, we added Section 6.4, including a full Smalltalk example.

The main advantage of pattern classes is the de-coupling of application classes. In situations that traditionally lead to large clusters of mutually dependent classes (traditional frameworks), pattern classes allow you to test and compile most classes independently. Also, each pattern can be tested as an independent unit.

This book combines ideas from different software fields, and contains numerous nontrivial examples. You will discover several common denominators: Class organization and communication (patterns), class relations, and the management of pointers. Even though this book took more work than a volume of its length should take, it was fun to write. I hope you'll find it equally entertaining to read. I tried not to hide controversies where they exist, and to be honest about problems that have not yet been solved.

I would like to thank Marjan Bace for his patience, understanding, new ideas, continuous support, and guidance; Craig Hubley for his readiness to help with many technical problems; and Judy Melanson for her able text processing and formatting. I would also like to thank all three reviewers of the final manuscript, Delano C. Stevens (GTE), William E. Bulley (Ann Arbor Computer), and Ed Schiebel (AT&T Bell Laboratories) for their valuable comments, as well as Margaret Marynowski and Maryla Sikora for their fine work in copyediting the manuscript and typesetting the book. Some readers may not be aware that the production of most books involves entire teams of dedicated specialists who, often anonymously, contribute a great deal of experience and effort to the product which, in its final form, carries only the author's name. This book is no exception. This entire project would have been impossible without the support of my programming family. My son Martin edited both versions of the entire manuscript and, without a single complaint about my excessive working hours, my wife Hana helped me by discussing countless technical and conceptual issues that arose in the project. Addison-Wesley has provided an e-mail address for communication with the author, or if you would like to be placed on a mailing list. Please send mail to soukup@aw. Code from this book is also available via ftp aw in the directory awputer.science.soukup, or on a diskette from Addison-Wesley.

Jiri Soukup 0201528266P04062001

From the Back Cover

issue in large project development, in testing, and in maintenance. Taming C++ takes a fresh look at the complex organization typical for large C++ systems and shows how this problem can be minimized by avoiding cyclic dependencies between classes, and by implementing the original object-oriented design so that it remains visible in the final code. This book shows you, through extensive examples, how to design and write C++ code using a new type of class--the pattern class--which helps you produce layered class organization with limited cyclic dependencies. The book then focuses on another problem of large project development--persistent data--integrating it with its general approach and providing copious implementation details unavailable elsewhere.

  1. Emphasizes code readability achieved through better class organization.
  2. Teaches how to improve software architecture.
  3. Shows how pattern classes encapsulate the high level object-oriented design.
  4. Promotes layered structuring of class relationships.
  5. Compares and contrasts design methodologies, class libraries, approaches to testing, and treatments of persistence.
  6. Explains how persistent data can be used as fast databases (frameworks) residing virtual memory.
Taming C++ is written for programmers, designers, and software managers. It will also be useful to applications developers, researchers, and advanced students. While the techniques presented here can improve any application, they are specifically important for large projects.

Programs from this book can be accessed via anonymous ftp at: ftp aw.com under aw.computer.science in a file entitled soukup; the code is also available on disk from Addison-Wesley Publishing Company; send requests to soukup@aw.com. Comments to the author can also be sent to this same address.



New York Times best sellers
Browse the New York Times best sellers in popular categories like Fiction, Nonfiction, Picture Books and more. See more

Product Details

  • Hardcover: 432 pages
  • Publisher: Addison-Wesley Pub (Sd) (June 1994)
  • Language: English
  • ISBN-10: 0201528266
  • ISBN-13: 978-0201528268
  • Product Dimensions: 1 x 8 x 9.8 inches
  • Shipping Weight: 1.5 pounds
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Best Sellers Rank: #4,993,508 in Books (See Top 100 in Books)

Customer Reviews

5 star
4 star
3 star
2 star
1 star
See both customer reviews
Share your thoughts with other customers

Top Customer Reviews

By A Customer on October 4, 1999
Format: Hardcover
It is a great book but certainly not for beginners. Explains a new concept of Pattern Classes which encapsulate design patterns. One thing missing is however that the book should have given the details of the patterns by the author, in a more organized manner. They are haphazardly spread through the book. (Not really that haphazard but actually, difficult to find unlike the Gamma et. all book which describes the patterns in a catalogue form.
Comment 3 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
By A Customer on May 10, 2004
Format: Hardcover
Easily the best programming book I have read in years. Takes a hard look at structuring very large scale programs into class and data / object relationships to remove 'spagetti object' coding style that is so prevelant in many C++ programs existing today. Since 1997, I have directly implemented many of the techniques discussed into my object library, and the payoff is tremendous. Needs a careful and thoughtfull reading; the more experience you have, the more this makes since. It is way beyond, and in an oppisite direction, of what college teaches.
Comment One person found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse