复制成功
  • 图案背景
  • 纯色背景
  •   |  注册
  • /
  • 批注本地保存成功,开通会员云端永久保存 去开通
  • 网上数字图..

    上传于:2015-05-31

    粉丝量:1171

    所发布亚博足球app下载来源于互联网和个人收集,仅用于分享交流和学习使用,请下载后于24小时内删除,版权为原作者所有,请支持购买原版。因上传亚博足球app下载受大小限制,部分亚博足球app下载拆分上传,请浏览确认后下载。如有侵犯您的版权,请通过站内信息告知,将立即删除相关资料.如有其它问题也欢迎联系,谢谢!

    

    计算机书籍 计算机书籍 Addison Wesley - Modern C++ - Design Generic Programming a.

    下载积分:600

    内容提示: Table of Contents Modern C+ + Design: Generic Programming and Design Patterns Applied By Andrei Alexandrescu Publisher : Addison Wesley Pub Date : February 01, 2001 ISBN: 0-201-70431-5 Pages : 352 Modern C++ Design is 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++ des...

    亚博足球app下载格式:PDF| 浏览次数:4| 上传日期:2015-05-31 08:31:19| 亚博足球app下载星级:
    Table of Contents Modern C+ + Design: Generic Programming and Design Patterns Applied By Andrei Alexandrescu Publisher : Addison Wesley Pub Date : February 01, 2001 ISBN: 0-201-70431-5 Pages : 352 Modern C++ Design is 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. TEAMFLYThis 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. Team-Fly® iiTable of Content Table of Content..................................................................................................................i Copyright.............................................................................................................................vi Foreword............................................................................................................................vii Foreword.............................................................................................................................ix Preface................................................................................................................................. x Audience.........................................................................................................................xi Loki..................................................................................................................................xi Organization..................................................................................................................xii Acknowledgments...........................................................................................................xiii Part I: Techniques................................................................................................................... 1 Chapter 1. Policy-Based Class Design........................................................................... 2 1.1 The Multiplicity of Software Design ...................................................................... 2 1.2 The Failure of the Do-It-All Interface.................................................................... 3 1.3 Multiple Inheritance to the Rescue?..................................................................... 4 1.4 The Benefit of Templates....................................................................................... 5 1.5 Policies and Policy Classes................................................................................... 6 1.6 Enriched Policies..................................................................................................... 9 1.7 Destructors of Policy Classes.............................................................................. 10 1.8 Optional Functionality Through Incomplete Instantiation................................ 11 1.9 Combining Policy Classes.................................................................................... 12 1.10 Customizing Structure with Policy Classes..................................................... 13 1.11 Compatible and Incompatible Policies............................................................. 14 1.12 Decomposing a Class into Policies.................................................................. 16 1.13 Summary.............................................................................................................. 17 Chapter 2. Techniques.................................................................................................... 19 2.1 Compile-Time Assertions..................................................................................... 19 2.2 Partial Template Specialization........................................................................... 22 2.3 Local Classes......................................................................................................... 23 2.4 Mapping Integral Constants to Types ................................................................ 24 2.5 Type-to-Type Mapping.......................................................................................... 26 2.6 Type Selection....................................................................................................... 28 2.7 Detecting Convertibility and Inheritance at Compile Time.............................. 29 2.8 A Wrapper Around type_info.......................................................................... 32 2.9 NullType and EmptyType................................................................................ 34 2.10 Type Traits ........................................................................................................... 34 2.11 Summary.............................................................................................................. 40 Chapter 3. Typelists......................................................................................................... 42 3.1 The Need for Typelists.......................................................................................... 42 3.2 Defining Typelists.................................................................................................. 43 3.3 Linearizing Typelist Creation............................................................................... 45 3.4 Calculating Length................................................................................................. 45 3.5 Intermezzo.............................................................................................................. 46 3.6 Indexed Access ..................................................................................................... 47 3.7 Searching Typelists............................................................................................... 48 3.8 Appending to Typelists......................................................................................... 49 3.9 Erasing a Type from a Typelist............................................................................ 50 3.10 Erasing Duplicates.............................................................................................. 51 3.11 Replacing an Element in a Typelist.................................................................. 52 3.12 Partially Ordering Typelists................................................................................ 53 3.13 Class Generation with Typelists........................................................................ 56 3.14 Summary.............................................................................................................. 65 3.15 Typelist Quick Facts...................................................................................... 66 iiiChapter 4. Small-Object Allocation................................................................................ 68 4.1 The Default Free Store Allocator ........................................................................ 68 4.2 The Workings of a Memory Allocator................................................................. 69 4.3 A Small-Object Allocator ...................................................................................... 70 4.4 Chunks................................................................................................................... 71 4.5 The Fixed-Size Allocator...................................................................................... 74 4.6 The SmallObjAllocator Class...................................................................... 77 4.7 A Hat Trick.............................................................................................................. 79 4.8 Simple, Complicated, Yet Simple in the End..................................................... 81 4.9 Administrivia........................................................................................................... 82 4.10 Summary.............................................................................................................. 83 4.11 Small-Object Allocator Quick Facts.................................................................. 83 Part II: Components.............................................................................................................. 85 Chapter 5. Generalized Functors................................................................................... 86 5.1 The Command Design Pattern............................................................................ 86 5.2 Command in the Real World................................................................................ 89 5.3 C++ Callable Entities ............................................................................................ 89 5.4 The Functor Class Template Skeleton ........................................................... 91 5.5 Implementing the Forwarding Functor::operator() ............................... 95 5.6 Handling Functors................................................................................................. 96 5.7 Build One, Get One Free...................................................................................... 98 5.8 Argument and Return Type Conversions.......................................................... 99 5.9 Handling Pointers to Member Functions.......................................................... 101 5.10 Binding................................................................................................................ 104 5.11 Chaining Requests............................................................................................ 106 5.12 Real-World Issues I: The Cost of Forwarding Functions ............................ 107 5.13 Real-World Issues II: Heap Allocation ........................................................... 108 5.14 Implementing Undo and Redo with Functor .............................................. 110 5.15 Summary............................................................................................................ 110 5.16 Functor Quick Facts....................................................................................... 111 Chapter 6. Implementing Singletons........................................................................... 113 6.1 Static Data + Static Functions != Singleton..................................................... 113 6.2 The Basic C++ Idioms Supporting Singletons................................................ 114 6.3 Enforcing the Singleton's Uniqueness ............................................................. 116 6.4 Destroying the Singleton.................................................................................... 116 6.5 The Dead Reference Problem........................................................................... 118 6.6 Addressing the Dead Reference Problem (I): The Phoenix Singleton........ 120 6.7 Addressing the Dead Reference Problem (II): Singletons with Longevity.. 122 6.8 Implementing Singletons with Longevity.......................................................... 125 6.9 Living in a Multithreaded World......................................................................... 128 6.10 Putting It All Together....................................................................................... 130 6.11 Working with SingletonHolder.................................................................. 134 6.12 Summary............................................................................................................ 136 6.13 SingletonHolder Class Template Quick Facts....................................... 136 Chapter 7. Smart Pointers............................................................................................. 138 7.1 Smart Pointers 101 ............................................................................................. 138 7.2 The Deal ............................................................................................................... 139 7.3 Storage of Smart Pointers.................................................................................. 140 7.4 Smart Pointer Member Functions..................................................................... 142 7.5 Ownership-Handling Strategies ........................................................................ 143 7.6 The Address-of Operator.................................................................................... 150 7.7 Implicit Conversion to Raw Pointer Types....................................................... 151 7.8 Equality and Inequality........................................................................................ 153 7.9 Ordering Comparisons........................................................................................ 157 iv7.10 Checking and Error Reporting......................................................................... 159 7.11 Smart Pointers to const and const Smart Pointers................................. 161 7.12 Arrays.................................................................................................................. 161 7.13 Smart Pointers and Multithreading................................................................. 162 7.14 Putting It All Together....................................................................................... 165 7.15 Summary............................................................................................................ 171 7.16 SmartPtr Quick Facts.................................................................................... 171 Chapter 8. Object Factories.......................................................................................... 173 8.1 The Need for Object Factories.......................................................................... 174 8.2 Object Factories in C++: Classes and Objects............................................... 175 8.3 Implementing an Object Factory....................................................................... 176 8.4 Type Identifiers.................................................................................................... 180 8.5 Generalization...................................................................................................... 181 8.6 Minutiae................................................................................................................. 184 8.7 Clone Factories.................................................................................................... 185 8.8 Using Object Factories with Other Generic Components............................. 188 8.9 Summary............................................................................................................... 189 8.10 Factory Class Template Quick Facts.......................................................... 189 8.11 CloneFactory Class Template Quick Facts.............................................. 190 Chapter 9. Abstract Factory.......................................................................................... 191 9.1 The Architectural Role of Abstract Factory...................................................... 191 9.2 A Generic Abstract Factory Interface............................................................... 193 9.3 Implementing AbstractFactory................................................................... 196 9.4 A Prototype-Based Abstract Factory Implementation.................................... 199 9.5 Summary............................................................................................................... 202 9.6 AbstractFactory and ConcreteFactory Quick Facts......................... 203 Chapter 10. Visitor.......................................................................................................... 205 10.1 Visitor Basics ..................................................................................................... 205 10.2 Overloading and the Catch-All Function........................................................ 210 10.3 An Implementation Refinement: The Acyclic Visitor.................................... 211 10.4 A Generic Implementation of Visitor............................................................... 215 10.5 Back to the "Cyclic" Visitor............................................................................... 221 10.6 Hooking Variations............................................................................................ 223 10.7 Summary............................................................................................................ 226 10.8 Visitor Generic Components Quick Facts ..................................................... 226 Chapter 11. Multimethods............................................................................................. 228 11.1 What Are Multimethods?.................................................................................. 228 11.2 When Are Multimethods Needed?.................................................................. 229 11.3 Double Switch-on-Type: Brute Force............................................................. 230 11.4 The Brute-Force Approach Automated.......................................................... 232 11.5 Symmetry with the Brute-Force Dispatcher.................................................. 237 11.6 The Logarithmic Double Dispatcher............................................................... 240 11.7 FnDispatcher and Symmetry...................................................................... 245 11.8 Double Dispatch to Functors........................................................................... 246 11.9 Converting Arguments: static_cast or dynamic_cast?..................... 248 11.10 Constant-Time Multimethods: Raw Speed ................................................. 252 11.11 BasicDispatcher and BasicFastDispatcher as Policies............. 255 11.12 Looking Forward ............................................................................................. 257 11.13 Summary.......................................................................................................... 258 11.14 Double Dispatcher Quick Facts.................................................................... 259 Appendix A. A Minimalist Multithreading Library....................................................... 262 A.1 A Critique of Multithreading............................................................................... 262 A.2 Loki's Approach................................................................................................... 263 A.3 Atomic Operations on Integral Types .............................................................. 264 vA.4 Mutexes................................................................................................................ 265 A.5 Locking Semantics in Object-Oriented Programming................................... 267 A.6 Optional volatile Modifier............................................................................. 269 A.7 Semaphores, Events, and Other Good Things.............................................. 269 A.8 Summary.............................................................................................................. 269 Bibliography..................................................................................................................... 270 viCopyright Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and Addison-Wesley was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals. The author and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein. The publisher offers discounts on this book when ordered in quantity for special sales. For more information, please contact: Pearson Education Corporate Sales Division One Lake Street Upper Saddle River, NJ 07458 (800) 382-3419 corpsales@pearsontechgroup.com Visit AWon the Web: www.awl.com/cseng/ Library of Congress Cataloging-in-Publication Data Alexandrescu, Andrei. Modern C++ design : generic programming and design patterns applied / Andrei Alexandrescu. p. cm. — (C++ in depth series) Includes bibliographical references and index. ISBN 0-201-70431-5 1. C++ (Computer program language) 2. Generic programming (Computer science) I. Title. II. Series. QA76.73.C153 A42 2001 005.13'3—dc21 00-049596 Copyright © 2001 by Addison-Wesley All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher. Printed in the United States of America. Published simultaneously in Canada. Text printed on recycled paper vii2 3 4 5 6 7 8 9 10—DOC—0504030201 Second printing, June 2001 Foreword by Scott Meyers In 1991, I wrote the first edition of Effective C++. The book contained almost no discussions of templates, because templates were such a recent addition to the language, I knew almost nothing about them. What little template code I included, I had verified by e-mailing it to other people, because none of the compilers to which I had access offered support for templates. In 1995, I wrote More Effective C++. Again I wrote almost nothing about templates. What stopped me this time was neither a lack of knowledge of templates (my initial outline for the book included an entire chapter on the topic) nor shortcomings on the part of my compilers. Instead, it was a suspicion that the C++ community's understanding of templates was about to undergo such dramatic change, anything I had to say about them would soon be considered trite, superficial, or just plain wrong. There were two reasons for that suspicion. The first was a column by John Barton and Lee Nackman in the January 1995 C++ Report that described how templates could be used to perform typesafe dimensional analysis with zero runtime cost. This was a problem I'd spent some time on myself, and I knew that many had searched for a solution, but none had succeeded. Barton and Nackman's revolutionary approach made me realize that templates were good for a lot more than just creating containers of T. As an example of their design, consider this code for multiplying two physical quantities of arbitrary dimensional type: template<int m1, int l1, int t1, int m2, int l2, int t2> Physical<m1+m2, l1+l2, t1+t2> operator*(Physical<m1, l1, t1> lhs, Physical<m2, l2, t2> rhs) { return Physical<m1+m2, l1+l2, t1+t2>::unit*lhs.value()*rhs.value(); } Even without the context of the column to clarify this code, it's clear that this function template takes six parameters, none of which represents a type! This use of templates was such a revelation to me, I was positively giddy. Shortly thereafter, I started reading about the STL. Alexander Stepanov's elegant li brary design, where containers know nothing about algorithms; algorithms know nothing about containers; iterators act like pointers (but may be objects instead); containers and algorithms accept function pointers and function objects with equal aplomb; and library clients may extend the library without having to inherit from any base classes or redefine any virtual functions, made me feel—as I had when I read Barton and Nackman's work—like I knew almost nothing about templates. So I wrote almost nothing about them in More Effective C++. How could I? My understanding of templates was still at the containers-of-T stage, while Barton, Nackman, Stepanov, and others were demonstrating that such uses barely scratched the surface of what templates could do. In 1998, Andrei Alexandrescu and I began an e-mail correspondence, and it was not long before I recognized that I was again about to modify my thinking about templates. Where Barton, Nackman, and viiiStepanov had stunned me with what templates could do, however, Andrei's work initially made more of an impression on me for how it did what it did. One of the simplest things he helped popularize continues to be the example I use when introducing people to his work. It's the CTAssert template, analogous in use to the assert macro, but applied to conditions that can be evaluated during compilation. Here it is: template<bool> struct CTAssert; template<> struct CTAssert<true> {}; That's it. Notice how the general template, CTAssert, is never defined. Notice how there is a specialization for true, but not for false. In this design, what's missing is at least as important as what's present. It makes you look at template code in a new way, because large portions of the "source code" are deliberately omitted. That's a very different way of thinking from the one most of us are used to. (In this book, Andrei discusses the more sophisticated CompileTimeChecker template instead of CTAssert.) Eventually, Andrei turned his attention to the development of template-based implementations of popular language idioms and design patterns, especially the GoF[*] patterns. This led to a brief skirmish with the Patterns community, because one of their fundamental tenets is that patterns cannot be represented in code. Once it became clear that Andrei was automating the generation of pattern implementations rather than trying to encode patterns themselves, that objection was removed, and I was pleased to see Andrei and one of the GoF (John Vlissides) collaborate on two columns in the C++ Report focusing on Andrei's work. [*] "GoF" stands for "Gang of Four" and refers to Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, authors of the definitive book on patterns, Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1995). In the course of developing the templates to generate idiom and pattern implementations, Andrei was forced to confront the variety of design decisions that all implementers face. Should the code be thread safe? Should auxiliary memory come from the heap, from the stack, or from a static pool? Should smart pointers be checked for nullness prior to dereferencing? What should happen during program shutdown if one Singleton's destructor tries to use another Singleton that's already been destroyed? Andrei's goal was to offer his clients all possible design choices while mandating none. His solution was to encapsulate such decisions in the form of policy classes, to allow clients to pass policy classes as template parameters, and to provide reasonable default values for such classes so that most clients could ignore them. The results can be astonishing. For example, the Smart Pointer template in this book takes only 4 policy parameters, but it can generate over 300 different smart pointer types, each with unique behavioral characteristics! Programmers who are content with the default smart pointer behavior, however, can ignore the policy parameters, specify only the type of object pointed to by the smart pointer, and reap the benefits of a finely crafted smart pointer class with virtually no effort. In the end, this book tells three different technical stories, each compelling in its own way. First, it offers new insights into the power and flexibility of C++ templates. (If the material on typelists doesn't knock your socks off, it's got to be because you're already barefoot.) Second, it identifies orthogonal dimensions along which idiom and pattern implementations may differ. This is critical information for template designers and pattern implementers, but you're unlikely to find this kind of analysis in most idiom or pattern descriptions. Finally, the source code to Loki (the template library described in this book) is available for free download, so you can study Andrei's implementation of the templates corresponding to the idioms and patterns he discusses. Aside from providing a nice stress test for your compilers' support for templates, this source code serves as an invaluable starting point for templates of your own design. Of course, it's also perfectly respectable (and completely legal) to use Andrei's code right out of the box. I know he'd want you to take advantage of his efforts. ixFrom what I can tell, the template landscape is changing almost as quickly now as it was in 1995 when I decided to avoid writing about it. At the rate things continue to develop, I may never write about templates. Fortunately for all of us, some people are braver than I am. Andrei is one such pioneer. I think you'll get a lot out of his book. I did. Scott Meyers September 2000 Foreword by John Vlissides What's left to say about C++ that hasn't already been said? Plenty, it turns out. This book documents a convergence of programming techniques—generic programming, template meta programming, object-oriented programming, and design patterns—that are well understood in isolation but whose synergies are only beginning to be appreciated. These synergies have opened up whole new vistas for C++, not just for programming but for software design itself, with profound implications for software analysis and architecture as well. Andrei's generic components raise the level of abstraction high enough to make C++ begin to look and feel like a design specification language. Unlike dedicated design languages, however, you retain the full expressiveness and familiarity of C++. Andrei shows you how to program in terms of design concepts: singletons, visitors, proxies, abstract factories, and more. You can even vary implementation trade-offs through template parameters, with positively no runtime overhead. And you don't have to blow big bucks on new development tools or learn reams of methodological mumbo jumbo. All you need is a trusty, late-model C++ compiler—and this book. Code generators have held comparable promise for years, but my own research and practical experience have convinced me that, in the end, code generation doesn't compare. You have the round-trip problem, the not-enough-code-worth-generating problem, the inflexible-generator problem, the inscrutable-generated-code problem, and of course the I-can't-integrate-the-bloody-generated-code-with-my-own-code problem. Any one of these problems may be a showstopper; together, they make code generation an unlikely so...

    关注我们

  • 新浪微博
  • 关注微信公众号

  • 打印亚博足球app下载
  • 复制文本
  • 下载计算机书籍 计算机书籍 Addison Wesley - Modern C++ - Design Generic Programming and Design Pattern.XDF
  • 您选择了以下内容