CGAL 6.2 - STL Extensions for CGAL

Loading...
Searching...
No Matches
List of all members | Public Member Functions | Related Functions
CGAL::Quadruple< T1, T2, T3, T4 > Class Template Reference
Reference Manual » Utilities

`#include <CGAL/utility.h>`

## Definition

template<typename T1, typename T2, typename T3, typename T4>
class CGAL::Quadruple< T1, T2, T3, T4 >

The Quadruple class is an extension of `std::pair`.

`Quadruple` is a heterogeneous quadruple: it holds one object of type `T1`, one of type `T2`, one of type `T3`, and one of type `T4`. A `Quadruple` is much like a container, in that it "owns" its elements. It is not actually a model of container, though, because it does not support the standard methods (such as iterators) for accessing the elements of a container.

`std::tuple` or `std::array` instead for new uses.

Requirements

`T1`, `T2`, `T3` and `T4` must be `Assignable`. Additional operations have additional requirements.

## Public Member Functions
template<class T1 , class T2 , class T3 , class T4 >
bool | operator< (Quadruple< T1, T2, T3, T4 > x, Quadruple< T1, T2, T3, T4 > y)
| The comparison operator.
template<class T1 , class T2 , class T3 , class T4 >
bool | operator== (Quadruple< T1, T2, T3, T4 > x, Quadruple< T1, T2, T3, T4 > y)
| The equality operator.

## Related Functions
(Note that these are not member functions.)
template<class T1 , class T2 , class T3 , class T4 >
Quadruple< T1, T2, T3, T4 > | make_quadruple (T1 x, T2 y, T3 z, T4 w)
| Equivalent to `Quadruple<T1, T2, T3, T4>(x, y, z, w)`.
template<class T1 , class T2 , class T3 , class T4 >
Quadruple< T1, T2, T3, T4 > | make_tuple (T1 x, T2 y, T3 z, T4 w)
| Equivalent to `Quadruple<T1, T2, T3, T4>(x, y, z, w)`.

## Types
typedef T1 | first_type
typedef T2 | second_type
typedef T3 | third_type
typedef T4 | fourth_type

## Variables
T1 | first
| first element.
T2 | second
| second element.
T3 | third
| third element.
T4 | fourth
| fourth element.

## Creation
| Quadruple ()
| introduces a quadruple using the default constructor of the four elements.
| Quadruple (T1 x, T2 y, T3 z, T4 w)
| constructs a quadruple such that `first` is constructed from `x`, `second` is constructed from `y`, `third` is constructed from `z`, and `fourth` is constructed from `w`.
template<class U , class V , class W , class X >
| Quadruple (U u, V v, W w, X x)
| constructs a quadruple such that `first` is constructed from `u`, `second` is constructed from `v`, `third` is constructed from `w`, and `fourth` is constructed from `x`.
template<int i>
T | get ()
| Gives access to `first`, `second`, `third` or `fourth` whenever `i` is 0, 1, 2 or 3, via a, potentially const, reference.

## Constructor & Destructor Documentation

## ◆ Quadruple()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class U , class V , class W , class X >

CGAL::Quadruple< T1, T2, T3, T4 >::Quadruple | ( | U | u,
|  | V | v,
|  | W | w,
|  | X | x
| ) |  |

constructs a quadruple such that `first` is constructed from `u`, `second` is constructed from `v`, `third` is constructed from `w`, and `fourth` is constructed from `x`.

Proper conversion operators must exist from `U` to `T1`, `V` to `T2`, `W` to `T3`, and `X` to `T4`.

## Member Function Documentation

## ◆ get()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<int i>

T CGAL::Quadruple< T1, T2, T3, T4 >::get | ( |  | ) |

Gives access to `first`, `second`, `third` or `fourth` whenever `i` is 0, 1, 2 or 3, via a, potentially const, reference.

Note: `T` stands for `T1`, `T2`, `T3` or `T4` depending on `i`.

## ◆ operator<()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class T1 , class T2 , class T3 , class T4 >

bool CGAL::Quadruple< T1, T2, T3, T4 >::operator< | ( | Quadruple< T1, T2, T3, T4 > | x,
|  | Quadruple< T1, T2, T3, T4 > | y
| ) |  |

The comparison operator.

It uses lexicographic comparison: the return value is true if the first element of `x` is less than the first element of `y`, and false if the first element of `y` is less than the first element of `x`. If neither of these is the case, then it returns true if the second element of `x` is less than the second element of `y`, and false if the second element of `y` is less than the second element of `x`. If neither of these is the case, then it returns true if the third element of `x` is less than the third element of `y`, and false if the third element of `y` is less than the third element of `x`. If neither of these is the case, then it returns the result of comparing the fourth elements of `x` and `y`. This operator may only be used if `T1`, `T2`, `T3`, and `T4` define the comparison operator.

## ◆ operator==()

template<typename T1 , typename T2 , typename T3 , typename T4 >
template<class T1 , class T2 , class T3 , class T4 >

bool CGAL::Quadruple< T1, T2, T3, T4 >::operator== | ( | Quadruple< T1, T2, T3, T4 > | x,
|  | Quadruple< T1, T2, T3, T4 > | y
| ) |  |

The equality operator.

The return value is true if and only the first elements of `x` and `y` are equal, the second elements of `x` and `y` are equal, the third elements of `x` and `y` are equal, and the fourth elements of `x` and `y` are equal. This operator may only be used if `T1`, `T2`, `T3`, and `T4` define the equality operator.

## Member Data Documentation

## ◆ first

template<typename T1 , typename T2 , typename T3 , typename T4 >

T1 CGAL::Quadruple< T1, T2, T3, T4 >::first

first element.

Please access it using `get<0>()`.

## ◆ fourth

template<typename T1 , typename T2 , typename T3 , typename T4 >

T4 CGAL::Quadruple< T1, T2, T3, T4 >::fourth

fourth element.

Please access it using `get<3>()`.

## ◆ second

template<typename T1 , typename T2 , typename T3 , typename T4 >

T2 CGAL::Quadruple< T1, T2, T3, T4 >::second

second element.

Please access it using `get<1>()`.

## ◆ third

template<typename T1 , typename T2 , typename T3 , typename T4 >

T3 CGAL::Quadruple< T1, T2, T3, T4 >::third

third element.

Please access it using `get<2>()`.