Discovering Modern C++

出版者:Addison

作者:Peter Gottschling

页数:480

出版时间:2015-12-27

价格:USD 45.78

装帧:Paperback

isbn号码:9780134383583

丛书系列:C++ In-Depth

具体描述

As scientific and engineering projects grow larger and more complex, it is increasingly likely that those projects will be written in C++. With embedded hardware growing more powerful, much of its software is moving to C++, too. Mastering C++ gives you strong skills for programming at nearly every level, from “close to the hardware” to the highest-level abstractions. In short, C++ is a language that scientific and technical practitioners need to know.

Peter Gottschling’s Discovering Modern C++ is an intensive introduction that guides you smoothly to sophisticated approaches based on advanced features. Gottschling introduces key concepts using examples from many technical problem domains, drawing on his extensive experience training professionals and teaching C++ to students of physics, math, and engineering.

This book is designed to help you get started rapidly and then master increasingly robust features, from lambdas to expression templates. You’ll also learn how to take advantage of the powerful libraries available to C++ programmers: both the Standard Template Library (STL) and scientific libraries for arithmetic, linear algebra, differential equations, and graphs.

Throughout, Gottschling demonstrates how to write clear and expressive software using object orientation, generics, metaprogramming, and procedural techniques. By the time you’re finished, you’ll have mastered all the abstractions you need to write C++ programs with exceptional quality and performance.

作者简介

Peter Gottschling 热衷于编写前沿的科学计算软件，他希望他的热情也能感染读者。因为职业的缘故他编写了 MTL4（矩阵模板库 4），同时也是 Boost Graph Library 的作者之一。他曾在多个 C++ 课程和专业培训中分享过开发经验，并撰写了本书。

他是 C++ 标准委员会成员，德国程序语言标准委员会副主席，也是德累斯顿 C++ 用户组的创始人。他年轻时在德累斯顿工业大学就读，同时在数学和计算机科学专业上达到了学士水平，并最终获得了计算机科学的博士学位。莱比锡建城一千年时，他离开了学术机构，回到了他最爱的故乡莱比锡，创建了自己的公司 SimuNova。

他已婚并育有四名子女。

目录信息

目录
前言
学习C++的理由
读此书的理由
美女与野兽
科学与工程中的语言
排版惯例
致谢
关于作者
Chapter 1 C++ Basics
1.1 Our First Program
1.2 Variables
1.2.1 Constants
1.2.2 Literals
1.2.3 Non-narrowing Initialization
1.2.4 Scopes
1.3 Operators
1.3.1 Arithmetic Operators
1.3.2 Boolean Operators
1.3.3 Bitwise Operators
1.3.4 Assignment
1.3.5 Program Flow
1.3.6 Memory Handling
1.3.7 Access Operators
1.3.8 Type Handling
1.3.9 Error Handling
1.3.10 Overloading
1.3.11 Operator Precedence
1.3.12 Avoid Side Effects!
1.4 Expressions and Statements
1.4.1 Expressions
1.4.2 Statements
1.4.3 Branching
1.4.4 Loops
1.4.5 goto
1.5 Functions
1.5.1 Arguments
1.5.2 Returning Results
1.5.3 Inlining
1.5.4 Overloading
1.5.5 main Function
1.6 Error Handling
1.6.1 Assertions
1.6.2 Exceptions
1.6.3 Static Assertions
1.7 I/O
1.7.1 Standard Output
1.7.2 Standard Input
1.7.3 Input/Output with Files
1.7.4 Generic Stream Concept
1.7.5 Formatting
1.7.6 Dealing with I/O Errors
1.8 Arrays, Pointers, and References
1.8.1 Arrays
1.8.2 Pointers
1.8.3 Smart Pointers
1.8.4 References
1.8.5 Comparison between Pointers and References
1.8.6 Do Not Refer to Outdated Data!
1.8.7 Containers for Arrays
1.9 Structuring Software Projects
1.9.1 Comments
1.9.2 Preprocessor Directives
1.10 Exercises
1.10.1 Age
1.10.2 Arrays and Pointers
1.10.3 Read the Header of a Matrix Market File
Chapter 2 Classes
2.1 Program for Universal Meaning Not for Technical Details
2.2 Members
2.2.1 Member Variables
2.2.2 Accessibility
2.2.3 AccessOperators
2.2.4 The Static Declarator for Classes
2.2.5 Member Functions
2.3 Setting Values: Constructors and Assignments
2.3.1 Constructors
2.3.2 Assignment
2.3.3 Initializer Lists
2.3.4 Uniform Initialization
2.3.5 Move Semantics
2.4 Destructors
2.4.1 Implementation Rules
2.4.2 Dealing with Resources Properly
2.5 Method Generation Résumé
2.6 Accessing Member Variables
2.6.1 Access Functions
2.6.2 Subscript Operator
2.6.3 Constant Member Functions
2.6.4 Reference-Qualified Members
2.7 Operator Overloading Design
2.7.1 Be Consistent!
2.7.2 Respect the Priority
2.7.3 Member or Free Function
2.8 Exercises
2.8.1 Polynomial
2.8.2 Move Assignment
2.8.3 Initializer List
2.8.4 Resource Rescue
Chapter 3 Generic Programming
3.1 Function Templates
3.1.1 Instantiation
3.1.2 Parameter Type Deduction
3.1.3 Dealing with Errors in Templates
3.1.4 Mixing Types
3.1.5 Uniform Initialization
3.1.6 Automatic return Type
3.2 Namespaces and Function Lookup
3.2.1 Namespaces
3.2.2 Argument-Dependent Lookup
3.2.3 Namespace Qualification or ADL
3.3 Class Templates
3.3.1 A Container Example
3.3.2 Designing Uniform Class and Function Interfaces
3.4 Type Deduction and Definition
3.4.1 Automatic Variable Type
3.4.2 Type of an Expression
3.4.3 decltype(auto)
3.4.4 Defining Types
3.5 A Bit of Theory on Templates: Concepts
3.6 Template Specialization
3.6.1 Specializing a Class for One Type
3.6.2 Specializing and Overloading Functions
3.6.3 Partial Specialization
3.6.4 Partially Specializing Functions
3.7 Non-Type Parameters for Templates
3.8 Functors
3.8.1 Function-like Parameters
3.8.2 Composing Functors
3.8.3 Recursion
3.8.4 Generic Reduction
3.9 Lambda
3.9.1 Capture
3.9.2 Capture by Value
3.9.3 Capture by Reference
3.9.4 Generalized Capture
3.9.5 Generic Lambdas
3.10 Variadic Templates
3.11 Exercises
3.11.1 String Representation
3.11.2 String Representation of Tuples
3.11.3 Generic Stack
3.11.4 Iterator of a Vector
3.11.5 Odd Iterator
3.11.6 Odd Range
3.11.7 Stack of bool
3.11.8 Stack with Custom Size
3.11.9 Deducing Non-type Template Arguments
3.11.10 Trapezoid Rule
3.11.11 Functor
3.11.12 Lambda
3.11.13 Implement make_unique
Chapter 4 Libraries
4.1 Standard Template Library
4.1.1 Introductory Example
4.1.2 Iterators
4.1.3 Containers
4.1.4 Algorithms
4.1.5 Beyond Iterators
4.2 Numerics
4.2.1 Complex Numbers
4.2.2 Random Number Generators
4.3 Meta-programming
4.3.1 Limits
4.3.2 Type Traits
4.4 Utilities
4.4.1 Tuple
4.4.2 function
4.4.3 Reference Wrapper
4.5 The Time Is Now
4.6 Concurrency
4.7 Scientific Libraries Beyond the Standard
4.7.1 Other Arithmetics
4.7.2 Interval Arithmetic
4.7.3 Linear Algebra
4.7.4 Ordinary Differential Equations
4.7.5 Partial Differential Equations
4.7.6 Graph Algorithms
4.8 Exercises
4.8.1 Sorting by Magnitude
4.8.2 STL Container
4.8.3 Complex Numbers
Chapter 5 Meta-Programming
5.1 Let the Compiler Compute
5.1.1 Compile-Time Functions
5.1.2 Extended Compile-Time Functions
5.1.3 Primeness
5.1.4 How Constant Are Our Constants?
5.2 Providing and Using Type Information
5.2.1 Type Traits
5.2.2 Conditional Exception Handling
5.2.3 A const-Clean View Example
5.2.4 Standard Type Traits
5.2.5 Domain-Specific Type Properties
5.2.6 enable-if
5.2.7 Variadic Templates Revised
5.3 Expression Templates
5.3.1 Simple Operator Implementation
5.3.2 An Expression Template Class
5.3.3 Generic Expression Templates
5.4 Meta-Tuning: Write Your Own Compiler Optimization
5.4.1 Classical Fixed-Size Unrolling
5.4.2 Nested Unrolling
5.4.3 Dynamic Unrolling–Warm-up
5.4.4 Unrolling Vector Expressions
5.4.5 Tuning an Expression Template
5.4.6 Tuning Reduction Operations
5.4.7 Tuning Nested Loops
5.4.8 Tuning Résumé
5.5 Exercises
5.5.1 Type Traits
5.5.2 Fibonacci Sequence
5.5.3 Meta-Program for Greatest Common Divisor
5.5.4 Vector Expression Template
5.5.5 Meta-List
Chapter 6 Object-Oriented Programming
6.1 Basic Principles
6.1.1 Base and Derived Classes
6.1.2 Inheriting Constructors
6.1.3 Virtual Functions and Polymorphic Classes
6.1.4 Functors via Inheritance
6.2 Removing Redundancy
6.3 Multiple Inheritance
6.3.1 Multiple Parents
6.3.2 Common Grandparents
6.4 Dynamic Selection by Sub-typing
6.5 Conversion
6.5.1 Casting between Base and Derived Classes
6.5.2 const-Cast
6.5.3 Reinterpretation Cast
6.5.4 Function-Style Conversion
6.5.5 Implicit Conversions
6.6 CRTP
6.6.1 A Simple Example
6.6.2 A Reusable Access Operator
6.7 Exercises
6.7.1 Non-redundant Diamond Shape
6.7.2 Inheritance Vector Class
6.7.3 Clone Function
Chapter 7 Scientific Projects
7.1 Implementation of ODE Solvers
7.1.1 Ordinary Differential Equations
7.1.2 Runge-Kutta Algorithms
7.1.3 Generic Implementation
7.1.4 Outlook
7.2 Creating Projects
7.2.1 Build Process
7.2.2 Build Tools
7.2.3 Separate Compilation
7.3 Some Final Words
Appendix A Clumsy Stuff
A.1 More Good and Bad Scientific Software
A.2 Basics in Detail
A.2.1 More about Qualifying Literals
A.2.2 static Variables
A.2.3 More about if
A.2.4 Duff’s Device
A.2.5 More about main
A.2.6 Assertion or Exception?
A.2.7 Binary I/O
A.2.8 C-Style I/O
A.2.9 Garbarge Collection
A.2.10 Trouble with Macros
A.3 Real-World Example: Matrix Inversion
A.4 Class Details
A.4.1 Pointer to Member
A.4.2 More Initialization Examples
A.4.3 Accessing Multi-dimensional Arrays
A.5 Method Generation
A.5.1 Controlling the Generation
A.5.2 Generation Rules
A.5.3 Pitfalls and Design Guides
A.6 Template Details
A.6.1 Uniform Initialization
A.6.2 Which Function Is Called?
A.6.3 Specializing for Specific Hardware
A.6.4 Variadic Binary I/O
A.7 Using std::vector in C++03
A.8 Dynamic Selection in Old Style
A.9 Meta-Programming Details
A.9.1 First Meta-Program in History
A.9.2 Meta-Functions
A.9.3 Backward-Compatible Static Assertion
A.9.4 Anonymous Type Parameters
A.9.5 Benchmark Sources of Dynamic Unrolling
A.9.6 Benchmark for Matrix Product
Appendix B Programming Tools
B.1 gcc
B.2 Debugging
B.2.1 Text-Based Debugger
B.2.2 Debugging with Graphical Interface: DDD
B.3 Memory Analysis
B.4 gnuplot
B.5 Unix, Linux, and Mac OS
Appendix C Language Definitions
C.1 Value Categories
C.2 Operator Overview
C.3 Conversion Rules
C.3.1 Promotion
C.3.2 Other Conversions
C.3.3 Usual Arithmetic Conversions
C.3.4 Narrowing
Bibliography
Index
· · · · · · (收起)

用户评价

从排版和结构上看，这本书的组织逻辑非常严密，仿佛一条精心铺设的知识阶梯。每一章的末尾都有一个“实践挑战”环节，这些挑战往往不是简单的代码填充，而是要求结合前文所学，去重构一个性能不佳的旧有组件，或者设计一个满足特定约束条件的并发数据结构。这使得学习过程充满了实战的代入感。我尤其欣赏作者处理“历史包袱”的方式，他非常坦诚地讨论了 C++ 中那些不太优雅的旧有设计，并明确指出在现代 C++ 中应当避免使用某些旧模式，例如，为什么应该优先使用 `std::optional` 而非返回错误码或魔术值。这种批判性思维的培养，让我在阅读其他旧代码库时，也能迅速识别出潜在的优化点和设计缺陷。总而言之，这是一部值得反复研读的、能真正提升工程素养的宝典。

这本厚重的书入手的时候，就有一种沉甸甸的质感，封面设计简洁却不失力量感，那种深邃的蓝色和少许的银色字体搭配，让人立刻联想到技术和深度。我原本以为这会是一本枯燥的 C++ 语法速查手册，但翻开目录才发现，它几乎涵盖了从基础到高阶的所有议题。作者在介绍新特性时，不是简单地罗列代码示例，而是深入剖析了这些特性背后的设计哲学和适用场景。例如，在讲解 RAII（Resource Acquisition Is Initialization）原则时，作者没有停留在“这是个好习惯”的层面，而是通过好几个复杂的资源管理案例，展示了如果不遵循该原则，程序会陷入何种难以追踪的内存泄漏或句柄泄露泥潭。特别是关于并发编程的那几章，讲解得极其透彻，使用了很多现代 C++ 提供的原子操作和内存模型相关的工具，清晰地描绘了多线程环境下竞态条件的产生机制，并提供了行之有效的规避方案，这一点对我解决目前工作中遇到的一个棘手的并发死锁问题帮助极大，让我对 C++ 在系统级编程中的强大能力有了更直观的认识。

我是在追求更高性能的嵌入式开发领域接触到这本书的。市面上很多 C++ 教材，讲到模板编程时，往往止步于简单的泛型容器实现，但这本书却将元编程（Metaprogramming）提升到了一个全新的高度。作者花了大量篇幅介绍如何利用 `constexpr` 和模板特化来在编译期完成复杂的计算和类型检查，这对于我们这种对运行时开销斤斤计较的领域来说，简直是如获至宝。我尝试着按照书中的指导，将一个原本在启动时需要耗费几百毫秒才能完成的配置校验过程，通过模板递归将其彻底移到了编译阶段，程序的启动速度立竿见影地提升了。更令人印象深刻的是，书中对 STL 源码级别的剖析，比如解释了 `std::vector` 内部是如何进行内存重分配和迭代器失效处理的，这种细节层面的挖掘，让我看问题的视角从“如何使用”升级到了“为什么这样设计”。读完这部分，我对标准库的敬畏感油然而生。

这本书最让我感到惊喜的是它对现代 C++ 设计理念的强调，特别是关于“零抽象开销”的坚持。作者在讲解智能指针（如 `std::unique_ptr` 和 `std::shared_ptr`）时，不仅仅是展示了它们如何替代裸指针，更深入地分析了它们是如何通过模板和内联技术，使得运行时性能几乎与手动管理内存没有差异。这彻底颠覆了我过去对“面向对象带来的性能损耗”的固有偏见。此外，书中对模块化编程（Modules）的展望和介绍，虽然很多内容基于最新的草案，但其前瞻性令人振奋，作者清晰地指出了当前预处理器宏系统的弊端，并展示了 Modules 如何从根本上解决头文件依赖和编译时间过长的问题。这本书不仅教授 C++ 的“现在”，更是在描绘 C++ 的“未来”。

说实话，这本书的阅读体验并非一帆风顺，它对读者的基础要求不低，如果你对 C++11 之前的特性还一知半解，直接啃这本书可能会感到吃力。它更像是一本面向有经验的程序员的“精进手册”，而非面向初学者的“入门向导”。我记得有一次，我被书里关于协程（Coroutines）那部分的讨论卡住了，作者引入了多个状态机和内存布局的概念，试图用一种非常底层的方式来阐释异步编程的新范式。我花了整整一个下午，对照着自己手绘的调用栈图才勉强理解了那个复杂的执行流程。这种高强度的智力挑战是它最迷人的地方——它不会轻易给你答案，而是引导你像一个真正的工程师那样，去拆解问题、理解原理，直到自己豁然开朗。这种通过艰苦努力换来的知识，远比那些“五分钟掌握 C++”的快餐内容来得扎实和有成就感。

讲的非常散，不会的还是需要自己看note

讲的非常散，不会的还是需要自己看note

讲的非常散，不会的还是需要自己看note

讲的非常散，不会的还是需要自己看note

讲的非常散，不会的还是需要自己看note