# QPair Struct

template <typename T1, typename T2> struct QPairThe QPair class is a template class that stores a pair of items. More...

Header: | #include <QPair> |

qmake: | QT += core |

**Note:** All functions in this struct are reentrant.

## Public Types

typedef | first_type |

typedef | second_type |

## Public Functions

QPair(QPair<TT1, TT2> &&p) | |

QPair(const QPair<TT1, TT2> &p) | |

QPair(const T1 &value1, const T2 &value2) | |

QPair() | |

void | swap(QPair<T1, T2> &other) |

QPair<T1, T2> & | operator=(const QPair<TT1, TT2> &p) |

QPair<T1, T2> & | operator=(QPair<TT1, TT2> &&p) |

## Public Variables

## Related Non-Members

QPair<T1, T2> | qMakePair(const T1 &value1, const T2 &value2) |

void | swap(QPair<T1, T2> &lhs, QPair<T1, T2> &rhs) |

bool | operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

bool | operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

QDataStream & | operator<<(QDataStream &out, const QPair<T1, T2> &pair) |

bool | operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

bool | operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

bool | operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

bool | operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) |

QDataStream & | operator>>(QDataStream &in, QPair<T1, T2> &pair) |

## Detailed Description

QPair<T1, T2> can be used in your application if the STL `pair`

type is not available. It stores one value of type T1 and one value of type T2. It can be used as a return value for a function that needs to return two values, or as the value type of a generic container.

Here's an example of a QPair that stores one QString and one `double`

value:

QPair<QString, double> pair;

The components are accessible as public data members called first and second. For example:

pair.first = "pi"; pair.second = M_PI;

Note, however, that it is almost always preferable to define a small struct to hold the result of a function with multiple return values. A struct trivially generalizes to more than two values, and allows more descriptive member names than `first`

and `second`

:

struct Variable { QString name; double value; }; Variable v; v.name = "pi"; v.value = M_PI;

The advent of C++11 automatic variable type deduction (`auto`

) shifts the emphasis from the type name to the name of functions and members. Thus, QPair, like `std::pair`

and `std::tuple`

, is mostly useful in generic (template) code, where defining a dedicated type is not possible.

QPair's template data types (T1 and T2) must be assignable data types. You cannot, for example, store a QWidget as a value; instead, store a QWidget *. A few functions have additional requirements; these requirements are documented on a per-function basis.

**See also **Container Classes.

## Member Type Documentation

### typedef QPair::first_type

The type of the first element in the pair (T1).

**See also **first.

### typedef QPair::second_type

The type of the second element in the pair (T2).

**See also **second.

## Member Function Documentation

### template <typename TT1, typename TT2> QPair::QPair(QPair<TT1, TT2> &&*p*)

Move-constructs a QPair instance, making it point to the same object that *p* was pointing to.

This function was introduced in Qt 5.2.

### template <typename TT1, typename TT2> QPair::QPair(const QPair<TT1, TT2> &*p*)

Constructs a pair from the other pair *p*, of types TT1 and TT2. This constructor will fail if `first`

cannot be initialized from `p.first`

or if `second`

cannot be initialized from `p.second`

.

This function was introduced in Qt 5.2.

**See also **qMakePair().

### QPair::QPair(const T1 &*value1*, const T2 &*value2*)

Constructs a pair and initializes the `first`

element with *value1* and the `second`

element with *value2*.

**See also **qMakePair().

### QPair::QPair()

Constructs an empty pair. The `first`

and `second`

elements are initialized with default-constructed values.

### void QPair::swap(QPair<T1, T2> &*other*)

Swaps this pair with *other*.

Equivalent to

qSwap(this->first, other.first); qSwap(this->second, other.second);

Swap overloads are found in namespace `std`

as well as via argument-dependent lookup (ADL) in the namespace of `T`

.

This function was introduced in Qt 5.5.

### template <typename TT1, typename TT2> QPair<T1, T2> &QPair::operator=(const QPair<TT1, TT2> &*p*)

Copies pair *p* into this pair.

This function was introduced in Qt 5.2.

**See also **qMakePair().

### template <typename TT1, typename TT2> QPair<T1, T2> &QPair::operator=(QPair<TT1, TT2> &&*p*)

Move-assigns pair *p* into this pair instance.

This function was introduced in Qt 5.2.

## Member Variable Documentation

### T1 QPair::first

The first element in the pair.

### T2 QPair::second

The second element in the pair.

## Related Non-Members

### template <typename T1, typename T2> QPair<T1, T2> qMakePair(const T1 &*value1*, const T2 &*value2*)

Returns a QPair<T1, T2> that contains *value1* and *value2*. Example:

QList<QPair<int, double> > list; list.append(qMakePair(66, M_PI));

This is equivalent to QPair<T1, T2>(*value1*, *value2*), but usually requires less typing.

### template <typename T1, typename T2> void swap(QPair<T1, T2> &*lhs*, QPair<T1, T2> &*rhs*)

This is an overloaded function.

Swaps *lhs* with *rhs*.

This function was introduced in Qt 5.5.

### template <typename T1, typename T2> bool operator!=(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is not equal to *p2*; otherwise returns false. Two pairs compare as not equal if their `first`

data members are not equal or if their `second`

data members are not equal.

This function requires the T1 and T2 types to have an implementation of `operator==()`

.

### template <typename T1, typename T2> bool operator<(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is less than *p2*; otherwise returns false. The comparison is done on the `first`

members of *p1* and *p2*; if they compare equal, the `second`

members are compared to break the tie.

This function requires the T1 and T2 types to have an implementation of `operator<()`

.

### template <typename T1, typename T2> QDataStream &operator<<(QDataStream &*out*, const QPair<T1, T2> &*pair*)

Writes the pair *pair* to stream *out*.

This function requires the T1 and T2 types to implement `operator<<()`

.

**See also **Serializing Qt Data Types.

### template <typename T1, typename T2> bool operator<=(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is less than or equal to *p2*; otherwise returns `false`

. The comparison is done on the `first`

members of *p1* and *p2*; if they compare equal, the `second`

members are compared to break the tie.

This function requires the T1 and T2 types to have an implementation of `operator<()`

.

### template <typename T1, typename T2> bool operator==(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is equal to *p2*; otherwise returns `false`

. Two pairs compare equal if their `first`

data members compare equal and if their `second`

data members compare equal.

This function requires the T1 and T2 types to have an implementation of `operator==()`

.

### template <typename T1, typename T2> bool operator>(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is greater than *p2*; otherwise returns false. The comparison is done on the `first`

members of *p1* and *p2*; if they compare equal, the `second`

members are compared to break the tie.

This function requires the T1 and T2 types to have an implementation of `operator<()`

.

### template <typename T1, typename T2> bool operator>=(const QPair<T1, T2> &*p1*, const QPair<T1, T2> &*p2*)

Returns `true`

if *p1* is greater than or equal to *p2*; otherwise returns `false`

. The comparison is done on the `first`

members of *p1* and *p2*; if they compare equal, the `second`

members are compared to break the tie.

This function requires the T1 and T2 types to have an implementation of `operator<()`

.

### template <typename T1, typename T2> QDataStream &operator>>(QDataStream &*in*, QPair<T1, T2> &*pair*)

Reads a pair from stream *in* into *pair*.

This function requires the T1 and T2 types to implement `operator>>()`

.

**See also **Serializing Qt Data Types.