The Pre-Loved edit from Shopbop
$38.88
FREE delivery Friday, December 6. Details
Or fastest delivery Tomorrow, November 27. Order within 6 hrs 7 mins. Details
Only 1 left in stock - order soon.
$$38.88 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$38.88
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Ships from
five star ten number
Ships from
five star ten number
Returns
Returnable until Jan 31, 2025
Returnable until Jan 31, 2025
For the 2024 holiday season, eligible items purchased between November 1 and December 31, 2024 can be returned until January 31, 2025.
Returns
Returnable until Jan 31, 2025
For the 2024 holiday season, eligible items purchased between November 1 and December 31, 2024 can be returned until January 31, 2025.
Payment
Secure transaction
Your transaction is secure
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Payment
Secure transaction
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Ruminations on C++: A Decade of Programming Insight and Experience 1st Edition

4.5 4.5 out of 5 stars 19 ratings

{"desktop_buybox_group_1":[{"displayPrice":"$38.88","priceAmount":38.88,"currencySymbol":"$","integerValue":"38","decimalSeparator":".","fractionalValue":"88","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"6d6IipPgefCCbGcu1lhjbc11mvd8WajfkQPnj9irwCULmhdw8uO0QEVs0qF2OhZiMUaWonL9%2FOWG50G%2Bj%2B89Y2cG29hl4dSWu0HauVoTmXB2l%2FjEjiX0YsNTG4%2Bw45JyS2QJJB30FPkLRloWDv3VSXxdo1AvtZECXr1bvhAfwg4SO5oruSqC5Pw5psigV0g2","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}]}

Purchase options and add-ons

Ruminations on C++ concentrates on the key C++ ideas and programming techniques - skimming the cream - to let you understand the "why" and not just the "how" of C++ programming. You need not be an expert C++ programmer to find solid fodder here, yet even experts need not fear overgrazing: You will find something worth chewing on in every chapter.
This should be your next C++ book, because it covers a broad range of C++ ideas and techniques, from detailed code examples to design principles and philosophy; shows how to think about programming in C++, not just how to follow rules; explains the motivation behind its examples, sometimes even solving the same problem in two different ways; covers both object-oriented programming and generic programming; and explains the ideas behind the Standard Template Library, which is the most important recent innovation in C++.
This book comes to you from two people who started using C++ when its entire user community could still fit in one room. Both of them have contributed significantly to the evolution of C++.

Amazon First Reads | Editors' picks at exclusive prices

Editorial Reviews

From the Author

As the book's preface notes, `Ruminations on C++' is indeed derived from magazine columns written over the years. The columns originally appeared in the Journal of Object-Oriented Programming (JOOP) and the now-defunct C++ Journal. Despite the reviewer's claim, none of the material comes from C++ Report.

Even if the book were just a collection of reprints, many readers would find it useful--even faithful subscribers to JOOP. However, the book is much more than mere reprints. Every chapter differs substantially from the corresponding column. Some of the differences aid readability or continuity; others add new material. Approximately half of the book's text, including all of chapter 15, is brand new.

From the Inside Flap

OriginsEarly in 1988, about when I had finished writing C Traps and Pitfalls, Bjarne Stroustrup told me that he had just been invited to join the editorial board of a new magazine called the Journal of Object-Oriented Programming(JOOP). The magazine was intended to fit between the conventional academic journals and the magazines that are mostly product reviews and advertising. They were seeking a C++ columnist; was I interested?

C++ was just beginning to become an important influence on the programming community. Usenix had recently held its first C++ workshop, in Santa Fe, New Mexico.They had expected 50 people; more than 200 showed up. Many more would hop on the C++ bandwagon, which meant that the community would need an articulate, reasoned voice to speak against the torrent of hype that was sure to come. It would need someone who could make clear the difference between hype and substance and keep a cool head in all the turmoil. I took the offer anyway.

I am writing these words while thinking about my sixty-third column for JOOP. The column has appeared in every issue but two, during which time I badly needed a break and was lucky enough to be able to get Jonathan Shopiro to take my place. On a third occasion, I wrote only the introduction to the column, stepping aside for the distinguished Danish computer scientist Bjorn Stavtrup. In addition, Livleen Singh talked me into writing a column for the quarterlyC++ Journal, which lasted six issues before folding, and Stan Lippman cajoled me into doing a column for the C++ Reportwhen it changed from a newsletter into a full-fledged magazine. Adding my 29 C++ Reportcolumns to the others brings the total to 98.

That's a lot of stuff to be scattered in periodicals all over the place.If the articles are useful individually, they should be evenmore useful when collected.In consequence, Barbara and I (mostly Barbara) have gone back over the columns, selected the best, and added to or rewritten them as needed for coherence and continuity. Just what the world needs--another C++ book

Now that you know why the book exists, let me tell you why you should read it instead of some other C++ book. Goodness knows, there are enough of them; why pick this one?

The first reason is that I think you'll enjoy it. Most C++ books don't have that in mind: They are curriculum-based. Enjoyment is secondary at best.

Magazine columns are different. I suppose there must be some people out there who thumb through a copy of JOOPin a bookstore and skim my column before deciding whether to buy the magazine, but it would be arrogant to think that there are more than a few. Most readers will be seeing my column after they've already paid for it, which means that they have a completely free choice about whether to read it or not. So each column has to be worth reading on its own.

This book contains no long, boring discussions of obscure details. Beginners are not intended to be able to learn C++ from this book alone. A few people, who already know several programming languages thoroughly, and who have figured out how to infer the rules for a new language by reading code, will be able to use this book to get an overview of C++. Most readers starting from scratch would do well to read The C++ Programming Language(Addison-Wesley 1991)by Bjarne Stroustrup, or Stan Lippman's C++ Primer(Addison-Wesley 1991), and then read this book.

This is a book about ideas and techniques, not details. If you want to find out how to make virtual base classes do double reverse backflips, you will have to turn elsewhere.What you will find here is lots of code to read.Try the examples for yourself. Classroom experience indicates that getting these programs to run and then modifying them is a good way to cement your understanding. For those who prefer to start with working code, we have made available selected examples from the book by anonymous FTP from ftp.aw in directory cseng/authors/koenig/ruminations.

If you know some C++ already, I think that this book will not only entertain but also enlighten you. This is the second reason to read it. My intent isn't to teach C++ per se. Instead, I want to show you how to think about programming in C++, and how to look at problems and express a solution in C++. Knowledge can be acquired systematically; wisdom cannot.OrganizationAlthough I intended each column to stand alone, I believe that the collection will be easier and more enjoyable to read when grouped by concept. The book is therefore divided into six parts.

Part I is an extended introduction to themes that will pervade the rest of the book. You won't find much code, but the ideas of abstraction and pragmatism explored there underlie both this book and, more important, the design of C++ and strategies for its effective use.

Part II looks at inheritance and object-oriented programming, which most people think are the most important ideas in C++. You will learn why inheritance is important and what it can do.You will also learn why it can be useful to conceal inheritance from its users and when to avoid inheritance altogether.

Part III explores templates, which I think constitute the most important idea in C++. The reason I think templates are so important is that they provide a particularly powerful kind of abstraction. Not only do templates allow the construction of containers that know almost nothing about the types of what they will contain, but they make it possible to abstract away things far more general than just types.

One reason that inheritance and templates are important is that they are ways of extending C++ without waiting (or paying) for people to produce new languages and compilers. The way to organize such extensions is through class libraries. Part IV talks about libraries--both their design and use.

With the basics well understood, we can look at some specialized programming techniques in Part V. Here you will find ways to tie classes inextricably together, as well as ways to keep them as far apart as possible.

Finally, in Part VI, we turn back for a last look at the terrain we have covered. Compilation and editing One artifact of these papers having been written over a number of years is that they do not always use all the current features of the language.This raises a problem: Do we rewrite the columns as if full-fledged ISO C++ were the norm when the standard hasn't been approved yet?Or do we deliberately write in an archaic style?

As with so much else in C++, we compromised. Where the original column was simply incorrect--either in light of how the language has changed since the column was written or because of a change in our understanding of how things should be--we'vefixed it. A particularly pervasive example is our use of const the importance of which has steadily grown in our understanding since const entered the language.

On the other hand, for instance, lots of examples here use int to represent true or false values, even though the standards committee has accepted bool as a built-in data type. The reasoning is that the columns were written that way originally, using int for such values will still work, and it will be years before most compilers support bool. AcknowledgmentsIn addition to publishing our ideas in JOOP, the C++ Report, and the C++ Journal, we refined them through giving talks (and listening to students) in many places. Particularly noteworthy were the conferences organized by the Usenix Association and by SIGS Publications, publishers of JOOPand the C++ Report. In addition, there are the weeklong courses that the two of us have taught at Stanford University under the auspices of the Western Institute in Computer Science, and at Bell Labs for members of the Acoustics Research Laboratory and Network Services Research Laboratory, as well as several courses and lectures that Dag Bruck, then at the Department of Automatic Control at the Lund Institute of Technology and now at Dynasim AB, organized in Sweden.

We are also grateful to the people who read and commented on drafts of the book and the columns that it comprises: Dag Bruck, Jim Coplien, Tony Hansen, Bill Hopkins, Brian Kernighan (who gets extra credit for reading the entire book twice carefully with pen in hand), Stan Lippman, Rob Murray, George Otto, and Bjarne Stroustrup.

The columns would never have become a book without the help of Deborah Lafferty, Loren Stevens and Tom Stone at Addison-Wesley, and the copy editing of Lyn Dupre.

We are particularly grateful to the enlightened managers at AT&T who made it possible to write these columns and to compile this book, including Dave Belanger, Ron Brachman, Jim Finucane, Sandy Fraser, Wayne Hunt, Brian Kernighan, Rob Murray, Ravi Sethi, Bjarne Stroustrup, and Eric Sumner.

Andrew Koenig
Barbara Moo
Gillette, New Jersey
April, 1996
0201423391P04062001

Product details

  • Publisher ‏ : ‎ Addison-Wesley Professional; 1st edition (January 1, 1996)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 380 pages
  • ISBN-10 ‏ : ‎ 0201423391
  • ISBN-13 ‏ : ‎ 978-0201423396
  • Item Weight ‏ : ‎ 1.15 pounds
  • Dimensions ‏ : ‎ 6.5 x 0.75 x 9.25 inches
  • Customer Reviews:
    4.5 4.5 out of 5 stars 19 ratings

Customer reviews

4.5 out of 5 stars
19 global ratings

Top reviews from the United States

Reviewed in the United States on June 25, 2019
Reviewed in the United States on April 25, 2016
Good book.
Reviewed in the United States on August 23, 2000
While this book came out before the ISO C++ (99) standard was finalized it still has a lot of relevant material in it. It is clearly presented, and the underlying design choices are explained and expanded on.
A word of caution, the topic on Smart pointers is interesting, but don't just copy it out, get a tested version from the C++ library "boost". Its like the string class every text seems to use, copy it, use it to learn from but don't use it in an actual project. You'll just have to go through the debugging process that everyone else has already done.
This book focuses on C++ Design and that is a hard subject to teach well. The mechanics of the language are much easier to master, the putting it all together in the correct way is what this book focuses on.
I'd also like to say that I think this book is better written than any of the C++Report articles that A.Koening wrote. My guess is that the review process is more stringent and he and B. Moo had more time to work the text over. In any case it is one of the easier to understand and read intermediate level C++ books.
15 people found this helpful
Report
Reviewed in the United States on August 18, 2000
Nestled between 'learn in 24 hour' books, uml tomes, and vc references is a smallish, silly looking book called Ruminations on C++. At first glance you may be nervous as you find cows on the cover, but this gem is one of the best programming books I've every enjoyed. This book is targeted to the intermediate C++ programmer who has mastered syntax and basic idioms, and wants to move beyond into more complex uses. The book introduces (some may say, pounds) the concept of smart pointers, containers and iterators, templates, and function adapters in a ah-ha! enlightening kind of way. Once you understand these concepts and start employing them in your programs, you'll wonder how you could have ever written programs without them. Some readers may be bothered by the fact that the chapters are 'regurgitations' of previous articles the writer had written, but I would highly recommend that you pick this up. The treatment on the SmartPointer alone is worth the price. Buy it now!!
19 people found this helpful
Report
Reviewed in the United States on February 24, 2007
I was keen to read this expanded and edited collection of columns, given the high quality of the authors' Accelerated C++. This is not quite as good as that book, but it's held up better than some of its contemporaries, like Carroll and Ellis's Designing and Coding Reusable C++.

The chapters are quite short, but they feel cohesive and flow well. The early part of the book is perhaps the most dated. There are discussions of implementing a string class and handle classes - they're treated well, but it's likely you've seen this several times before. Also, I didn't find the 'string picture' chapters, designed to illustrate class design, terribly interesting or illuminating of the underlying principles of object orientation (I didn't like them much in Accelerated C++ either).

However, the section on templates remains relevant, and the discussion of function objects and generic programming is a very good introduction. The later chapters on API design also retain insights. And in particular, the chapter on stream manipulators is very cool. It's also very good at discussing implementation and design issues and the thought processes that go into them. The feel is of someone talking you through how they went about writing some useful C++ and the trade offs involved.

In summary, this is a little dated, but it still has some bits and pieces that you won't find elsewhere. Not one to own at all costs, but keep an eye out for a cheap second hand copy, and when the price is right, pounce.
2 people found this helpful
Report
Reviewed in the United States on December 2, 1999
"Ruminations..." is among my favorite C++-oriented books. If you've read a few articles by Koenig (and sometimes Moo) in JOOP, C++ Report, or elsewhere you'll have a good idea for what to expect here. The problems are practical, the writing is clear, and the analysis is thorough. Code is not sanctioned to sidebars or mammoth examples in this book; it's an interwoven part of the discussion, and it evolves as solutions are explored. You might learn more about the standard C++ library by reading this book than many of the "STL" books out currently available. If you're new to C++ you should start elsewhere, otherwise this book deserves your attention.
9 people found this helpful
Report
Reviewed in the United States on June 9, 1999
A book for the knowledgable C++ programmer who seeks greater insight in programming, design and C++. It goes beyond programming constructs and specific methodologies, covering a very wide range of programming problems and their solutions. Based on magazine columns, the revised and extended material is presented in an unusually readable style. This is a book you will return to many times, just for the joy of it.
7 people found this helpful
Report
Reviewed in the United States on February 2, 2009
For starters this book was way beyond my level when I got it and am still struggling to implementing many of the ideas contained in Ruminations. I am not fond of the explnations of what not to do. The material is as dense as Acclerated C++. As it has been stated this book came out before the STL was fully devloped so some of the chapetrs could use revising. This is one of the few books that is a practicle guide to advanced programming. My main complaint about the authors is their unique practicle way of teaching C++. I would like to see more examples of how to implemet OOP concepts in C++.
One person found this helpful
Report

Top reviews from other countries

Translate all reviews to English
Amudhan Shankar Narayanan
4.0 out of 5 stars Review
Reviewed in India on December 27, 2023
Good
Maciej Kania
5.0 out of 5 stars Excellent C++ book
Reviewed in Germany on December 9, 2019
I read it after I completed the "Accelerated C++" book, which looks to me like a very good revision of the topics covered there.
陳 東昇
4.0 out of 5 stars 日本語版絶版
Reviewed in Japan on July 8, 2020
まだ英語版の新品が残っているので、ラッキーです。
内容は古くなったいますが、読む価値がまだあります。