Qt 5.6 | Qt Core | C++ Classes | QPair

Qt 5.6.2 Reference Documentation

# QPair Class

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

Header: | #include <QPair>
qmake: | QT += core

- List of all members, including inherited members

## Public Types

typedef | first_type
typedef | second_type

## Public Functions

| QPair()
| QPair(const T1 &value1, const T2 &value2)
| QPair(const QPair<TT1, TT2> &p)
| QPair(QPair<TT1, TT2> &&p)
void | swap(QPair &other)
QPair & | operator=(const QPair<TT1, TT2> &p)
QPair & | operator=(QPair<TT1, TT2> &&p)

## Public Variables

T1 | first
T2 | second

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

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.

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

### QPair::QPair()

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

### 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(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(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.

### void QPair::swap(QPair &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.

### QPair &QPair::operator=(const QPair<TT1, TT2> &p)

Copies pair p into this pair.

This function was introduced in Qt 5.2.

See also qMakePair().

### QPair &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

### 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, 3.14159));

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

### 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.

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

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

### 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.

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

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

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

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

### 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.