Enjoy fast, free delivery, exclusive deals, and award-winning movies & TV shows with Prime
Try Prime and start saving today with fast, free delivery

List Price: $59.99 Details

Save: $9.00 (15%)

FREE Returns

FREE delivery Friday, December 15

Or fastest delivery Wednesday, December 13. Order within 18 hrs 14 mins

Arrives before Christmas

Select delivery location

In Stock

$$50.99 () Includes selected options. Includes initial monthly payment and selected options. Details

Ships from

Amazon.com

Ships from

Amazon.com

Sold by

Amazon.com

Sold by

Amazon.com

Returns

Returnable until Jan 31, 2024

Returns

Returnable until Jan 31, 2024

For the 2023 holiday season, eligible items purchased between November 1 and December 31, 2023 can be returned until January 31, 2024

Read full return policy

Payment

Secure transaction

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

Details

Add a gift receipt for easy returns

FREE delivery Friday, December 15

Or fastest delivery Wednesday, December 13. Order within 18 hrs 14 mins

Arrives before Christmas

Select delivery location

Used: Acceptable | Details

Sold by Dream Books Co.

Fulfilled by Amazon

Access codes and supplements are not guaranteed with used items.

Follow the author

Kurt Guntheroth

Follow

Optimized C++: Proven Techniques for Heightened Performance 1st Edition

by Kurt Guntheroth (Author)

3.7 31 ratings

See all formats and editions

Price

New from

Used from

Kindle

"Please retry"

$38.49

—

Paperback

"Please retry"

$50.99

$42.75

$30.52

Kindle
$38.49 Read with our free app
Paperback
$41.52 - $50.99

16 Used from $30.52 16 New from $42.75

{"desktop_buybox_group_1":[{"displayPrice":"$50.99","priceAmount":50.99,"currencySymbol":"$","integerValue":"50","decimalSeparator":".","fractionalValue":"99","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"hlq6rQhPDxnTGsrFO6hLueemjZ3vzEz2gHcBYQq5Q8i6E82P2zxtuOBwPGbL2dcCCx656MTuwbzI%2FH4wQ7y5cm%2BxxaYyRqxbEE0MsXr%2BOAzVj%2Bv%2ByV7elPhZzGzuTA90aQu%2FDTCtkvPjlHqqYKM6rQ%3D%3D","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$41.52","priceAmount":41.52,"currencySymbol":"$","integerValue":"41","decimalSeparator":".","fractionalValue":"52","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"hlq6rQhPDxnTGsrFO6hLueemjZ3vzEz25bns2Dft8ZOxRjd4A2NTBeQokrJ1CMMJxnfNqCogfm1ilGqrnU17DVrIvyrpNlEPWGdX9oH9OSd%2Bt4ninu1toHJF3ieyTgnsZKTPvv6spofZxKwWoELfdmf9GkCYeDZZ%2FfwPfSw55tQLvrWo5AHz2g%3D%3D","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}]}

Purchase options and add-ons

In today’s fast and competitive world, a program’s performance is just as important to customers as the features it provides. This practical guide teaches developers performance-tuning principles that enable optimization in C++. You’ll learn how to make code that already embodies best practices of C++ design run faster and consume fewer resources on any computer―whether it’s a watch, phone, workstation, supercomputer, or globe-spanning network of servers.

Author Kurt Guntheroth provides several running examples that demonstrate how to apply these principles incrementally to improve existing code so it meets customer requirements for responsiveness and throughput. The advice in this book will prove itself the first time you hear a colleague exclaim, “Wow, that was fast. Who fixed something?”

Locate performance hot spots using the profiler and software timers
Learn to perform repeatable experiments to measure performance of code changes
Optimize use of dynamically allocated variables
Improve performance of hot loops and functions
Speed up string handling functions
Recognize efficient algorithms and optimization patterns
Learn the strengths―and weaknesses―of C++ container classes
View searching and sorting through an optimizer’s eye
Make efficient use of C++ streaming I/O functions
Use C++ thread-based concurrency features effectively

ISBN-10

9781491922064
ISBN-13

978-1491922064
Edition

1st
Publisher

O'Reilly Media
Publication date

2016
June 14
Language

EN
English
Dimensions

7.0 x 0.9 x 9.2
inches
Length

385
Pages
See all details

Frequently bought together

Optimized C++: Proven Techniques for Heightened Performance

$50.99

Get it as soon as Friday, Dec 15

In Stock

Ships from and sold by Amazon.com.

+

$68.09

Get it as soon as Thursday, Dec 14

In Stock

Ships from and sold by Amazon.com.

+

Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14

$42.22

Get it as soon as Friday, Dec 15

Only 19 left in stock (more on the way).

Ships from and sold by Amazon.com.

Total price:

To see our price, add these items to your cart.

Try again!

Details

Added to Cart

Some of these items ship sooner than the others.

Show details Hide details

Choose items to buy together.

Scott Meyers
1,065
Paperback
47 offers from $22.63
Fedor G. Pikus
63
Paperback
13 offers from $27.97
Bjorn Andrist
148
Paperback
1 offer from $59.99
Klaus Iglberger
66
Paperback
26 offers from $40.23
Peter Gottschling
22
Paperback
18 offers from $38.55
Viktor Sehr
57
Paperback
19 offers from $28.83

Editorial Reviews

About the Author

A career technologist with broad experience in software development, Kurt has exceptional experience and skills in early stages of product development including market research, user needs analysis, and architectural design. In addition, Kurt has very deep C++ development experience. He currently works as a Software Engineer at iStreamPlanet.

Product details

ASIN ‏ : ‎ 1491922060
Publisher ‏ : ‎ O'Reilly Media; 1st edition (June 14, 2016)
Language ‏ : ‎ English
Paperback ‏ : ‎ 385 pages
ISBN-10 ‏ : ‎ 9781491922064
ISBN-13 ‏ : ‎ 978-1491922064
Item Weight ‏ : ‎ 1.46 pounds
Dimensions ‏ : ‎ 7 x 0.88 x 9.2 inches

Best Sellers Rank: #2,122,308 in Books (See Top 100 in Books)
- #545 in C++ Programming Language
- #907 in Object-Oriented Design
- #2,572 in Software Development (Books)

Customer Reviews:
3.7 31 ratings

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Videos

Help others learn more about this product by uploading a video!

Upload your video

Important information

To report an issue with this product, click here.

About the author

Follow authors to get new release updates, plus improved recommendations.

Kurt Guntheroth

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read author blogs and more

Customer reviews

3.7 out of 5

31 global ratings

How customer reviews and ratings work

Sort reviews by

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Dave from Somerville MA

Excellent book, but not for the faint of heart.

Reviewed in the United States on August 13, 2016

Verified Purchase

Best book I've read on C++ since the Scott Meyers canon. It is well written and PACKED with technical knowledge. Clearly, Guntheroth is a seasoned developer who has done a good job of selecting the pertinent items about optimization and left out the mundane from this book. As an embedded C++ developer, the topics are right on point, well discussed, and thoroughly explained. This book goes deep and is not for the faint of heart. I would recommend this book to those who have already read Meyers and Stroustrup books and I would recommend reading this BEFORE reading Alexandrescu.

18 people found this helpful

Helpful

SI

Nod bad but could be better

Reviewed in the United States on October 10, 2018

While reading this book, I got a feeling that there IS real experience behind it, and experience is the only thing which matters for such dark magic thing as optimization. In particular, emphasis on memory accesses being expensive is EXTREMELY important in real world, and is well-covered in the book, kudos! Also, the book doesn't degenerate into a messy unstructured list of unrelated techniques and at least tries to put it into perspective.

OTOH, sometimes this real experience is a bit, well, stale. For example, for measuring time intervals the book states that "on PCs, the fastest tick counters available have 100-nanosecond resolution" - which isn't true even for Windows which corresponding section heavily leans to (there is RDTSC instruction with ~1ns resolution for about 20 years now on all what can be named PC). In another example, in the whole chapter dedicated to strings I didn't find a reference to Small String Optimization (SSO), which is a reality for 5+ years now, and which changes performance analysis significantly. Advice "perform I/O in a separate thread" is also outdated in the modern days of generally-better-performing async I/O (at the very least, async I/O should be mentioned in this context).

Overall, I'd give this book 3.5 stars, but there is no such option - and given that books with real-world experience are rare, I decided to round it up rather than down.

4 people found this helpful

Helpful

Z Beck

Lacking the content and depth I was hoping for

Reviewed in the United States on February 7, 2017

Verified Purchase

A lot of the concepts don't have enough support or their support is not concrete enough. For example, the author describes the cost of function calls, including the hidden pointer to the "this" argument for member function calls that must be written to the stack or a register. For that reason, he encourages the use of static functions were possible. To me that's not enough of an explanation. I would have listed the number of registers available, including a discussion of how it's 32/64 bit and OS-dependent: 32-bit always pass parameters on the stack, 64-bit Windows passes the first four parameters in registers and 64-bit linux/BSD/MacOS pass 14 in registers (six of which can be pointers). -- Without this level of explanation, I found myself questioning the validity of some of the other proposed optimizations.

A few concepts I was hoping for are missing, including vectorization (SSE, AVX), which is mentioned only in passing; more depth to floating point arithmetic; better discussion of memory and cache access patterns (the handling of the CPU cache in particular is so vague that there's no takeaway message that I could apply to my code); ...

Meanwhile, there's an excessive amount of time spent on a handful of topics, including timers (why are sundials and grandfather clocks given full paragraphs?) and, as others have said, the C++ language itself.

I was hoping this book would be a reference guide once I'd finished reading it, but a lot of the material wasn't quite concrete enough for it to be useful. I would highly recommend reading Agner's manuals instead if you have knowledge of C++ already. In some places they're a little bit dated but still solid and very much grounded in computer architecture. (Do a search, they're free online.)

27 people found this helpful

Helpful

luncliff

Five Stars

Reviewed in the United States on October 13, 2016

Verified Purchase

Useful guidelines, check-list for intermediate C++ programmer!

One person found this helpful

Helpful

Nathaniel Higgins

For the love of God, don't learn from this book

Reviewed in the United States on November 24, 2023

I'll give it two stars because I did learn some important concepts after all. I would strongly advise against getting into this book if only for the fact that it's written by a complete scumbag.

Helpful

Igor Hersht

I would call this book “Optimized C++ for beginners from ...

Reviewed in the United States on January 2, 2017

Verified Purchase

I would call this book “Optimized C++ for beginners from beginner. “ There are 2 main problems in this book.
1. It is really for people who does not know C++. Literally half of the book is explanation what is std::string and” don’t do too much in the loop”.
2. It seems to me author himself does not understand relatively basic things about C++ optimization ( e.g. why binary search on sorted array could be faster than hash map ). Some statement such as “always move declaration of a variable out of the loop” is just incorrect.
Advise for beginners – don’t buy this book. Learn from experts: Scott Meyers, Nicolai M. Josuttis, Antony Williams, Andrei Alexandrescu, Herb Sutter …

41 people found this helpful

Helpful

Shahzad Aslam-Mir

Unusually good

Reviewed in the United States on May 21, 2016

I bought this book in rough cut form and watched it develop. The book is unusual and good IMHO, it has some really great analyses of container algorithm performance comparison and provides good specific guidance on algorithm and container use. It has been a joy to read and learn from. I liked the separation of discussion of optimizing data structures versus optimizing your use of containers. Chapter 6,7,8 are wonderful educating reads.

14 people found this helpful

Helpful

tiger taco

Not deep enough given the subject

Reviewed in the United States on October 22, 2016

Verified Purchase

It's not bad but it's one of those books you read and at the end don't fully understand what you learned. The best example of this phenomenon is reading a dictionary - you read entire dictionary but still don't have a clue how to speak the language. This happens when connections between concepts are not elucidated enough.

11 people found this helpful

Helpful

Top reviews from other countries

Translate all reviews to English

Adam Fowler

Very details, and covers C++14

Reviewed in the United Kingdom on May 20, 2016

Verified Purchase

Really liking this book. Goes in to great detail. Sometimes a little too much about very specific things, hence only 4 stars, but these areas are easy to skip over. Should be required reading for all C++ coders. Does include the latest C++14 alterations.

3 people found this helpful

Client d'Amazon

Disappointing

Reviewed in France on May 19, 2018

Verified Purchase

I was hoping for a book tackling mostly C++-specific issues, and in depth. It turns out the book has a lot of generic advice, such as "optimize hot loops" or "use a thread pool rather than launch a new thread every time".

There is some interesting discussion of some C++-specific aspects, but not often in a very thorough or consistent manner. In the chapter about standard containers, the author gives a bunch of performance figures measured with some benchmark of his own, but the source code for the benchmark is unavailable, so you cannot try with your own compiler and standard library. Knowing that this or that has lackluster performance on Visual Studio 2015 doesn't help much if I'm targetting gcc 6 with the GNU libstdc++ on Linux.

In the part about memory management, there is this very vague statement "I have heard a rumor that both Windows and Linux have recently raised their game with state-of-the-art memory managers". Well... ok, you've heard a rumor, but you're writing and selling a book about optimized C++, so perhaps you should have gone and validate what the rumor says? I don't buy a specialized, technical book to learn about unconfirmed rumors!

As a more minor issue, I'm surprised that the author spends time discussing pre-C++11 idioms. This, in a book published in 2016.

I'm not a veteran C++ programmer, yet I feel I learnt too little by reading this book.

2 people found this helpful

Translate review to English

Aldo Quelopana

Great Book!

Reviewed in Canada on October 18, 2021

Verified Purchase

This is book presents all the topics that I was looking for. I wasn't sure about buying it because of some of the comments that I saw here, but after reading it, I learned a lot about improving my code. The book is easy to understand and explains the concepts/tricks well.

A reader

Too much useless and incorrect information, and not enough useful information

Reviewed in the United Kingdom on May 19, 2019

Verified Purchase

Unfortunately, this book suffers from a few significant problems.

First, the author writes extensively (probably about half of the book in total) on basic C++ concepts that most readers should already know and/or concepts that are irrelevant to the topic of the book.

Second, when the author tries to provide potentially useful information, he discusses the topic in an inadequate way that is likely to leave readers scratching their heads in confusion.

Third, more than a few times the author wrote something that I knew to be incorrect or misleading.

Here are some examples of those second and third problems...

On pages 84-85, the author advocates the use of std::stringstream, but neglects to mention that this class performs lots of work in its constructor (apparently something to do with locales). I once obtained a significant optimisation in an application by removing as many instances of stringsteam as I could.

On page 97, the author advocates use of hash tables but neglects to mention that the heap allocation used in most hash table implementations is likely to increase cache misses (and hence reduce performance). He neglects to mention that there are some implementations of hash tables that use a large block of contiguous memory to be more cache friendly. (Do an Internet search for "flat hashmap" if you are interested in efficient hash tables.) The author mentions that a hash table lookup is O(1) in the common case and O(N) in the worst case, but never mentions the possibility of using a DFA, which is always O(1) lookup. Put simply, a DFA can be faster than a hash table, and this contradicts the author's claim that hash tables provide the fastest table lookup mechanism. The discussion on page 97 about hash tables would have benefited from mentioning the possibility of perfect hashes, but readers have to wait more than 100 pages (until page 224) for a mention of this.

On pages 123-124, the author mentions the possibility of storing a balanced binary tree in a contiguous array rather than in fragmented heap-allocated memory. This is a potentially useful thing to know but, unfortunately, the discussion of this topic is too superficial to be useful. In addition, he conflates two different opportunities for optimisation---(a) using a continuous array to avoid fragmented heap-allocated memory, and (b) using implicitly computed pointers/indexes rather than explicit pointers to parent/child nodes---into a single discussion and gives the incorrect impression that you must combine both opportunities together.

On page 150, the author mentions the possibility of iterating over an array backwards (that is, from length-1 to 0) rather than forwards (from 0 to length-1), but he neglects to warn that iterating backwards might be slower due to some CPUs implementing a forwards-looking-only cache prefetching mechanism. On my Intel-based laptop, iterating backwards over a multi MB array takes 25% more time than iterating forwards.

On pages 233-234, the author uses low-resolution timers to do a high-resolution performance test. The author tries to explain why this should work, but the explanation is too superficial and left me dubious.

On page 245, the author claims that, in most cases, the relative performance of two apps/algorithms when compiling in debug mode is similar to the relative performance when compiling in release/optimised mode. I was shocked at the author's naivety when I read this claim.

In summary, the book provides very little useful insight but lots of waffle and too much incorrect/bad advice to be recommended. Part-way through reading this book, I found a much better book called "Optimizing software in C++: An optimization guide for Windows, Linux and Mac platforms". You can find a free PDF of that book with an Internet search. It contains about half the pages and 10 times more insight than "Optimized C++".

11 people found this helpful

DSci

Molto superficiale

Reviewed in Italy on September 29, 2016

Verified Purchase

L'autore tratta alcuni argomenti in maniera fin troppo banale. Ci sono fin troppi esempi per sistemi windows and qualche raro cenno a sistemi unix. Sul web si trovano molte piú informazioni utili.

Translate review to English

See more reviews

Image Unavailable

Follow the author