This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)
|
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.
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.
TR1 includes the following components:
Reference wrapper – enables passing references, rather than copies, into algorithms or function objects. The feature was based on Boost.Ref. 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 Func, class Arg>
void g(Func 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), std::tr1::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 pointerweak_ptr – a variant of shared_ptr that doesn't increase the reference countThe proposal is based on Boost Smart Pointer library.
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
Function object binders (bind) – can bind any 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.
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.
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.
<random> header file – variate_generator, mersenne_twister, poisson_distribution, etc.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 int n, unsigned int m, double x); | |
| Associated Legendre polynomials | double assoc_legendre(unsigned int l, unsigned int 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 | 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 int n, double x); | |
| Hypergeometric series | double hyperg(double a, double b, double c, double x); | |
| Laguerre polynomials | double laguerre(unsigned int n, double x); | |
| Legendre polynomials | double legendre(unsigned int l, double x); | |
| Riemann zeta function | double riemann_zeta(double x); | |
| Spherical Bessel functions of the first kind | double sph_bessel(unsigned int n, double x); | |
| Spherical associated Legendre functions | double sph_legendre(unsigned int l, unsigned int m, double theta); | |
| Spherical Neumann functions | double sph_neumann(unsigned int n, double x); |
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 int n, float x);
long double sph_neumannl(unsigned int n, long double x);
<tuple> header file – tuplestd::pair<array> header file – arraystd::vector<unordered_set>, <unordered_map> header filesunordered_set, unordered_multiset, unordered_map, and unordered_multimap classes, analogous to set, multiset, map, and multimap, respectively
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<regex> header file – regex, regex_match, regex_search, regex_replace, etc.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).
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.