C++模板元编程：深度探索Boost与进阶技术

5星 · 超过95%的资源需积分: 50 108 浏览量更新于2024-07-25 收藏 1.89MB PDF 举报

《C++模板元编程：概念、工具与技术——来自Boost及其以外》是一本深入剖析C++模板元编程的专著，它作为C++ In-Depth系列丛书中的一员，对于熟练掌握C++编程的程序员来说是不可或缺的参考资料。本书不仅介绍了模板元编程的基本概念，还涵盖了Boost库以及其他扩展技术中的实用工具和技巧。 C++模板元编程是C++语言中一种强大的特性，允许程序员在编译时处理类型和表达式，而不是运行时。作者首先通过"Getting Started"部分引导读者快速入门，让读者理解模板元编程的核心概念。这部分解释了什么是元编程（Meta-programming），即编写生成其他代码的程序，以及为何在C++中使用这种技术，因为它可以提高代码的灵活性和效率，尤其是在处理类型依赖和通用编程场景。章节2着重于类型特质（Traits）和类型操纵，这是元编程的基础。"Type Associations"部分阐述了如何通过类型别名和关联来获取或操作类型信息。Metafunctions（元函数）则是关键工具，它们是模板函数的特殊形式，可以在编译时计算结果。"Numerical Metafunctions"展示了如何用元编程实现数值计算相关的模板，例如计算类型的最大值或最小值。此外，"Making Choices at Compile Time"探讨了如何在编译期根据类型特性选择不同的代码路径。随着对基础概念和技术的深入，作者引入了Boost库，这是一个广泛使用的C++库集合，其中包含许多现成的元编程工具和组件。读者将了解到如何利用这些工具来简化复杂的问题，以及在实际项目中如何结合Boost进行模板元编程实践。本书还提供了一些实用建议，如"Making the Most of This Book"，指导读者如何充分利用书籍资源，包括补充材料和实践练习，以便更好地理解和掌握元编程技术。同时，章节8的"Section 1.6 When Metaprogramming?"讨论了何时选择使用元编程，以及何时常规编程更为合适。《C++ Template Metaprogramming》是一本深入浅出的指南，适合C++开发者提升对模板元编程的理解，学习如何运用这一强大工具来优化代码、提高性能和编写更加灵活的解决方案。无论是对C++初学者还是高级开发者，这都是一本不可多得的参考书籍。

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

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,

[1]

so even if you are inclined to skim them the first time through, we

suggest you refer back to them later.

[1]

We borrowed this idea from Andrew Koenig and Barbara Moo's Accelerated C++: Practical Programming By Example

[KM00](See 24.).

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.

7.1 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 form.

 Boost libraries discussed in this book that are not yet part of an official

release.

The index.html file at the top level of the CD will provide you with a convenient

guide to all of its contents. Additional and updated material, including the

inevitable errata, will appear on the book's Web site: http://www.boost-

consulting.com/mplbook. You'll also find a place there to report any mistakes you

might find.

7.2 Trying It Out

To compile any of the examples, just put the CD's boost_1_32_0/ directory into

your compiler's #include path.

The libraries we present in this book go to great lengths to hide the problems of

less-than-perfect compilers, so it's unlikely that you'll have trouble with the

examples we present here. That said, we divide C++ compilers roughly into three

categories.

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

A. Those with mostly conforming template implementations. On these

compilers, the examples and libraries "just work." Almost anything released

since 2001, and a few compilers released before then, fall into this category.

B. Those that can be made to work, but require some workarounds in user

code.

C. Those that are too broken to use effectively for template metaprogramming.

Appendix D(See 22.) lists the compilers that are known to fall into each of these

categories. For those in category B, Appendix D(See 22.) refers to a list of

portability idioms. These idioms have been applied to the copies of the book's

examples that appear on the accompanying CD, but to avoid distracting the

majority of readers they don't appear in the main text.

The CD also contains a portability table with a detailed report of how various

compilers are doing with our examples. GCC is available free for most platforms,

and recent versions have no problems handling the code we present here.

Even if you have a relatively modern compiler from category A, it might be a good

idea to grab a copy of GCC with which to cross-check your code. Often the easiest

way to decipher an inscrutable error message is to see what some other compiler

has to say about your program. If you find yourself struggling with error messages

as you try to do the exercises, you might want to skip ahead and read the first two

sections of Chapter 8(See 15.), which discusses how to read and manage

diagnostics.

And now, on to C++ Template Metaprogramming!

8. Chapter 1. Introduction

You can think of this chapter as a warm-up for the rest of the book. You'll get a

chance to exercise your tools a little and go through a short briefing on basic

concepts and terminology. By the end you should have at least a vague picture of

what the book is about, and (we hope) you'll be eager to move on to bigger ideas.

8.1 Section 1.1. Getting Started

One of the nice things about template metaprograms is a property they share with

good old traditional systems: Once a metaprogram is written, it can be used

without knowing what's under the hoodas long as it works, that is.

To build your confidence in that, let us begin by presenting a tiny C++ program

that simply uses a facility implemented with template metaprogramming:

#include "libs/mpl/book/chapter1/binary.hpp"

#include <iostream>

int main()

{

std::cout << binary<101010>::value << std::endl;

return 0;

}

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

Even if you were always good at binary arithmetic and can tell what the output of

the program will be without actually running it, we still suggest that you go to the

trouble of trying to compile and run the example. Besides contributing to building

your confidence, it's a good test of whether your compiler is able to handle the

code we present in this book. The program should write the decimal value of the

binary number 101010:

to the standard output.

8.2 Section 1.2. So What's a Metaprogram?

If you dissect the word metaprogram literally, it means "a program about a

program."

[1]

A little less poetically, a metaprogram is a program that manipulates

code. It may be an odd-sounding concept, but you're probably already familiar with

several such beasts. Your C++ compiler is one example: it manipulates your C++

code to produce assembly language or machine code.

[1]

In philosophy and, as it happens, programming, the prefix "meta" is used to mean "about" or "one level of description higher,"

as derived from the original Greek meaning "beyond" or "behind."

Parser generators such as YACC [Joh79](See 24.) are another kind of program-

manipulating program. The input to YACC is a high-level parser description written

in terms of grammar rules and attached actions brace-enclosed. For instance, to

parse and evaluate arithmetic expressions with the usual precedence rules, we

might feed YACC the following grammar description:

expression : term

| expression '+' term { $$ = $1 + $3; }

| expression '-' term { $$ = $1 - $3; }

;

term : factor

| term '*' factor { $$ = $1 * $3; }

| term '/' factor { $$ = $1 / $3; }

;

factor : INTEGER

| group

;

group : '(' expression ')'

;

In response, YACC would generate a C/C++ source file containing (among other

things), a yyparse function that we can call to parse text against the grammar and

execute the appropriate actions:

[2]

This is provided that we also implemented an appropriate yylex function to tokenize the text. See Chapter 10(See 17.) for

a complete example or, better yet, pick up a YACC manual.

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

int main()

{

extern int yyparse();

return yyparse();

}

The user of YACC is operating mostly in the domain of parser design, so we'll call

YACC's input language the domain language of this system. Because the rest of

the user's program typically requires a general-purpose programming system and

must interact with the generated parser, YACC translates the domain language into

the host language, C, which the user then compiles and links together with her

other code. The domain language thus undergoes two translation steps, and the

user is always very conscious of the boundary between it and the rest of her

program.

8.3 Section 1.3. Metaprogramming in the Host

Language

YACC is an example of a translatora metaprogram whose domain language differs

from its host language. A more interesting form of metaprogramming is available in

languages such as Scheme [SS75](See 24.). The Scheme metaprogrammer defines

her domain language as a subset of the legal programs in Scheme itself, and the

metaprogram executes in the same translation step used to process the rest of the

user's program. Programmers move between ordinary programming,

metaprogramming, and writing in the domain language, often without being aware

of the transition, and they are able to seamlessly combine multiple domains in the

same system.

Amazingly, if you have a C++ compiler, this is precisely the kind of

metaprogramming power you hold in your fingertips. The rest of this book is about

unlocking that power and showing how and when to use it.

8.4 Section 1.4. Metaprogramming in C++

In C++, it was discovered almost by accident [Unruh94](See 24.), [Veld95b](See

24.) that the template mechanism provides a rich facility for native language

metaprogramming. In this section we'll explore the basic mechanisms and some

common idioms used for metaprogramming in C++.

1.4.1. Numeric Computations

The earliest C++ metaprograms performed integer computations at compile time.

One of the very first metaprograms was shown at a C++ committee meeting by

Erwin Unruh; it was actually an illegal code fragment whose error messages

contained a sequence of computed prime numbers!

Since illegal code is hard to use effectively in a larger system, let's examine a

slightly more practical application. The following metaprogram (which lies at the

heart of our little compiler test above) transliterates unsigned decimal numerals

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

into their binary equivalents, allowing us to express binary constants in a

recognizable form.

template <unsigned long N>

struct binary

{

static unsigned const value

= binary<N/10>::value << 1 // prepend higher bits

| N%10; // to lowest bit

};

template <> // specialization

struct binary<0> // terminates recursion

{

static unsigned const value = 0;

};

unsigned const one = binary<1>::value;

unsigned const three = binary<11>::value;

unsigned const five = binary<101>::value;

unsigned const seven = binary<111>::value;

unsigned const nine = binary<1001>::value;

If you're wondering "Where's the program?" we ask you to consider what happens

when we access the nested ::value member of binary<N>. The binary template

is instantiated again with a smaller N, until N reaches zero and the specialization is

used as a termination condition. That process should have the familiar flavor of a

recursive function calland what is a program, after all, but a function? Essentially,

the compiler is being used to interpret our little metaprogram.

Error Checking

There's nothing to prevent a user from passing binary a number such as

678, whose decimal representation is not also valid binary. The result

would make a strange sort of sense (it would be 6x2

+ 7x2

+ 8x2

), but

nonetheless an input like 678 probably indicates a bug in the user's logic.

In Chapter 3(See 10.) we'll show you how to ensure that

binary<N>::value only compiles when N's decimal representation is

composed solely of 0s and 1s.

Because the C++ language imposes a distinction between the expression of

compile-time and runtime computation, metaprograms look different from their

runtime counterparts. As in Scheme, the C++ metaprogrammer writes her code in

the same language as the ordinary program, but in C++ only the compile-time

subset of the full language is available to her. Compare the previous example with

this straightforward runtime version of binary:

unsigned binary(unsigned long N)

{

return N == 0 ? 0 : N%10 + 2 * binary(N/10);

}

剩余311页未读，继续阅读

sjiagc

粉丝: 7
资源: 52

C++模板元编程：深度探索Boost与进阶技术

C++ Template Metaprogramming 原书附带示例代码

C++ Template Metaprogramming (Chm和Pdf)

C++ Template Metaprogramming (英文版).chm

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

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

Addison Wesley - C++ Template Metaprogramming Concepts Tools And Techniques From Boost And Beyond

（C++元编程）C++ Template Metaprogramming Concepts, Tools, and Techniques from Boost and Beyond.chm

C++模板元编程(C++ 领域扛鼎之作，荣耀先生倾情翻译，名著名译) 原书名： C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond

cpp_metaprog_HandsOn_C++_c++template_metaprogramming_

The connection between C template metaprogramming and functional programming

最新资源