If you are involved in developing, designing, architecting C++ software, you absolutely
need to read listed here books. These books are some of the best in this category. They provide a plethora
of information about C++ and software development in general, saving development time and efforts,
teaching with examples how to design, create, test, manage high quality software projects.
(If you don't see the pictures and links below that means your browser
either doesn't support inlined frames or you have a proxy service that is blocking
them.)

This book demonstrates key techniques that make C++ effective and teaches the fundamental
concepts necessary for mastery. -- page viThis book can be rightly called a C++ bible. Bjarne Stroustrup provides
detailed and precise discussion of every C++ concept in this monumental work. The
book can be somewhat difficult for a novice, but for those who already have working
knowledge of the language, this book can be a good reference and makes an interesting
reading.

Many bad coding standards have been set by people who don't understand the language
well, don't understand software development well, or try to legislate too much.
A bad coding standard quickly loses credibility and at best even its valid guidelines
are liable to be ignored by disenchanted programmers who dislike or disagree with
its poorer guidelines. That's "at best" - at worst, a bad standard might actually
be enforced. -- page xi.If you are developing internal standards for your group, or even for
yourself, this book is indispensable for you. It will allow avoiding the common
pitfalls of legislating the irrelevant stuff and steer you to the things that really
matter.

Never make exception safety an afterthought. Exception safety affects a class's
design. It is never "just an implementation detail." -- page 17This book is an excellent research of exception safety principles and
much more.Exceptional C++ shows by example how to go about solid software engineering.
-- Scott Meyers

"But I can always tell where the bottlenecks are," you may think. Don't worry, you're
not alone. Most programmers think this at one time or another, but they're still
wrong. Dead wrong. Programmers are notoriously poor guessers about where their code's
true bottlenecks lie. Sometimes, we get lucky and are right. Most of the time, we're
not. -- page 85This book continues the discussion started in "Exceptional C++" covering
new topics and providing more insights.

One of C++'s most powerful features is its support for generic programming. This
power is reflected in the flexibility of the C++ standard library, especially in
its containers, iterators, and algorithms portion, originally known as the standard
template library (STL). -- page 1 This book continues discussion started in previous Exceptional C++ books,
covering topics like standard library, optimization, resource management.

The information in this book will make you a better STL programmer. It will make
you a more productive programmer. And it will make you a happier programmer. Using
STL is fun, but using it effectively is outrageous fun, the kind of fun where they
have to drag you away from the keyboard, because you just can't believe the good
time you're having. -- Introduction No C++ study is complete without a discussion of the C++ Standard Library.
Scott Meyers shows 50 specific ways to improve your use of the Standard Template
Library. He presents the material in an easy to read yet very precise form and with
a good humor.

It is thus with great trepidation that I proclaim to
you now that the single most important rule in object-oriented programming with
C++ is this: public inheritance means "isa." Commit this rule to memory. -- Item
35. This book covers 50 topics that every C++ programmer absolutely must
know. Scott Meyers meticulously dissected the most fundamental topics that virtually
every C++ project includes, such as memory management, constructors, destructors,
class design and implementation, basics of inheritance and OOD.

The way most people locate bottlenecks is to guess. Using experience, intuition,
tarot cards and Ouija boards, rumors or worse, developer after developer solemnly
proclaims that a program's efficiency problems can be traced to network delays,
improperly tuned memory allocators, compilers that don't optimize aggressively enough,
or some bonehead manager's refusal to permit assembly language for crucial inner
loops. Such assessments are generally delivered with a condescending sneer, and
usually both the sneerers and their prognostications are flat-out wrong -- Item
16 This book continues discussion started in Effective C++ and covers 50
more topics, such as operators, exceptions, efficiency, specific techniques.

Testing by itself does not improve software quality. Test results are an indicator
of quality, but in and of themselves, they don't improve it. Trying to improve software
quality by increasing the amount of testing is like trying to lose weight by weighing
yourself more often. What you eat before you step onto the scale determines how
much you will weigh, and the software development techniques you use determine how
many errors testing will find. If you want to lose weight, don't buy a new scale;
change your diet. If you want to improve your software, don't test more; develop
better. This book contains a lot of valuable information about software development
gathered from author's experience, studies and research.

Templates can be used to develop elaborate libraries of elements that connect in
seamless ways. Non-template libraries can often do such things too. However, when
it comes to small, fairly simple utilities that make everyday programming easier,
traditional procedural or object-oriented libraries are not always viable because
the overhead to invoke the simple functionality is disproportionate to the facility
offered. C++ templates is probably the most powerful and most important concept
in modern C++. If you want to (and you should) study templates in depth, understand
how to use SFINAE, CRTP, metaprogramming, and other advanced topics, this book is
an invaluable resource for you.

Fact 8 One of the two most common causes of runaway projects is poor estimation.
Fact 9 Software estimation usually occurs at the wrong time.
Fact 10 Software estimation is usually done by the wrong people.
Fact 11 Software estimates are rarely corrected as the project proceeds.
Fact 12 Since estimates are so faulty, there is little reason to be concerned when
software projects do not meet estimated targets. But everyone is concerned anyway.
As the title suggests this book contains a study of facts and fallacies
of software engineering. It's very human to believe the fallacies, yet facts often
come as a surprise. This book is a must read for everybody who is involved in software
development, - developers, architects, managers.