C++ Technical Report 1

Document that proposed additions to the C++ standard library From Wikipedia, the free encyclopedia

C++ Technical Report 1 (TR1) is the common name for ISO/IEC TR 19768, C++ Library Extensions, which is a document that proposed 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.

Overview

Compilers did not need to include the TR1 components in order to conform to the C++ standard, because TR1 proposals were not part of the standard itself, only a set of possible additions that were still to be ratified. However, most of TR1 was available from Boost, and several compiler/library distributors implemented all or some of the components. TR1 is not the complete list of additions to the library that appeared in C++11. For example, C++11 includes a 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.

Components

Summarize
Perspective

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.[1] 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.[2]

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[3]

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.[4]

Function return types (result_of) – determines the type of a call expression.

Member functions (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.[5]

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.[6]

Numerical facilities

Random number generation

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.

  • additions to the <cmath>/<math.h> header files – beta, legendre, etc.

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.

More information , ...
Function nameFunction prototypeMathematical expression
Associated Laguerre polynomials double assoc_laguerre( unsigned n, unsigned m, double x ) ;
Associated Legendre polynomials double assoc_legendre( unsigned l, unsigned m, double x ) ;
Beta function double beta( double x, double y ) ;
Complete elliptic integral of the first kind double comp_ellint_1( double k ) ;
Complete elliptic integral of the second kind double comp_ellint_2( double k ) ;
Complete elliptic integral of the third kind double comp_ellint_3( double k, double nu ) ;
Confluent hypergeometric functions double conf_hyperg( double a, double c, double x ) ;
Regular modified cylindrical Bessel functions double cyl_bessel_i( double nu, double x ) ;
Cylindrical Bessel functions of the first kind double cyl_bessel_j( double nu, double x ) ;
Irregular modified cylindrical Bessel functions double cyl_bessel_k( double nu, double x ) ;
Cylindrical Neumann functions

Cylindrical Bessel functions of the second kind

double cyl_neumann( double nu, double x ) ;
Incomplete elliptic integral of the first kind double ellint_1( double k, double phi ) ;
Incomplete elliptic integral of the second kind double ellint_2( double k, double phi ) ;
Incomplete elliptic integral of the third kind double ellint_3( double k, double nu, double phi ) ;
Exponential integral double expint( double x ) ;
Hermite polynomials double hermite( unsigned n, double x ) ;
Hypergeometric series double hyperg( double a, double b, double c, double x ) ;
Laguerre polynomials double laguerre( unsigned n, double x ) ;
Legendre polynomials double legendre( unsigned l, double x ) ;
Riemann zeta function double riemann_zeta( double x ) ;
Spherical Bessel functions of the first kind double sph_bessel( unsigned n, double x ) ;
Spherical associated Legendre functions double sph_legendre( unsigned l, unsigned m, double theta ) ;
Spherical Neumann functions

Spherical Bessel functions of the second kind

double sph_neumann( unsigned n, double x ) ;
Close

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[7]
  • 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[8]
  • 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
  • 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[9]
  • 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.TR2 call for proposals.

Some of the proposals included:

After the call was issued for proposals for TR2, ISO procedures were changed, so 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), a revision of the C standard which incorporated some features proposed in TR1
  • 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

References

Loading related searches...

Wikiwand - on

Seamless Wikipedia browsing. On steroids.