CGAL 6.1.2 - STL Extensions for CGAL: CGAL::Default Struct Reference

CGAL 6.1.2 - STL Extensions for CGAL

Loading...
Searching...
No Matches
Classes
CGAL::Default Struct Reference
Reference Manual

`#include <CGAL/Default.h>`

## Definition

`Default` is a tag class.

It can be used to state that one wants to use the default argument of a template parameter of a class template.

This can be useful in several cases: (a) when one needs a non-default value for another template parameter coming next (since C++ only supports defaults at the end of lists), (b) when the default is actually a complex expression, e.g. referring to previous template parameters (in this case, it shortens compiler error messages and mangled symbol names), (c) when defining the default involves circular dependencies of type instantiations (there, it breaks the cycle in a nice way).

Using the mechanism is easy: just plug `Default` as template argument in the place where you would like to use the default. You should refer to the documentation of the template class you are using in order to know whether this functionality is offered.

Also beware that the type of the instantiated template class will not be the same when instantiating it using `Default` instead of the type of the default argument, even though their interfaces will otherwise be the same. This may have consequences in some cases.

Is model of
  `DefaultConstructible`
  `CopyConstructible`

In order to help the template class writer, `Default` provides a convenient way to extract the desired type for a template parameter which may be defaulted using `Default`. It is enough to fetch the type as `Default::Get<Parameter, Type>::type`, as in the example program below.

Example

File STL_Extension/Default.cpp

#include <CGAL/Default.h>
#include <CGAL/use.h>
// A is a concrete type
struct A {};
void use_a(A) {}
// B is the template class which has 2 template parameters
// with default arguments : A and int.
template < typename A1_ = A, typename A2 = int >
struct B
{
B()
: a1()
{}
// Note that it is also possible to use CGAL::Default
// instead of A as the default argument for A1_ above.
// Extract the desired type for A1 :
typedef typename CGAL::Default::Get<A1_, A>::type A1;
A1 a1;
};
int main ()
{
B<CGAL::Default, double> b;
use_a(b.a1); // It is really of type A.
}
unspecified_type

## Classes
struct | Get
| A nested template providing a typedef `type` which equals `Type` if `Parameter` is `Default`, and `Parameter` otherwise. More...
struct | Lazy_get
| A nested template providing a typedef `type` which equals `MetaFct::type` if `Parameter` is `Default`, and `Parameter` otherwise. More...