Variable Number of Arguments

Most extensions to the new C++ standards only relate to the libraries; however, a number of changes affect the core of the language. Most of these changes are cosmetic. For example, the parser can now handle angled brackets in nested template definitions, such as vector<vector<int>> (previously, developers had to put a space between the final ">>" to avoid confusion with the left shift >> operator).

Templates with a variable number of parameters are probably the biggest change to the core. One possible application of this concept is that of implementing a typecast tuple class, as shown in the following example:

template<typename... REST>
struct tuple;
template<>
struct tuple<>{};
template<typename T>
struct tuple<T>{ T car;};
template<typename T, typename... REST>
struct tuple<T,REST...> { T car; tuple<REST...> cdr;};
int main() {
tuple<int, char> t;
t.car = 1;
t.cdr.car = 'a';
}

The new standard library tuple provides a far more sophisticated tuple class.

Random Generators

The random generator taken from C was designed for very simple simulations. The new rand library has far more extensive capabilities. For example, you can choose from several methods of generating pseudo-random numbers. All parameters are freely selectable, but if you are not an expert in the random generator field, you are probably better off using one of the many preset methods. Besides the methods for generating pseudo-random numbers, you will also find a large selection of distribution methods (uniform distribution, Gaussian distribution, etc.).

The GCC implementation of rand is still not perfect; however, the differences between it and the C++ standard to come are more or less cosmetic and likely to disappear in future versions. For example, the std::uniform_real_distribution class is still called std::uniform_real, and it still lacks a default_random_engine.

Type Traits

If you make heavy use of templates, you are likely to encounter the following problem sooner or later: You want to write a template class or function, but the code only works if the type has additional properties. The type_traits library gives you an elegant approach to testing for this issue:

template<typename T> T f(T a) {
static_assert(std::is_floating_point<T>::value == true, "f needs a floating point argument!");
...
}

The static_assert command is also new. static_assert defines an assertion at build time. The standard copy command is a complex application of type traits. A naive implementation always calls the copy constructor of the objects. A more sophisticated implementation uses the faster memcpy for simple types.

An implementation of copy is shown in Listing 1, although it is still somewhat simplified. If you have access to the internal structure of the standard container, you can and should handle vector iterators separately.