Book Categories

Description of Introduction to the Boost C++ Libraries; Volume I - Foundations

C++ is one of the most important and influential programming languages for application development. It supports the modular, object -oriented and generic programming models and its flexibility has been one of the main reasons why it has been so successful. With the emergence of the Boost Libraries (www.boost.org) we see that C++ is brought to a new level, namely a set of reusable and modular template libraries that C++ developers can use in their applications. This book is dedicated to a number of Boost libraries that model higher-order functions, data types and data structures, libraries for text and string processing, multi-threading, random number generation and more. We also discuss how Boost and design patterns are used to promote the flexibility of developer code. Each library is described in a step-by-step way. Numerous examples are given to show the functionality of each library. The full source code is freely available to purchasers of the book.

Coverage includes:

* Understanding and using 25 major Boost Libraries
* Learn about higher-order functions, data structures, memory management, multi-threading and more
* Using Boost in new and existing (legacy) applications
* Integrating Boost and the famous Gang-Of-Four design patterns
* Ready-to-run projects in Visual Studio
* Appendices and Exercises
* Full source code available (using the book registration form)

Title Information

ISBN:

9789491028014

Pages:

310 pages

Format:

Hardback

Product Code:

525911

Publisher:

Datasim Education

Published:

01/11/2010

Write a review of this book

Customer Reviews from Amazon

About Robert Demming and Daniel J. Duffy

Robert Demming is software designer, developer and trainer and he has been involved with numerous software projects in the areas of optical technology, process control, CAD and order processing systems since 1993. He has a BSc degree in technical computer science from Amsterdam Hogeschool.

Daniel J. Duffy is founder of Datasim Education BV and has been working with C++ and its applications since 1989. He is designer, algorithm builder and trainer. He has a PhD in numerical analysis from Trinity College, Dublin. One of the projects that he is involved in is applying the Boost libraries to finance and engineering.

Contents of Introduction to the Boost C++ Libraries; Volume I - Foundations

Preface
1 Modelling Functions
1.1 Goals and Objectives
1.2 What is a Function and why do we need Functions?
1.3 Function Pointers in C
1.4 Function Essentials
1.5 Modelling Algebraic Expressions using Function
1.6 Generic Functions and Functions as Data Members
1.7 Callback Functions and Notification Patterns
1.8 Class-based Callback Functions
1.9 Scalar, Vector and Vector-valued Functions
1.9.1 Scalar-valued Functions
1.9.2 Vector Functions
1.9.3 Vector-valued Functions
1.10 Conclusions and Summary
2 Bind
2.1 Introduction and Objectives
2.2 An Introduction to Function Objects
2.3 Predefined and User-defined Function Objects
2.4 The for_each() Algorithm
2.5 Function Adapters for Member Functions and Ordinary Functions
2.6 Introducing Bind
2.7 Placeholders and Arguments
2.8 Calling a Member Function
2.9 Using Bind with Function Objects
2.10 Dynamic Sorting and Bind
2.11 Function Composition
2.12 Applications and Relationships with STL and Boost
2.13 Summary and Conclusions
3 Event Notification, Observer Pattern and Signals Library
3.1 Introduction and Objectives
3.2 Notification Patterns in Object-Oriented Systems
3.3 The GOF Observer Pattern: what is it and what are the Problems?
3.3.1 The GOF Observer Pattern: Critique
3.4 An Introduction to the Signals Library
3.5 Signals and Slots
3.6 Slot Groups
3.7 Objects playing Roles of Signals and Slots
3.8 Connection Management and the connection Class
3.9 Creating Slots using Bind and Lambda
3.9.1 Creating Slots "on the fly" with Lambda
3.9.2 Creating Slot Types with Bind
3.10 Combiners
3.11 Thread-Safe Signals Library
3.12 The GOF Observer Pattern revisited
3.13 Summary and Conclusions
4 Phoenix
4.2 Motivating Phoenix: a Test Case
4.3 Introduction to Functional Programming
4.3.1 Lambda Calculus and Lambda Functions
4.4 The Architecture of Phoenix
4.5 Actors, Arguments and Fundamentals
4.6 Composite
4.7 Function and Operator
4.8 Statement
4.9 Object
4.10 Scope and Local Variables
4.11 Bind
4.12 Container
4.13 Algorithm
4.14 Summary and Conclusions
5 Smart Pointers and Serialization
5.1 Introduction and Objectives
5.2 An Introduction to Memory Management
5.3 An Introduction to Smart Pointers
5.4 Scoped Pointers and Scoped Arrays
5.5 Shared Pointer and Shared Arrays
5.5.1 Functionality of shared_ptr
5.5.2 Stop Sharing Ownership
5.5.3 Retrieving the Resource from Shared Data
5.5.4 Shared Arrays
5.5.5 Custom Deleters
5.6 Weak Pointers
5.7 Smart Pointers and Exception Handling
5.8 Using Smart Pointers with STL Containers
5.9 Test Case: creating smart Composite Objects
5.10 Serialization and Object Persistence
5.10.1 Main Concepts and Initial Examples
5.10.2 STL Containers and Serialisation of more Complex Objects
5.10.3 XML Serialisation and Deserialisation
5.10.4 An Example from Boost Documentation: Serialization Tutorial
5.11 Summary and Conclusions
6 Tuple
6.1 Introduction and Objectives
6.2 An Introduction to n-Tuples
6.3 The tuple Class: Fundamental Properties
6.4 Accessing Tuple Elements
6.5 Comparing Tuples
6.6 Tuples and Streaming
6.7 Applications of Tuple
6.8 Summary and Conclusions
7 Any
7.1 Introduction and Objectives
7.2 The any Class: Fundamental Properties
7.3 Using any with Smart Pointers
7.4 STL Containers whose Elements are of Type any
7.5 Property Sets with heterogeneous Elements
7.6 Initialisation of Data with Assign Library
7.7 Summary and Conclusions
8 Variant
8.1 Introduction and Objectives
8.2 What is a Discriminated Union?
8.3 The variant Class Template: Hello World Example
8.4 Member Functions in variant
8.5 Type-safe Visitation of Variants
8.6 Summary and Conclusions
9 Number and other Algebraic Systems
9.1 Introduction and Objectives
9.2 A Review of STL complex Template Class
9.2.1 Application: Discrete Fourier Transform (DFT)
9.3 Complex Numbers Algorithms
9.4 Rational Numbers
9.5 Greatest Common Divisor (gcd) and Least Common Multiple (lcm)
9.5.1 More general Cases
9.6 Quaternions and Octonians
9.7 Conversions
9.8 Summary and Conclusions
10 String Algorithm
10.1 Introduction and Objectives
10.2 Case Conversion, Trimming and Predicates
10.3 Find Algorithms
10.4 Erase and Replace
10.5 Split and Join
10.6 Finders and Formatters
10.7 Iterators
10.7.1 Creating Custom Formatters
10.8 Classification
10.9 Creating Name-Value Maps
10.10 The Range Library
10.11 Summary and Conclusions
11 Tokenizer
11.1 Introduction and Objectives
11.2 What is a Token?
11.3 The Token Class, Token Iterator and Token Function
11.3.1 Token Class
11.3.2 TokenizerFunction Concept
11.3.3 Token Iterator
11.3.4 Examples
11.4 Conversions and Casting Examples
11.5 Summary and Conclusions
12 Regex
12.1 Introduction and Objectives
12.2 Alphabet, Words and Language
12.3 An Introduction to Regular Expressions
12.4 Regex Functionality
12.5 The Class basic_regex
12.6 Regular Expression Matching
12.7 Searching
12.8 Replacing
12.9 Dynamic Regular Expressions and Exception Handling
12.10 Regex and Callbacks
12.11 Summary and Conclusions
13 An Introduction to Expression Templates and Xpressive
13.1 Introduction and Objectives
13.2 Binary Trees and Expression Trees
13.2.1 Traversing Binary Trees
13.2.2 Extended Binary Trees
13.3 An Introduction to Expression Templates
13.4 An Introduction to Xpressive 180
13.5 First Encounters with Xpressive
13.6 Regex Object and Matches
13.7 Nested Regex and simple Grammar
13.8 Semantic Actions
13.9 More Semantic Actions
13.10 Conclusions and Summary
14 MultiArray and Array
14.1 Introduction and Objectives
14.2 A Quick „101‟ Tour of MultiArray
14.3 Overview of MultiArray Functionality
14.4 Specifying Array Dimensions
14.5 Accessing the Elements of a Multi-Array
14.6 Setting the Array Base
14.7 Storage Ordering
14.8 Array
14.9 Applications of Boost.Array
14.10 Four-dimensional Arrays
14.11 Views and Slices
14.11.1 Zooming
14.11.2 Slicing
14.12 MultiArray Adaptors
14.13 Utility Print Functions
14.14 MultiArrays in Combination with other Data Structures
14.15 Summary and Conclusions
15 Random Number Generation
15.1 Introduction and Objectives
15.2 Overview of Random Number Generation
15.3 Random Number Generators in Boost
15.4 variate_generator
15.5 Performance, Reliability, Suitability and Accuracy Requirements
15.6 Examples using Random Number Generators
15.6.1 Calculating
15.6.2 Finding Real Roots of a Quadratic Equation
15.6.3 Kernel Density Estimation
15.7 Conclusions and Summary
16 Flyweight and Functional/Hash
16.1 Introduction and Objectives
16.2 The “Hello World” Example
16.3 Flyweight Requirements
16.4 Key-Value Flyweights
16.5 Flyweight Factory Specification
16.6 Tracking and Lifecycle Policies
16.7 Tagging Policies
16.8 Holders
16.9 Locking Policies and Thread-Safe Code
16.10 Summary and Conclusions
16.11 Appendix: Functional/Hash
17 Integrating Legacy Applications with Boost
17.1 Introduction and Objectives
17.2 Migrating Legacy Code to Boost: The CADObject Project
17.3 CADObject Architecture: Version One
17.4 CADObject Architecture: Version Two
17.5 CADObject Architecture: Version Three
17.6 Using Boost.Serialization
17.7 Factories and Deserialisation
17.8 Conclusions and Summary
18 Thread
18.1 Introduction and Objectives
18.2 An Introduction to Threads
18.3 The Life of a Thread
18.3.1 How Threads Communicate
18.4 What Kinds of Applications are suitable for Multi-Threading?
18.4.1 Suitable Tasks for Multi-threading
18.5 The Boost thread class
18.6 The Life of a Thread
18.7 Basic Thread Synchronization
18.8 Thread Interruption
18.9 Thread Notification
18.10 Thread Groups
18.11 Shared Queue Pattern
18.12 The Producer-Consumer Pattern
18.13 Volatile Variables
18.14 Thread Local Storage
18.15 Summary and Conclusions
Appendix A: Advanced Generic Programming
Introduction and Objectives
Some Useful Techniques
Traits Classes
An Introduction to Policy-based Design
Curiously Recurring Template Pattern (CRTP)
The Boost Categories
Appendix B: Boost, Design Patterns and Applications
Introduction and Objectives
An Overview of Design Patterns
Boost and Design Patterns
Which Boost Libraries "Bootstrap" the GOF Design Patterns?
Creating Layered Software Systems
Appendix C: Exercises and Projects
Introduction and Objectives
Epilogue and Volume II Contents
Bibliography
Index
Book Registration Form