## Frequent Links

# C++ Technical Report 1

**C++ Technical Report 1** (**TR1**) is the common name for * ISO/IEC TR 19768, C++ Library Extensions*, which was a document proposing additions to the C++ standard library for the C++03 language standard. The additions include regular expressions, smart pointers, hash tables, and random number generators. TR1 was not a standard itself, but rather a draft document. However, most of its proposals became part of the later official standard, C++11. Before C++11 was standardized, vendors used this document as a guide to create extensions. The report's goal was "to build more widespread existing practice for an expanded C++ standard library."

The report was first circulated in draft form in 2005 as Draft Technical Report on C++ Library Extensions, then published in 2007 as an ISO/IEC standard as ISO/IEC TR 19768:2007.

## Contents

## Overview

Compilers needed not include the TR1 components to be conforming to the C++ standard, because TR1 proposals were not part of the standard itself, but only a set of possible additions that were still to be ratified. However, most of it was available from Boost, and several compiler/library distributors implemented all or part of the components. TR1 was not a complete list of additions to the library that were going to appear in the next standard, C++11. For example, C++11 includes thread support library that is not available in TR1.

The new components were defined in the `std::tr1`

namespace to distinguish them from the then current standard library.

There is also a second technical report, C++ Technical Report 2, planned for publishing after C++11.^{[1]}

## Components

TR1 includes the following components:

### General utilities

**Reference wrapper** – enables passing references, rather than copies, into algorithms or function objects. The feature was based on Boost.Ref.^{[2]} A wrapper reference is obtained from an instance of the template class `reference_wrapper`

. Wrapper references are similar to normal references (‘&’) of the C++ language. To obtain a wrapper reference from any object the template class `ref`

is used (for a constant reference `cref`

is used).

Wrapper references are useful above all for template functions, when argument deduction would not deduce a reference (e.g. when forwarding arguments):

#include <iostream> #include <tr1/functional> void f( int &r ) { ++r; } template< class Funct, class Arg > void g( Funct f, Arg t ) { f(t); } int main() { int i = 0; g( f, i ); // 'g< void(int &r), int >' is instantiated std::cout << i << "\n"; // Output: 0 g( f, std::tr1::ref(i) ); // 'g< void(int &r), reference_wrapper<int> >' is instanced std::cout << i << "\n"; // Output: 1 }

**Smart pointers** – adds several classes that simplify object lifetime management in complex cases. Three main classes are added:

`shared_ptr`

– a reference-counted smart pointer`weak_ptr`

– a variant of`shared_ptr`

that doesn't increase the reference count

The proposal is based on Boost Smart Pointer library.^{[3]}

### Function objects

These four modules are added to the `<functional>`

header file:

**Polymorphic function wrapper** (`function`

) – can store any callable function (function pointers, member function pointers, and function objects) that uses a specified function call signature. The type does not depend on the kind of the callable used. Based on Boost.Function^{[4]}

**Function object binders** (`bind`

) – can bind any parameter parameters to function objects. Function composition is also allowed. This is a generalized version of the standard `std::bind1st`

and `std::bind2nd`

bind functions. The feature is based on Boost Bind library.^{[5]}

**Function return types** (`result_of`

) – determines the type of a call expression.

** mem_fn** – enhancement to the standard

`std::mem_fun`

and `std::mem_fun_ref`

. Allows pointers to member functions to be treated as function objects. Based on Boost Mem Fn library.^{[6]}

### Metaprogramming and type traits

There is now `<type_traits>`

header file that contains many useful trait meta-templates, such as `is_pod`

, `has_virtual_destructor`

, `remove_extent`

, etc. It facilitates metaprogramming by enabling queries on and transformation between different types. The proposal is based on Boost Type Traits library.^{[7]}

### Numerical facilities

#### Random number generation

- new
`<random>`

header file –`variate_generator`

,`mersenne_twister`

,`poisson_distribution`

, etc. - utilities for generating random numbers using any of several Pseudorandom number generators, engines, and probability distributions

#### Mathematical special functions

**Some features of TR1, such as the mathematical special functions and certain C99 additions, are not included in the Visual C++ implementation of TR1.**
The Mathematical special functions library was not standardized in C++11.

These functions will likely be of principal interest to programmers in the engineering and scientific disciplines.

The following table shows all 23 special functions described in TR1.

Function name | Function prototype | Mathematical expression |
---|---|---|

Associated Laguerre polynomials | double assoc_laguerre( unsigned n, unsigned m, double x ) ; |
<math>{L_n}^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n+m}(x), \text{ for } x \ge 0</math> |

Associated Legendre polynomials | double assoc_legendre( unsigned l, unsigned m, double x ) ; |
<math>{P_l}^m(x) = (1-x^2)^{m/2} \frac{d^m}{dx^m} P_l(x), \text{ for } x \ge 0</math> |

Beta function | double beta( double x, double y ) ; |
<math>\Beta(x,y)=\frac{\Gamma(x) \Gamma(y)}{\Gamma(x+y)}</math> |

Complete elliptic integral of the first kind | double comp_ellint_1( double k ) ; |
<math>K(k) = F\left(k, \textstyle \frac{\pi}{2}\right) = \int_0^{\frac{\pi}{2}} \frac{d\theta}{\sqrt{1 - k^2 \sin^2 \theta}}</math> |

Complete elliptic integral of the second kind | double comp_ellint_2( double k ) ; |
<math>E\left(k, \textstyle \frac{\pi}{2}\right) = \int_0^{\frac{\pi}{2}} \sqrt{1 - k^2 \sin^2 \theta}\; d\theta</math> |

Complete elliptic integral of the third kind | double comp_ellint_3( double k, double nu ) ; |
<math>\Pi\left(\nu, k, \textstyle \frac{\pi}{2}\right) = \int_0^{\frac{\pi}{2}} \frac{d\theta}{(1 - \nu \sin^2 \theta)\sqrt{1 - k^2 \sin^2 \theta}}</math> |

Confluent hypergeometric functions | double conf_hyperg( double a, double c, double x ) ; |
<math>F(a, c, x) = \frac{\Gamma(c)}{\Gamma(a)} \sum_{n = 0}^\infty \frac{\Gamma(a + n) x^n}{\Gamma(c + n) n!}</math> |

Regular modified cylindrical Bessel functions | double cyl_bessel_i( double nu, double x ) ; |
<math>I_\nu(x) = i^{-\nu} J_\nu(ix) = \sum_{k = 0}^\infty \frac{(x/2)^{\nu + 2k}}{k! \; \Gamma(\nu + k + 1)}, \text{ for } x \ge 0</math> |

Cylindrical Bessel functions of the first kind | double cyl_bessel_j( double nu, double x ) ; |
<math>J_\nu(x) = \sum_{k = 0}^\infty \frac{(-1)^k \; (x/2)^{\nu + 2k}}{k! \; \Gamma(\nu + k + 1)}, \text{ for } x \ge 0</math> |

Irregular modified cylindrical Bessel functions | double cyl_bessel_k( double nu, double x ) ; |
<math>\begin{align}
K_\nu(x) & = \textstyle\frac{\pi}{2} i^{\nu+1} \big(J_\nu(ix) + i N_\nu(ix)\big) \\ & = \begin{cases} \displaystyle \frac{I_{-\nu}(x) - I_\nu(x)}{\sin \nu\pi}, & \text{for } x \ge 0 \text{ and } \nu \notin \mathbb{Z} \\[10pt] \displaystyle \frac{\pi}{2} \lim_{\mu \to \nu} \frac{I_{-\mu}(x) - I_\mu(x)}{\sin \mu\pi}, & \text{for } x < 0 \text{ and } \nu \in \mathbb{Z} \\ \end{cases} \end{align}</math> |

Cylindrical Neumann functions | double cyl_neumann( double nu, double x ) ; |
<math>
N_\nu(x) = \begin{cases} \displaystyle \frac{J_\nu(x)\cos \nu\pi - J_{-\nu}(x)}{\sin \nu\pi}, & \text{for } x \ge 0 \text{ and } \nu \notin \mathbb{Z} \\[10pt] \displaystyle \lim_{\mu \to \nu} \frac{J_\mu(x)\cos \mu\pi - J_{-\mu}(x)}{\sin \mu\pi}, & \text{for } x < 0 \text{ and } \nu \in \mathbb{Z} \\ \end{cases} </math> |

Incomplete elliptic integral of the first kind | double ellint_1( double k, double phi ) ; |
k\right| \le 1</math> |

Incomplete elliptic integral of the second kind | double ellint_2( double k, double phi ) ; |
k\right| \le 1</math> |

Incomplete elliptic integral of the third kind | double ellint_3( double k, double nu, double phi ) ; |
k\right| \le 1</math> |

Exponential integral | double expint( double x ) ; |
<math> \mbox{E}i(x)=-\int_{-x}^{\infty} \frac{e^{-t}}{t}\, dt</math> |

Hermite polynomials | double hermite( unsigned n, double x ) ; |
<math>H_n(x)=(-1)^n e^{x^2}\frac{d^n}{dx^n}e^{-x^2}\,\!</math> |

Hypergeometric series | double hyperg( double a, double b, double c, double x ) ; |
<math>F(a,b,c,x)=\frac{\Gamma(c)}{\Gamma(a)\Gamma(b)}\sum_{n = 0}^\infty\frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)}\frac{x^n}{n!}</math> |

Laguerre polynomials | double laguerre( unsigned n, double x ) ; |
<math>L_n(x)=\frac{e^x}{n!}\frac{d^n}{dx^n}\left(x^n e^{-x}\right), \text{ for } x \ge 0</math> |

Legendre polynomials | double legendre( unsigned l, double x ) ; |
x\right| \le 1 </math> |

Riemann zeta function | double riemann_zeta( double x ) ; |
<math>
\Zeta(x) = \begin{cases} \displaystyle \sum_{k = 1}^\infty k^{-x}, & \text{for } x > 1 \\[10pt] \displaystyle 2^x\pi^{x-1}\sin\left(\frac{x\pi}{2}\right)\Gamma(1-x)\zeta(1-x), & \text{for } x < 1 \\ \end{cases} </math> |

Spherical Bessel functions of the first kind | double sph_bessel( unsigned n, double x ) ; |
<math>j_n(x) = \sqrt{\frac{\pi}{2x}} J_{n+1/2}(x), \text{ for } x \ge 0</math> |

Spherical associated Legendre functions | double sph_legendre( unsigned l, unsigned m, double theta ) ; |
m| \leq l</math> |

Spherical Neumann functions | double sph_neumann( unsigned n, double x ) ; |
<math>n_n(x) = \left(\frac{\pi}{2x}\right)^{\frac{1}{2}}N_{n+\frac{1}{2}}(x), \text{ for } x \ge 0</math> |

Each function has two additional variants. Appending the suffix ‘**f**’ or ‘**l**’ to a function name gives a function that operates on `float`

or `long double`

values respectively. For example:

float sph_neumannf( unsigned n, float x ) ; long double sph_neumannl( unsigned n, long double x ) ;

### Containers

#### Tuple types

- new
`<tuple>`

header file –`tuple`

- based on Boost Tuple library
^{[8]} - vaguely an extension of the standard
`std::pair`

- fixed size collection of elements, which may be of different types

#### Fixed size array

- new
`<array>`

header file –`array`

- taken from Boost Array library
^{[9]} - as opposed to dynamic array types such as the standard
`std::vector`

#### Hash tables

- new
`<unordered_set>`

,`<unordered_map>`

header files - they implement the
`unordered_set`

,`unordered_multiset`

,`unordered_map`

, and`unordered_multimap`

classes, analogous to`set`

,`multiset`

,`map`

, and`multimap`

, respectively- unfortunately,
`unordered_set`

and`unordered_multiset`

cannot be used with the`set_union`

,`set_intersection`

,`set_difference`

,`set_symmetric_difference`

, and`includes`

standard library functions, which work for`set`

and`multiset`

- unfortunately,
- new implementation, not derived from an existing library, not fully API compatible with existing libraries
- like all hash tables, often provide constant time lookup of elements but the worst case can be linear in the size of the container

### Regular expressions

- new
`<regex>`

header file –`regex`

,`regex_match`

,`regex_search`

,`regex_replace`

, etc. - based on Boost RegEx library
^{[10]} - pattern matching library

### C compatibility

C++ is designed to be compatible with the C programming language, but is not a strict superset of C due to diverging standards. TR1 attempts to reconcile some of these differences through additions to various headers in the C++ library, such as <complex>, <locale>, <cmath>, etc. These changes help to bring C++ more in line with the C99 version of the C standard (not all parts of C99 are included in TR1).

## Technical Report 2

In 2005, a request for proposals for a TR2 was made with a special interest in Unicode, XML/HTML, Networking and usability for novice programmers.[3].

Some of the proposals included:

- Threads [4]
- The Asio C++ library (networking [5][6]).
- Signals/Slots [7][8]
- Filesystem Library [9] – Based on the Boost Filesystem Library, for query/manipulation of paths, files and directories.
- Boost Any Library [10]
- Lexical Conversion Library [11]
- New String Algorithms [12]
- Toward a More Complete Taxonomy of Algebraic Properties for Numeric Libraries in TR2 [13]
- Adding heterogeneous comparison lookup to associative containers for TR2 [14]

Since the call for proposals for TR2, changes to ISO procedures meant that there will not be a TR2, instead enhancements to C++ will be published in a number of Technical Specifications. Some of the proposals listed above are already included in the C++ standard or in draft versions of the Technical Specifications.

## See also

- C++11, standard for the C++ programming language; the library improvements were based on TR1
- C11 (C standard revision), the most recent standard for the C programming language
- Boost library, a large collection of portable C++ libraries, several of which were included in TR1
- Standard Template Library, part of the current C++ Standard Library

## Notes

- ↑ [1]
- ↑ Chapter 22. Boost.Ref – Boost 1.48.0
- ↑ Smart Pointers – Boost 1.48.0
- ↑ Chapter 9. Boost.Function – Boost 1.48.0
- ↑ Boost: bind.hpp documentation – Boost 1.48.0
- ↑ Boost: mem_fn.hpp documentation – Boost 1.48.0
- ↑ [2]
- ↑ The Boost Tuple Library – Boost 1.48.0
- ↑ Chapter 3. Boost.Array – Boost 1.48.0
- ↑ Boost.Regex – Boost 1.36.0

## References

- ISO/IEC JTC1/SC22/WG21 (2005-06-24). "Draft Technical Report on C++ Library Extensions" (PDF).
- "ISO/IEC TR 19768:2007".
- Becker, Peter (2006).
*The C++ Standard Library Extensions: A Tutorial and Reference*. Addison-Wesley Professional. ISBN 0-321-41299-0.

## External links

- Scott Meyers' Effective C++: TR1 Information – contains links to the TR1 proposal documents which provide background and rationale for the TR1 libraries.