- Qt 5.15
- Qt Core
- C++ Classes
- QPair
- Qt 5.15.19 Reference Documentation

# QPair Struct

template <typename T1, typename T2> struct QPair

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

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

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

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.