Modern C++ Design: Generic Programming and Design Pattern... and over 2 million other books are available for Amazon Kindle . Learn more
100% PP 100%25%20PP
   2,713.57 + FREE Delivery
  • Inclusive of all taxes
Sold and fulfilled by B2A UK.
Quantity:1
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more.
See all 2 images

Modern C++ Design: Generic Programming and Design Patterns Applied (C++ in Depth Series) Paperback – Import, 13 Feb 2001

| 100% Purchase Protection
  • Genuine products
  • Safe and secure ordering
  • Easy returns
  • 100% purchase protection with A-to-Z Guarantee
  • > Learn more

See all 3 formats and editions Hide other formats and editions
Price New from
Paperback, Import, 13 Feb 2001
   2,713.57
   2,713.57

Frequently Bought Together

Modern C++ Design: Generic Programming and Design Patterns Applied (C++ in Depth Series) + C++ Concurrency in Action
Price For Both:   3,252.57

These items are dispatched from and sold by different sellers.

Buy the selected items together

Customers Who Bought This Item Also Bought


Product Description

From the Inside Flap

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 it. 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.

Imagine the following scenario. You come from a design meeting with a couple of printed diagrams, scribbled with your annotations. Okay, the event type passed between these objects is not char anymore; its int. You change one line of code. The smart pointers to Widget are too slow; they should go unchecked. You change one line of code. The object factory needs to support the new Gadget class just added by another department. You change one line of code.

You changed the design. Compile. Link. Done.

Well, there is something wrong with this scenario, isnt there? A much more likely scenario is this: You come from the meeting in a hurry because you have a pile of work to do. You fire a global search. You perform surgery on code. You add code. You introduce bugs. You remove the bugs . . . thats the way a programmers job is, right? Although this book cannot possibly promise you the first scenario, it is nonetheless a resolute step in that direction. It tries to present C++ as a newly discovered language for software architects.

Traditionally, code is the most detailed and intricate aspect of a software system. Historically, in spite of various levels of language support for design methodologies (such as object orientation), a significant gap persisted between the blueprints of a program and its code because the code must take care of the ultimate details of the implementation and of many ancillary tasks. The intent of the design is, more often than not, dissolved in a sea of quirks.

This book presents a collection of reusable design artifacts, called generic components, together with the techniques that make them possible. These generic components bring their users the well-known benefits of libraries, but in the broader space of system architecture. The coding techniques and the implementations provided focus on tasks and issues that traditionally fall in the area of design, activities usually done before coding. Because of their high level, generic components make it possible to map intricate architectures to code in unusually expressive, terse, and easy-to-maintain ways.

Three elements are reunited here: design patterns, generic programming, and C++. These elements are combined to achieve a very high rate of reuse, both horizontally and vertically. On the horizontal dimension, a small amount of library code implements a combinatorialand essentially open-endednumber of structures and behaviors. On the vertical dimension, the generality of these components makes them applicable to a vast range of programs.

This book owes much to design patterns, powerful solutions to ever-recurring problems in object-oriented development. Design patterns are distilled pieces of good designrecipes for sound, reusable solutions to problems that can be encountered in manycontexts. Design patterns concentrate on providing a suggestive lexicon for designs to be conveyed. They describe the problem, a time-proven solution with its variants, and the consequences of choosing each variant of that solution. Design patterns go above and beyond anything a programming language, no matter how advanced, could possibly express. By following and combining certain design patterns, the components presented in this book tend to address a large category of concrete problems.

Generic programming is a paradigm that focuses on abstracting types to a narrow collection of functional requirements and on implementing algorithms in terms of these requirements. Because algorithms define a strict and narrow interface to the types they operate on, the same algorithm can be used against a wide collection of types. The implementations in this book use generic programming techniques to achieve a minimal commitment to specificity, extraordinary terseness, and efficiency that rivals carefully handcrafted code.

C++ is the only implementation tool used in this book. You will not find in this book code that implements nifty windowing systems, complex networking libraries, or clever logging mechanisms. Instead, 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, errors in mixing and matching the appropriate pieces are usually caught during compile time.

This books manifest intent is to create generic componentspreimplemented 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 complementarywhereas 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.

Audience

The intended audience of this book 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 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 and concentrate on using the provided library. Each chapter 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.

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.

Having an acquaintance with design patterns (Gamma et al. 1995) is recommended but not mandatory. The patterns and idioms applied in the book are described in detail. However, this book is not a pattern bookit does not attempt to treat patterns in full generality. Because patterns are presented from the pragmatic standpoint of a library writer, even readers interested mostly in patterns may find the perspective refreshing, if constrained.

Loki

The book describes an actual C++ library called Loki. Loki is the god of wit and mischief in Norse mythology, and the authors hope is that the librarys originality and flexibility will remind readers of the playful Norse god. All the elements of the library live in the namespace Loki. The namespace is not mentioned in the coding examples because it would have unnecessarily increased indentation and the size of the examples. Loki is freely available; you can download it from awl/cseng/titles/0-201-70431-5.

Except for its threading part, Loki is written exclusively in standard C++. This, alas, means that many current compilers cannot cope with parts of it. I implemented and tested Loki using Metrowerks CodeWarrior Pro 6.0 and Comeau C++ 4.2.38, both on Windows. It is likely that KAI C++ wouldnt have any problem with the code, either. As vendors release new, better compiler versions, you will be able to exploit everything Loki has to offer.

Lokis code and the code samples presented throughout the book use a popular coding standard originated by Herb Sutter. Im sure you will pick it up easily. In a nutshell,

Classes, functions, and enumerated types look LikeThis.

Variables and enumerated values look likeThis.

Member variables look likeThis_.

Template parameters are declared with class if they can be only a user-defined type, and with typename if they can also be a primitive type.

From the Back Cover

Modern C++ Designis an important book. Fundamentally, it demonstrates ‘generic patterns’ or ‘pattern templates’ as a powerful new way of creating extensible designs in C++–a new way to combine templates and patterns that you may never have dreamt was possible, but is. If your work involves C++ design and coding, you should read this book. Highly recommended.
–Herb Sutter

What’s left to say about C++ that hasn’t already been said? Plenty, it turns out.
–From the Foreword by John Vlissides

In Modern C++ Design, Andrei Alexandrescu opens new vistas for C++ programmers. Displaying extraordinary creativity and programming virtuosity, Alexandrescu offers a cutting-edge approach to design that unites design patterns, generic programming, and C++, enabling programmers to achieve expressive, flexible, and highly reusable code.

This book introduces the concept of generic components–reusable design templates that produce boilerplate code for compiler consumption–all within C++. Generic components 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 describes the specific C++ techniques and features that are used in building generic components and goes on to implement industrial strength generic components for real-world applications. Recurring issues that C++ developers face in their day-to-day activity are discussed in depth and implemented in a generic way. These include:

  • Policy-based design for flexibility
  • Partial template specialization
  • Typelists–powerful type manipulation structures
  • Patterns such as Visitor, Singleton, Command, and Factories
  • Multi-method engines

For each generic component, the book presents the fundamental problems and design options, and finally implements a generic solution.

In addition, an accompanying Web site, http://www.awl.com/cseng/titles/0-201-70431-5, makes the code implementations available for the generic components in the book and provides a free, downloadable C++ library, called Loki, created by the author. Loki provides out-of-the-box functionality for virtually any C++ project.

Get a value-added service! Try out all the examples from this book at www.codesaw.com. CodeSaw is a free online learning tool that allows you to experiment with live code from your book right in your browser.



0201704315B11102003


Product details

  • Paperback: 352 pages
  • Publisher: Addison Wesley; 1 edition (13 February 2001)
  • Language: English
  • ISBN-10: 0201704315
  • ISBN-13: 978-0201704310
  • Product Dimensions: 18.7 x 1.9 x 23.2 cm
  • Average Customer Review: 5.0 out of 5 stars  See all reviews (1 customer review)

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

5.0 out of 5 stars
5 star
1
4 star
0
3 star
0
2 star
0
1 star
0
See the customer review
Share your thoughts with other customers

Most Helpful Customer Reviews

Format: Paperback Verified Purchase
This book presents a completely new perspective of using C++ in generic programming. If you have been always using C++ in OOPs perspective then this a good book to get a feel of generics.

Book covers Generics, Design patterns, Effective object creation, Smart Pointers, Multiple dispatch with great explanation.

A very good book if you want to explore above topics in C++.
Was this review helpful to you? Yes No Sending Feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 84 reviews
126 of 134 people found the following review helpful
template pathology 8 April 2004
By A Customer - Published on Amazon.com
Format: Paperback
Read this book and you may feel you've fallen down the hole into some sort of C++ Alice-in-Wonderland:
"Isn't it nifty just how much you can do with functions... that not only don't do anything but don't even really exist at all?" p.36
The title is a bit presumptuous; a more accurate title would be "Template Metaprogramming Stunts", since this book is primarily about tricks you can play with C++'s template mechanism.
The author does also make a go at proposing a new concept of "policy-based class design" -- by which he means using templates intead of multiple inheritance to create combinatorial mixtures of behavior. This is interesting, but seems hard to apply beyond the cliches he considers (ex: smart pointers), so his argument reads like a well-intended but parochial graduate thesis, with dutiful gestures of respect to his mentors (ex: Scot Myers) and limited range of real-world application.
The real meat of the book is his template techniques, which are ingenious -- if perverse, when seen from the standpoint of someone else trying to read and extend your code, or diagnose its arcane compiler errors. If you've ever had to work with other people on software, you may find his glib view of compiler errors disappointing. In many cases he relies on compiler errors to signal something more complex and semantic than the mere error would suggest. (If you're programmed much C++ you've surely experienced 10-line long STL template errors with a very simple underlying cause that is hard to discern from the error message. Learning to suss out what these mean is much of the sweat-work of learning C++.) I think this is simply that he's coming from the perspective that the interworkings of the language and the compiler are fascinating, and worth being a primary focus of study. But from the perspective of someone just tried to get your work done in the problem domain at hand, you may resent this attitude.
This book is best approached if you think C++ is really neat. Wheter you love C++ for its roccoco intricacy, or just see it as an evolutionary leaf node language full of botched misfeatures, you will find much here to confirm your opinion. I don't mean to belittle this book. There is real insight here: the idea of computing on types instead of values (to store the results of template-based computations) is a nifty idea. But it's worth keeping an eye on what problems you are really trying to solve, and which ones you may be creating.
Some telling quotes:
"Unfortunately, type_info's useful capabilities are packaged in a way that makes them unnecessarily hard to exploit." p.38
"For a variety of reasons, C++ is a language that leads its users sometimes to say, 'These are the smartest five lines of code I ever wrote.' Maybe it is its semantic richness or the ever-exciting (and surprising?) way its features interact." p.51
139 of 157 people found the following review helpful
Template Showboating 15 July 2001
By Amazon Customer - Published on Amazon.com
Format: Paperback
While this is an interesting book, I'm not as unconditionally enthusiastic about it as most of the reviewers here seem to be. I felt that, as opposed to Scott Meyers' books and the original _Design Patterns_ book, many of the techniques presented in this book are the result of research into "elegant" solutions rather than experience with what really works in practical applications.
I really liked chapter 1 discussing policy-based class design, chapter 2 discussing various template techniques, chapter 6 discussing singleton implementation, anbd chapter 7 discussing smart pointers. Chapter 11 discussing multimethods, appears to be a good discussion of various alternatives but I'm not inclined to use multimethods anytime soon.
Chapter 3 about typelists is interesting, but after all the dazzling manipulations, all that typelists seem to be good for is generating class hierarchies, which I didn't find very compelling - it looks as if the typelists help to manage complexity that possibly wouldn't be there if the typelists hadn't been used in the first place.
Chapter 4 about small object allocation was of limited interest to me. The other chapters, 5 (Functors), 8 (Object Factories), 9 (Abstract Factory), and 10 (Visitor) offered fairly complex, template based solutions that to me did not look obviously superior to the straightforward manual implementations shown in _Design Patterns_.
Overall, a stimulating book, but one whose recipes will need careful evaluation before use.
50 of 54 people found the following review helpful
After two disappointments... 24 May 2001
By Kevin Graham - Published on Amazon.com
Format: Paperback
I was longing for a good book on advanced C++. First, I bought "Multi-Paradigm C++". It does have some insights but author's style is baroque to the extreme. A good cure for insomnia. Then I bought "Generative Programming". I found it too much of a PhD thesis garnished with too much fluff for my taste.
Not wanting to risk anymore, I borrowed this book from a friend... to lose sleep for two nights reading it! It is the book I was looking for: no-nonsense, eye-opening, inspirational. The author's mastery of C++ and the creativity with which he solves real-world problems are phenomenal.
Alexandrescu discusses and implements the following design patterns: Command, Singleton, Proxy (in the form of smart pointers), Factory Method, Abstract Factory, and Visitor. In doing so, he creates highly configurable components that support most variations that accompany the patterns, and allow the component users to add their own variations. This is done through template parameters. The technique is not new but the author documents it thoroughly (coining the Policy-based design term) and uses it very creatively to achieve elegant designs.
The book also has foundation chapters: Techniques, Typelists, and a small object allocator. The latter is not really in sync with the rest of the book, being a low-level component written in straight C++, but in compensation, the chapter on typelists is as meta as you can imagine, and more :-).
In short: a great book if you use C++, especially so if you need to participate in the architectural stage of projects. But the best thing the book has done for me is, it made me extremely excited about programming - a feeling forgotten since my college days. Five stars plus.
33 of 36 people found the following review helpful
A significant and valuable book; strongly recommended. 2 April 2001
By Mindy Newcombe - Published on Amazon.com
Format: Paperback
I was waiting for this, and pestering bookstores for it for 2 weeks before it arrived. And it still exceeded my expectations. Note: The author was partly responsible for the C++ ScopeGuard library - an amazing, essential piece of code.
For any C++ engineers using reference counting (that'll be all of us, then), the amazingly configurable SmartPtr<> and the SmallObjectAllocator are instantly worth many times the price of the book. The deep, thorough analysis of Singletons, Functors, the Visitor pattern, Double-dispatch and Factories are all important chapters in their own right, with immediate use in real programs as well as educational value. The pervading concept of policy classes will undoubtedly influence your future approach to design, because the examples are all so elegant, compelling and downright useful.
But I think there is even more value in the longer term. This book takes a somewhat dizzying step into a new way of thinking, reminiscent of first encountering STL or GoF's Design Patterns. I feel sure that the concept of typelists is an important contribution to the direction of the language; a flexible, generic, *declarative* way of expressing relationships between abstractions. However, these techniques place such strain on the C++ template facility (which even in its final ISO form is barely adequate for the task) that it's amazing that they work at all. The book is full of ingenious work-arounds to overcome language limitations.
I just wish that more current compilers would accept the code. Sadly, Visual C++ 6.0 is a long way from this level of standard-conformance. Hopefully VC++ .NET will be better.
28 of 30 people found the following review helpful
Read this milestone book! 12 July 2001
By Maxim - Published on Amazon.com
Format: Paperback
I highly recommended this book if you are interested in generic techniques and Design Patterns
This book uses C++ and Generic programming techniques to implement GoF Design Patterns [1]. It introduces Andrei's "Generic Design Patterns Library", called "Loki". Loki's techniques are more important than the library itself and should be applicable in many other contexts. (Since the library is not yet available, I cannot comment on it further.) One word of caution (lest you get overly excited) - Loki uses some of the latest C++ features and requires standard-adhering compilers [g++ v2.95.2-5, Borland C++ v5.5, and EDG's v2.45 or later. Microsoft's VC++ 6.0 fails-Ed.]
The book is written for intermediate or expert level programmers. A fair knowledge of C++, particularly templates, is needed Also, some knowledge of Design Patterns is useful, although not strictly necessary, since the book describes the patterns in a pretty self-contained fashion.
With these prerequisites the book makes for quite an enjoyable read, but I would not call it easy due to the inherently complexity of the material covered. Andrei's writing style is frank and friendly, which makes the reading easier.
I found the code fragments to be very accurate bar some mechanical/typesetting errors, some of which will be fixed by the time of the printing. The book's strong points include:
1) Taking techniques as complex as template meta-programming and bringing them back to us earthly beings. You could get a more extensive treatment of these techniques from the book Generative Programming [2] or from Todd Veldhuisen's papers [3] but the examples in this book make a very good introduction to the area.
2) Creating a generic library of design patterns using "policy-based" classes eliminate the redundancy found in many systems that utilize Design Patterns.
3) The one line of the book I'd like to (mis?)quote in my review is "Remember, the design constraints buried in the class's design are as bad as magic constants embedded in code". As obvious as it is, this principle is often overlooked (I know...) and largely because people do not see a solution to it and are willing to live with the "this is as good as it gets" mentality. In this sense the book was a great eye-opener - it showed the feasibility of the solutions and the techniques for the implementation.
Personally, I hope you enjoy the book as much as I did!

Popular searches on Amazon.in

Mobiles: Android One | Google Nexus 5 | Apple iPhone 6 | Apple iPhone 5s | Samsung Mobiles | Sony Mobiles | Nokia Mobiles | Micromax Mobiles | HTC Mobiles
Computers: HP Laptops | Asus Laptops | Dell Laptops | SanDisk Drives | HP Drives | Seagate Drives | WD Drives | SanDisk Cards | Strontium 8GB Memory Card
Cameras: Canon 1200D | Sony Cybershot W810 | Nikon D5200 | Canon Cameras | Nikon Cameras | Sony Cameras | Samsung Cameras | Panasonic Cameras
Watches: Casio Watches | Titan Watches | Fastrack Watches | Sonata Watches | Timex Watches | Maxima Watches | Fossil Watches | Tommy Hilfiger Watches
Kindle: Kindle e-readers | Kindle Paperwhite | Kindle Paperwhite 3G | Kindle Fire HD | Kindle Accessories | Kindle Touchscreen | Kindle eBooks
Top Searches: Samsung Galaxy Core 2 | Micromax Canvas Juice | Micromax Unite 2 | Micromax Canvas Knight | Panasonic P81 | Nokia XL | Arya Z2 | GOSF
Others: Sachin Tendulkar Autobiography | Apple iPad Mini | Tupperware | Puma Shoes | Pampers Diapers | XBox One | XBox 360 | Destiny | PS4 | PS3