C++ Gotchas: Avoiding Common Problems in Coding and Design and over one million other books are available for Amazon Kindle . Learn more

Buy New

or
Sign in to turn on 1-Click ordering.
or
Amazon Prime free trial required. Sign up when you check out. Learn more
Buy Used
Used - Good See details
Price: £18.00

or
Sign in to turn on 1-Click ordering.
 
   
More Buying Choices
Have one to sell? Sell yours here
or
Get a £9.50 Amazon.co.uk Gift Card
C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing)
 
 
Start reading C++ Gotchas: Avoiding Common Problems in Coding and Design on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing) [Paperback]

Stephen C. Dewhurst
4.5 out of 5 stars  See all reviews (4 customer reviews)
RRP: £36.99
Price: £31.44 & this item Delivered FREE in the UK with Super Saver Delivery. See details and conditions
You Save: £5.55 (15%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
In stock.
Dispatched from and sold by Amazon.co.uk. Gift-wrap available.
Only 3 left in stock--order soon (more on the way).
Want guaranteed delivery by Wednesday, May 30? Choose Express delivery at checkout. See Details

Formats

Amazon Price New from Used from
Kindle Edition £20.84  
Paperback £31.44  
Trade In this Item for up to £9.50
Trade in C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing) for an Amazon.co.uk gift card of up to £9.50, which you can then spend on millions of items across the site. Plus, get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade-in values may vary (terms apply). Find more products eligible for trade-in.

Frequently Bought Together

C++ Gotchas: Avoiding Common Problems in Coding and Design (Addison-Wesley Professional Computing) + Effective C++: 55 Specific Ways to Improve Your Programs and Designs (Addison-Wesley Professional Computing Series) + More Effective C++: 35 New Ways to Improve Your Programs and Designs (Professional Computing)
Price For All Three: £88.42

Show availability and delivery details

Buy the selected items together


Product details

  • Paperback: 352 pages
  • Publisher: Addison Wesley; 1 edition (26 Nov 2002)
  • Language English
  • ISBN-10: 0321125185
  • ISBN-13: 978-0321125187
  • Product Dimensions: 23.7 x 18.6 x 1.7 cm
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: 354,119 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Stephen C. Dewhurst
Discover books, learn about writers, and more.

Visit Amazon's Stephen C. Dewhurst Page

Product Description

Product Description

C++ Gotchas is the latest addition to the distinguished roster of Addison-Wesley's bestselling programming titles, such as Effective C++ and Exceptional C++. While appealing to the same broad audience of intermediate C++ programmers, this book has a completely different approach. The author presents 99 "gotchas" - common and preventable problems in C++ programming and design. The gotchas run the gamut from minor syntactic annoyances to basic design flaws to psychological behavior. The material has been selected based on the author's extensive experience presenting gotchas in his training classes, speaking engagements, and magazine articles. By learning the lessons in this book C++ programmers will save themselves much time and wasted effort. C++ Gotchas is destined to become an invaluable reference to many programmers.

From the Back Cover

"This may well be the best C++ book I have ever read. I was surprised by the amount I learned."

--Matthew Wilson, Development Consultant, Synesis Software

C++ Gotchas is the professional programmer's guide to avoiding and correcting ninety-nine of the most common, destructive, and interesting C++ design and programming errors. It also serves as an inside look at the more subtle C++ features and programming techniques.

This book discusses basic errors present in almost all C++ code, as well as complex mistakes in syntax, preprocessing, conversions, initialization, memory and resource management, polymorphism, class design, and hierarchy design. Each error and its repercussions are explained in context, and the resolution of each problem is detailed and demonstrated.

Author Stephen Dewhurst supplies readers with idioms and design patterns that can be used to generate customized solutions for common problems. Readers will also learn more about commonly misunderstood features of C++ used in advanced programming and design. A companion Web site, located at http://www.semantics.org, includes detailed code samples from the book.

Readers will discover:

  • How to escape both common and complex traps associated with C++
  • How to produce more reusable, maintainable code
  • Advanced C++ programming techniques
  • Nuances of the C++ language

C++ Gotchas shows how to navigate through the greatest dangers in C++ programming, and gives programmers the practical know-how they need to gain expert status.



0321125185B10212002

Suggested Tags from Similar Products

 (What's this?)
Be the first one to add a relevant tag (keyword that's strongly related to this product)
 
(6)

Your tags: Add your first tag
 


Customer Reviews

3 star
0
2 star
0
1 star
0
Most Helpful Customer Reviews
19 of 19 people found the following review helpful
Format:Paperback
This book presents ninety nine bite-sized nuggets of C++ programming advice, and as such it is very much in the same mold as Exceptional C++ or Effective C++. However it differs from them in several ways. Firstly, is it problem-driven: each nugget consists of a common (or not so common) programming problem, together with a discussion of why it is a problem and how to avoid it. Secondly, it has a more comprehensive and intuitive structure. The issues discussed are divided into nine categories, starting with Basics (eg. excessive commenting, distinguishing between references and pointers) and proceeding through Syntax (eg. "for" statement variable declaration, maximal munch problems); The Preprocessor (avoid it); Conversions (eg. casting, slicing, void*); Initialization (eg. member initialization lists, non-local static initialization order); Memory and Resource Mangement (eg. overloading new and delete, auto_ptr); Polymorphism (eg. overloading vs overriding vs hiding, type codes); Class Design (eg. get/set interfaces, improper operator overloading); and Hierarchy Design (eg. public inheritance for code reuse, cosmic hierarchies). This breadth and organization of subject matter - starting from language basics and moving up to issues of object oriented design - make it feel like a really comprehensive survey of common C++ issues. Necessarily for a book of this kind, it covers much of the same ground as its predecessors, however C++ Gotchas does contain some information that I've not seen elsewhere - the use of translation-unit-local static "Schwarz counters" to control the order of non-local static initialization, for example. Finally, Dewhurst seems to have a slightly less "holier-than-thou" attitude towards programming than some other widely-read authors. Although his book contains the usual exhortations against "excessively clever" programming, he also takes obvious delight in sharing gems such as the fact that the predefined index operator is commutative, so "myIntArray[10]" is exactly equivalent to "10[myIntArray]". Ninety-nine is one of those "suspicious" numbers that makes me think a book has been written for concept rather than content. But not in this case. I recommend it to anyone who regularly programs in C++.
Comment | 
Was this review helpful to you?
4 of 4 people found the following review helpful
Format:Paperback
There are unlikely to be many other C++ books where the word 'ignoramus' appears as often. Dewhurst's writing definitely has character. This book contains 99 items on common mistakes made by C++ programmers, and serves up best practices to replace those bad habits.

Does this sound a bit familiar? Well, yeah, there's substantial overlap with books by Scott Meyers and Herb Sutter, so not every item is a revelation. That said, C++ is sufficiently complicated that I can do with all the help I can get.

However, there isn't any material on templates here, and there's quite a lot of overlap with the author's subsequent book, 'C++ Common Knowledge', which I consider to be superior to this one. So while this is a perfectly good book, I would point you towards C++ Common Knowledge.
Comment | 
Was this review helpful to you?
By A Customer
Format:Paperback
Having read pretty much all of the "how to progam in C++" books, it was time to start on the "how NOT to progam in C++" ones. I was aware of most of the things covered in the book. The two chapters that interested me the most were chaper 5, Memory and Resource Management, and chapter 6 Polymorphism (in particular some of the MI and overriding issues).
Comment | 
Was this review helpful to you?

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Listmania!


Look for similar items by category


Look for similar items by subject


Feedback


Amazon.co.uk Privacy Statement Amazon.co.uk Delivery Information Amazon.co.uk Returns & Exchanges