9780321227256

At long last, this much-awaited book delivers practical metaprogramming into the hands of the everyday C++ programmer.

Aleksey Gurtovoy is a technical lead for MetaCommunication and a contributing member of the Boost C++ community.

Preface
Acknowledgments
Making the Most of This Book
Introduction
Getting Started
So What's a Metaprogram?Metaprogramming in the Host Language
Metaprogramming in C++
Why Metaprogramming?
When Metaprogramming?
Why a Metaprogramming Library?
Traits and Type Manipulation
Type Associations
Metafunctions
Numerical Metafunctions
Making Choices at Compile Time
A Brief Tour of the Boost Type Traits Library
Nullary Metafunctions
Metafunction Definition
History
Details
Exercises
A Deeper Look at Metafunctions
Dimensional Analysis
Higher-Order Metafunctions
Handling Placeholders
More Lambda Capabilities
Lambda Details
Details
Exercises
Integral Type Wrappers and Operations
Boolean Wrappers and Operations
Integer Wrappers and Operations
Exercises
Sequences and Iterators
Concepts
Sequences and Algorithms
Iterators
Iterator Concepts
Sequence Concepts
Sequence Equality
Intrinsic Sequence Operations
Sequence Classes
Integral Sequence Wrappers
Sequence Derivation
Writing Your Own Sequence
Details
Exercises
Algorithms
Algorithms, Idioms, Reuse, and Abstraction
Algorithms in the MPL
Inserters
Fundamental Sequence Algorithms
Querying Algorithms
Sequence Building Algorithms
Writing Your Own Algorithms
Details
Exercises
Views and Iterator Adaptors
A Few Examples
View Concept
Iterator Adaptors
Writing Your Own View
History
Exercises
Diagnostics
Debugging the Error Novel
Using Tools for Diagnostic Analysis
Intentional Diagnostic Generation
History
Details
Exercises
Crossing the Compile-Time/Runtime Boundary.for each
Implementation Selection
Object Generators
Structure Selection
Class Composition
(Member) Function Pointers as Template Arguments
Type Erasure
The Curiously Recurring Template Pattern
Explicitly Managing the Overload Set
The "sizeof Trick"
Summary
Exercises
Domain-Specific Embedded Languages
A Little Language
Goes a Long Way
DSLs, Inside Out
C++ as the Host Language
Blitz++ and Expression Templates
General-Purpose DSELs
The Boost Spirit Library
Summary
Exercises
A DSEL Design Walkthrough
Finite State Machines
Framework Design Goals
Framework Interface Basics
Choosing a DSL
Implementation
Analysis
Language Directions
Exercises
An Introduction to Preprocessor Metaprogramming
Motivation
Fundamental Abstractions of the Preprocessor
Preprocessor Library Structure
Preprocessor Library Abstractions
Exercise
The typename and template Keywords
The Issue
The Rules
Compile-Time Performance
The Computational Model
Managing Compilation Time
The Tests
MPL Portability Summary
Bibliography
Index
Table of Contents provided by Publisher. All Rights Reserved.

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

In 1998 Dave had the privilege of attending a workshop in Generic Programming at Dagstuhl Castle in Germany. Near the end of theworkshop, a very enthusiastic Kristof Czarnecki and Ullrich Eisenecker (ofGenerative Programmingfame) passed out a few pages of C++ source code that they billed as a complete Lisp implementation built out of C++ templates. At the time it appeared to Dave to be nothing more than a curiosity, a charming but impractical hijacking of the template system to prove that you can write programs that execute at compile time. He never suspected that one day he would see a role for metaprogramming in most of his day-to-day programming jobs. In many ways, that collection of templates was the precursor to the Boost Metaprogramming Library (MPL): It may have been the first library designed to turn compile-time C++ from an ad hoc collection of "template tricks" into an example of disciplined and readable software engineering. With the availability of tools to write and understand metaprograms at a high level, we've since found that using these techniques is not only practical, but easy, fun, and often astoundingly powerful. Despite the existence of numerous real systems built with template metaprogramming and the MPL, many people still consider metaprogramming to be other-worldly magic, and often as something to be avoided in day-to-day production code. If you've never done any metaprogramming, it may not even have an obvious relationship to the work you do. With this book, we hope to lift the veil of mystery, so that you get an understanding not only ofhowmetaprogramming is done, but also why andwhen. The best part is that while much of the mystery will have dissolved, we think you'll still find enough magic left in the subject to stay as inspired about it as we are. Making the Most of This Book The first few chapters of this book lay the conceptual foundation you'll need for most everything else we cover, and chapters generally build on material that has come before. That said, feel free to skip ahead for any reasonwe've tried to make that possible by providing cross-references when we use terms introduced earlier on. Chapter 10, Domain-Specific Embedded Languages, is an exception to the rule that later chapters depend on earlier ones. It focuses mostly on concepts, and only appears late in the book because at that point you'll have learned the tools and techniques to put Domain-Specific Embedded Languages into play in real code. If you only remember one chapter by the time you're done, make it that one. Near the end of many chapters, you'll find a Details section that summarizes key ideas. These sections usually add new material that deepens the earlier discussion,* so even if you are inclined to skim them the first time through, we suggest you refer back to them later. We conclude most chapters with exercises designed to help you develop both your programming and conceptual muscles. Those marked with asterisks are expected to be more of a workout than the others. Not all exercises involve writing codesome could be considered "essay questions"and you don't have to complete them in order to move on to later chapters. We do suggest you look through them, give a little thought to how you'd answer each one, and try your hand at one or two; it's a great way to gain confidence with what you've just read. Supplementary Material This book comes with a companion CD that supplies the following items in electronic form Sample code from the book. A release of the Boost C++ libraries. Boost has become known for high-quality, peer-reviewed, portable, generic, and freely reusable C++ libraries. We make extensive use of one Boost library throughout the bookthe Boost Metaprogramming Library (MPL)and we discuss several others. A complete MPL reference manual, in HTML and PDF

Amazon no longer offers textbook rentals. We do!

C++ Template Metaprogramming Concepts, Tools, and Techniques from Boost and Beyond

C++ Template Metaprogramming Concepts, Tools, and Techniques from Boost and Beyond

0321227255

Summary

Author Biography

Table of Contents

Supplemental Materials

Excerpts

Write a Review