C++ – programming language that supports many paradigms: classes, overloaded functions, templates, modules, procedural programming, parallel programming, etc. In spite of the flexibility and variety of language, require significant effort to develop a method of design that allows to use multiple paradigms in a single application. This ebook series, simply and aptly describes the environment for the application multi-paradigm design, offers an impressive array of design techniques that form the basis of multi-paradigm design.
The C++ language is being used increasingly for complex and large-scale software systems-systems that call for multi-paradigm design. Well known for his C++ expertise, James Coplien guides program designers through the most challenging aspects of C++ design. In this electronic book, James Coplien describes each paradigm and explains how it solves the design problem at hand and how it applies to C++.

Ebook covers the foundation organizing data structures and their implementation using C++ language. Most of the data structures, such as arrays, vectors, lists, maps and stacks, are composed of standard template library (STL). Book quite extensively studied canonical realization of these data structures, which is both effective and concise. Much attention in the book is paid to algorithms for working with data structures.
Electronic book should be studied on practical examples. Software projects at the end of each ebook chapter allow the reader to develop and implement their own data structure, either to expand or use the data structure, covered in chapter. While carrying out laboratory work provided in each chapter, the reader will be able to gain practical skills application of knowledge in real programming. 
Ebook can be used as a teaching tool in studying computer technology programs in higher education institutions.

• history of C++ and the Standard Library
• template basics
• Big-O Notation
• the std namespace
• ebook explains the mechanism standard exceptions
• allocators
• standard library utilities
• electronic book contains description of pairs and auto_ptr
• numeric limits
• the Standard Template Library (STL) basics
• containers, iterators, algorithms, vectors, lists, deques, strings, sets, multisets, bitsets, maps, multimaps, stacks, queues
• iterator adapters, function objects, element requirements, value and reference semantics, complex numbers, valarrays, stream classes, stream manipulators and formatting, file I/O, internationalization, and locales

In book Modern C++ Design, Andrei Alexandrescu opens new vistas for C++ programmers. Displaying extraordinary creativity and virtuosity, Alexandrescu offers in this book a cutting-edge approach to software design that unites design patterns, generic programming, and C++, enabling programmers to achieve expressive, flexible, and highly reusable code. The ebook introduces the concept of generic components, reusable design templates that enable an easier and more seamless transition from design to application code, generate code that better expresses the original design intention, and support the reuse of design structures with minimal recoding. The author then shows in the book how to apply this approach to recurring, real-world issues that C++ programmers face in their day-to-day activity. All code is available on the Web, along with Alexandrescu’s downloadable Loki C++ library, which provides powerful out-of-the-box functionality for virtually any C++ project.  You might be holding this book in a bookstore, asking yourself whether you should buy it. Or maybe you are in your employers library, wondering whether you should invest time in reading the book. I know you dont have time, so Ill cut to the chase. If you have ever asked yourself how to write higher-level programs in C++, how to cope with the avalanche of irrelevant details that plague even the cleanest design, or how to build reusable components that you dont have to hack into each time you take them to your next application, then this book is for you.
C++ is the only implementation tool used in this book. You will not find in this ebook code that implements nifty windowing systems, complex networking libraries, or clever logging mechanisms. Instead, in this book you will find the fundamental components that make it easy to implement all of the above, and much more. C++ has the breadth necessary to make this possible. Its underlying C memory model ensures raw performance, its support for polymorphism enables object-oriented techniques, and its templates unleash an incredible code generation machine. Templates pervade all the code in the book because they allow close cooperation between the user and the library. The user of the library literally controls he way code is generated, in ways constrained by the library. The role of a generic component library is to allow user-specified types and behaviors to be combined with generic components in a sound design. Because of the static nature of the technique used in this ebook, errors in mixing and matching the appropriate pieces are usually caught during compile time. 
This books manifest intent is to create generic components, preimplemented pieces of design whose main characteristics are flexibility, versatility, and ease of use. Generic components do not form a framework. In fact, their approach is complementary whereas a framework defines interdependent classes to foster a specific object model, generic components are lightweight design artifacts that are independent of each other, yet can be mixed and matched freely. They can be of great help in implementing frameworks. 
The intended audience of this ebook falls into two main categories. The first category is that of experienced C++ programmers who want to master the most modern library writing techniques. The book presents new, powerful C++ idioms that have surprising capabilities, some of which werent even thought possible. These idioms are of great help in writing high-level libraries. Intermediate C++ programmers who want to go a step further will certainly find the book useful, too, especially if they invest a bit of perseverance. Although pretty hard-core C++ code is sometimes presented, it is thoroughly explained. 
The second category of the book consists of busy programmers who need to get the job done without undergoing a steep learning investment. They can skim the most intricate details of implementation in the ebook and concentrate on using the provided library. Each chapter of the ebook has an introductory explanation and ends with a Quick Facts section. Programmers will find these features a useful reference in understanding and using the components. The components can be understood in isolation, are very powerful yet safe, and are a joy to use. 
For better understanding this book you need to have a solid working experience with C++ and, above all, the desire to learn more. A degree of familiarity with templates and the Standard Template Library (STL) is desirable.

C++ Coding Standards by Herb Sutter and Andrei Alexandrescu, the newest book in Bjarne Stroustrup’s C++ In Depth series, is the authoritative ebook reference for C++ software development teams. It’s the only C++ coding standard with Stroustrup’s name on it, and the only one book written by two of the top names C++. Both authors draw on their personal extensive real-world project experience at commercial software companies ranging in size from small successful start-ups to RealNetworks to Microsoft. That concrete, in-the-trenches experience shines through in Item after Item as the book covers not only many issues of note in Standard C++ itself, but also includes important material on how Standard C++ interacts with nonstandard but real-world topics like dealing with threading and concurrency, handling application scalability, and correctly designing and deploying modules (including shared libraries and DLLs).
Overview: This ebook delivers a valuable set of tried-and-true rules, guidelines, and best practices condensed into 101 concise one- and two-page Items. But this book is something more: It also acts as an index into the world’s C++ literature because each Item includes copious references that, in all, cite nearly 100 different top books and articles—from Brooks’ classic The Mythical Man-Month to Vandevoorde and Josuttis’ cutting-edge C++ Templates to the authors’ own previous books—and distill the scattered advice and guidelines into one authoritative handbook.
Book contents: The topical sections it covers are:

• Organizational and Policy Issues;
• Design Style;
• Coding Style;
• Functions and Operators;
• Class Design and Inheritance;
• Book describes Construction, Destruction, and Copying;
• Namespaces and Modules;
• EBook contains description of Templates and Genericity;
• Error Handing and Exceptions;
• STL: Containers;
• STL: Algorithms;
• Type Safety

Each Item of the ebook is laid out as follows: 
Item title: The simplest meaningful sound bite we could come up with as a mnemonic for the rule. 
Summary: The most essential points, briefly stated. 
Discussion: An extended explanation of the guideline. This often includes brief rationale, but remember that the bulk of the rationale is intentionally left in the References. 
Examples (if applicable): Examples that demonstrate a rule or make it memorable. 
Exceptions (if applicable): Any (and usually rare) cases when a rule doesn’t apply. But beware the trap of being too quick to think: “Oh, I’m special; this doesn’t apply in my situation” — that rationalization is common, and commonly wrong. 
References: See these parts of the C++ books for the full details and analysis. 
A landmark book that belongs on every C++ development team’s bookshelf and reading list.

This book is about providing successful strategies for solving real-world problems in C++. Like its predecessors, it draws on years of in-the-trenches experience, and provides tested techniques and practical solutions for programmers designing modern software systems with C++, from small projects to enterprise applications.
Book contents: Built around 40 Items, Exceptional C++ Style ebook helps you understand the rules and issues critical to successful software design and development in C++.

Book

The concise text of the book covers a range of challenging topics in C++ without attempting to be comprehensive. Each “item” in the ebook is presented as a question to try and solve yourself before the author presents his solution, plus additional detail as needed. For most topics of the book, Sutter ends by giving his advice on the best practices (and gotchas to avoid).
Early sections of the book concentrate on using Standard Template Library (STL) container classes, like removing items effectively, and the subtle differences between container types. Standout sections of the ebook on designing custom templates (using specialization techniques) and exception-safe classes will help you do more with your own classes. One entertaining problem here shows a number-guessing game (Mastermind) built as efficiently as possible using STL code (including expert-level use of generic functions to do much of the work).
Several problems on copy-on-write (COW) semantics for more efficient classes point out the issues surrounding code optimization. There has been a debate in the C++ community for years about whether it’s possible to design truly “exception-safe” classes. Sutter, in his books, points out the difficulty with a precise analysis of the issues surrounding exceptions and C++ constructors. Material on the finer points of inheriting classes of the ebook (including when to avoid and when to use multiple inheritance in C++) will extend your class design options. A good section of the book is the author’s explication of how to simulate COM/Java style interfaces in C++, which isn’t immediately obvious, even to experienced C++ developers.
Later sections of the ebook delve into code maintenance issues, including advice for using macros, typedefs, and namespaces. (Advice on migrating existing C++ code into namespaces will help you combine legacy code with other libraries.) A final appendix of the book shows off some benchmarks for optimizing strings using a variety of techniques.
Intelligent, provocative, and demanding, More Exceptional C++ shows why C++ continues to be a rich, complex, and challenging language. Armed with titles like this one, experienced C++ programmers can write better code and avoid pitfalls buried in the outer edges of their favorite language.

Topics covered by the ebook:

• ebook explains puzzles and solutions to advanced topics in C++
• using remove() and erase() for Standard Template Library (STL) containers
• custom templates with inheritance and traits
• book contains description of using typename
• containers used with pointers
• the finer points of vector,set,and maps
• potential problems with vector
• book explains post and prefix operators used with functions
• templates overloading
• explicit and partial template specialization (plus function template overloading)
• using STL to implement Mastermind (a number-guessing game)
• the finer points of inline functions
• lazy optimizations (including copy-on-write–COW–and semantics for strings)
• book explains iterators and references
• gotchas in multithreaded environments
• designing exception-safe classes
• constructor failures and object lifetimes
• uncaught exceptions (the pitfalls of using uncaught_exception())
• unmanaged pointers (in parameter evaluation and auto_ptr)
• copy assignment
• inheritance and exception safety issues
• multiple inheritance dos and don’ts
• the Siamese Twin problem
• ebook describes virtual functions
• controlled polymorphism
• memory management issues with smart pointers (auto_ptr)
• recursive declarations
• how to simulate nested functions
• preprocessor macros
• hints for initialization
• forward declarations
• using typedef effectively
• best practices for namespaces (including code maintenance and migrating existing C++ code to namespaces)
• appendices on advice for multithreaded optimization

Based on the author’s Guru of the Week Web column, this ebook poses a series of challenging questions on the inner workings of C++, centering around generic programming with the Standard Template Library (STL), exception handling, memory management, and class design. Even if you think you know C++ well, most of the problems,describing in the book will teach you something more about the language and how to write more robust classes that are “exception safe”.Don’t think this is just “language lawyering,” though.
The author’s explanations stress sound programming principles (favoring simplicity) and idioms (such as the Pimpl idiom for class design that promotes faster compile times and better maintainability, or using “smart” auto_ptrs with STL.) Judging from the range and depth of these examples, Sutter’s command of the inner workings of C++ is impressive, and he does an excellent job of conveying this expertise without jargon or a lot of theory. After reading this book, C++ designers will learn several “best practices” of how to write robust, efficient classes that are “exception safe.” Chances are you’ll gain a better understanding of memory management techniques and working with STL too. For the experienced developer seeking leading-edge knowledge of some of the best ways to use C++, ebook Exceptional C++ is both a challenging and truly worthwhile source of information.

Topics covered by book:

• advanced C++ programming tutorial
• generic programming
• book contains tips for string classes
• containers and STL
• ebook describes virtual functions
• class inheritance
• the Pimpl idiom
• namespaces
• memory management
• C++ memory areas
• overloading new and delete
• book contain description of using smart pointer with auto_ptr
• using const
• casts
• hints for better performance and code maintainability