The QPair class is a template class that stores a pair of items. More...

` #include <QPair>`

typedef | first_type |

typedef | second_type |

QPair () | |

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

QPair<T1, T2> & | operator= ( const QPair<T1, T2> & other ) |

T1 | first |

T2 | second |

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

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 ) |

The QPair class is a template class that stores a pair of items.

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 = 3.14159265358979323846;

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.

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

**See also **first.

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

**See also **second.

Constructs an empty pair. The `first` and `second` elements are initialized with default-constructed values.

Constructs a pair and initializes the `first` element with *value1* and the `second` element with *value2*.

**See also **qMakePair().

Assigns *other* to this pair.

The first element in the pair.

The second element in the pair.

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

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

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

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==()`.

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<()`.

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

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

**See also **Serializing Qt Data Types.

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<()`.

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==()`.

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<()`.

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<()`.

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.