En esta página

QSizePolicy Class

La clase `QSizePolicy` es un atributo de diseño que describe la política de redimensionamiento horizontal y vertical. Más información...

Encabezado: #include <QSizePolicy>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets

Tipos públicos

enum ControlType { DefaultType, ButtonBox, CheckBox, ComboBox, Frame, …, ToolButton }
flags ControlTypes
enum Policy { Fixed, Minimum, Maximum, Preferred, Expanding, …, Ignored }
enum PolicyFlag { GrowFlag, ExpandFlag, ShrinkFlag, IgnoreFlag }

Funciones públicas

QSizePolicy()
QSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical, QSizePolicy::ControlType type = DefaultType)
QSizePolicy::ControlType controlType() const
Qt::Orientations expandingDirections() const
bool hasHeightForWidth() const
bool hasWidthForHeight() const
QSizePolicy::Policy horizontalPolicy() const
int horizontalStretch() const
bool retainSizeWhenHidden() const
void setControlType(QSizePolicy::ControlType type)
void setHeightForWidth(bool dependent)
void setHorizontalPolicy(QSizePolicy::Policy policy)
void setHorizontalStretch(int stretchFactor)
void setRetainSizeWhenHidden(bool retainSize)
void setVerticalPolicy(QSizePolicy::Policy policy)
void setVerticalStretch(int stretchFactor)
void setWidthForHeight(bool dependent)
void transpose()
QSizePolicy transposed() const
QSizePolicy::Policy verticalPolicy() const
int verticalStretch() const
operator QVariant() const
bool operator!=(const QSizePolicy &other) const
bool operator==(const QSizePolicy &other) const
size_t qHash(QSizePolicy key, size_t seed = 0)
QDataStream &operator<<(QDataStream &stream, const QSizePolicy &policy)
QDataStream &operator>>(QDataStream &stream, QSizePolicy &policy)

Descripción detallada

La política de tamaño de un widget es una expresión de su disposición a ser redimensionado de diversas formas, y afecta a cómo el motor de diseño trata dicho widget. Cada widget devuelve un QSizePolicy que describe la política de redimensionamiento horizontal y vertical que prefiere al ser dispuesto en el diseño. Se puede modificar esto para un widget específico cambiando su propiedad QWidget::sizePolicy.

QSizePolicy contiene dos valores independientes de « QSizePolicy::Policy » y dos factores de estiramiento; uno describe la política de tamaño horizontal del widget y el otro, su política de tamaño vertical. También contiene un indicador que señala si la altura y la anchura de su tamaño preferido están relacionadas.

Las políticas horizontal y vertical pueden establecerse en el constructor y modificarse mediante las funciones ` setHorizontalPolicy()` y ` setVerticalPolicy()`. Los factores de estiramiento se pueden establecer mediante las funciones ` setHorizontalStretch()` y ` setVerticalStretch()`. El indicador que señala si el ` sizeHint()` del widget depende del ancho (como una barra de menú o una etiqueta con ajuste de línea) se puede establecer mediante la función ` setHeightForWidth()`.

Las políticas de tamaño y los factores de estiramiento actuales se pueden recuperar mediante las funciones horizontalPolicy(), verticalPolicy(), horizontalStretch() y verticalStretch(). Como alternativa, utilice la función transpose() para intercambiar las políticas y los factores de estiramiento horizontales y verticales. La función hasHeightForWidth() devuelve el estado actual del indicador que señala las dependencias de las sugerencias de tamaño.

Utilice la función ` expandingDirections()` para determinar si el widget asociado puede utilizar más espacio del que indica su función ` sizeHint()`, así como para averiguar en qué direcciones puede expandirse.

Por último, la clase `QSizePolicy` proporciona operadores que comparan esta política de tamaño con una política dada, así como un operador ` QVariant ` que almacena esta `QSizePolicy` como un objeto ` QVariant `.

Véase también QSize, QWidget::sizeHint(), QWidget::sizePolicy y QLayoutItem::sizeHint().

Documentación sobre tipos de miembros

enum QSizePolicy::ControlType
flags QSizePolicy::ControlTypes

Esta enumeración especifica los diferentes tipos de widgets en cuanto a su interacción con el diseño:

ConstanteValorDescripción
QSizePolicy::DefaultType0x00000001El tipo predeterminado, cuando no se especifica ninguno.
QSizePolicy::ButtonBox0x00000002Una instancia de ` QDialogButtonBox `.
QSizePolicy::CheckBox0x00000004Una instancia de ` QCheckBox `.
QSizePolicy::ComboBox0x00000008Una instancia de ` QComboBox `.
QSizePolicy::Frame0x00000010Una instancia de ` QFrame `.
QSizePolicy::GroupBox0x00000020Una instancia de ` QGroupBox `.
QSizePolicy::Label0x00000040Una instancia de « QLabel ».
QSizePolicy::Line0x00000080Una instancia de « QFrame » con QFrame::HLine o QFrame::VLine.
QSizePolicy::LineEdit0x00000100Una instancia de QLineEdit.
QSizePolicy::PushButton0x00000200Una instancia de QPushButton.
QSizePolicy::RadioButton0x00000400Una instancia de QRadioButton.
QSizePolicy::Slider0x00000800Una instancia de QAbstractSlider.
QSizePolicy::SpinBox0x00001000Una instancia de QAbstractSpinBox.
QSizePolicy::TabWidget0x00002000Una instancia de « QTabWidget ».
QSizePolicy::ToolButton0x00004000Una instancia de ` QToolButton `.

El tipo ControlTypes es una definición de tipo (typedef) para QFlags<ControlType>. Almacena una combinación OR de valores de ControlType.

Véase también setControlType() y controlType().

enum QSizePolicy::Policy

Esta enumeración describe los distintos tipos de dimensionamiento por dimensión que se utilizan al crear un ` QSizePolicy`.

ConstanteValorDescripción
QSizePolicy::Fixed0El QWidget::sizeHint() es la única alternativa aceptable, por lo que el widget nunca puede agrandarse ni reducirse (por ejemplo, la dirección vertical de un botón).
QSizePolicy::MinimumGrowFlagEl tamaño indicado por sizeHint() es mínimo y suficiente. El widget puede ampliarse, pero no supone ninguna ventaja que sea más grande (p. ej., la dirección horizontal de un botón). No puede ser más pequeño que el tamaño indicado por sizeHint().
QSizePolicy::MaximumShrinkFlagEl valor de `sizeHint()` es un máximo. El widget puede reducirse tanto como sea necesario sin que ello suponga un inconveniente si otros widgets necesitan el espacio (por ejemplo, una línea separadora). No puede ser mayor que el tamaño proporcionado por `sizeHint()`.
QSizePolicy::PreferredGrowFlag | ShrinkFlagEl valor de `sizeHint()` es el óptimo, pero el widget puede reducirse y seguir siendo útil. El widget puede ampliarse, pero no supone ninguna ventaja que sea mayor que el valor de `sizeHint()` (la política predeterminada de « QWidget »).
QSizePolicy::ExpandingGrowFlag | ShrinkFlag | ExpandFlagEl valor de sizeHint() es un tamaño razonable, pero el widget puede reducirse y seguir siendo útil. El widget puede aprovechar el espacio adicional, por lo que debería ocupar todo el espacio posible (por ejemplo, la dirección horizontal de un control deslizante horizontal).
QSizePolicy::MinimumExpandingGrowFlag | ExpandFlagEl valor de sizeHint() es mínimo y suficiente. El widget puede aprovechar el espacio adicional, por lo que debería ocupar todo el espacio posible (por ejemplo, en la dirección horizontal de un control deslizante horizontal).
QSizePolicy::IgnoredShrinkFlag | GrowFlag | IgnoreFlagSe ignora el valor de sizeHint(). El widget obtendrá todo el espacio posible.

Véase también PolicyFlag, setHorizontalPolicy() y setVerticalPolicy().

enum QSizePolicy::PolicyFlag

Estas opciones se combinan entre sí para formar los distintos valores de « Policy »:

ConstanteValorDescripción
QSizePolicy::GrowFlag1El widget puede superar su tamaño sugerido si es necesario.
QSizePolicy::ExpandFlag2El widget debe ocupar todo el espacio posible.
QSizePolicy::ShrinkFlag4El widget puede reducirse por debajo de su indicación de tamaño si es necesario.
QSizePolicy::IgnoreFlag8Se ignora la indicación de tamaño del widget. El widget ocupará todo el espacio posible.

Véase también Policy.

Documentación de funciones de miembro

[constexpr noexcept] QSizePolicy::QSizePolicy()

Crea un objeto QSizePolicy con « Fixed » como políticas horizontal y vertical.

Las políticas se pueden modificar mediante las funciones ` setHorizontalPolicy()` y ` setVerticalPolicy()`. Utiliza la función ` setHeightForWidth()` si la altura preferida del widget depende de su anchura (por ejemplo, un ` QLabel ` con ajuste de línea).

Véanse también setHorizontalStretch() y setVerticalStretch().

[constexpr noexcept] QSizePolicy::QSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical, QSizePolicy::ControlType type = DefaultType)

Crea un objeto `QSizePolicy` con las políticas ` horizontal ` y ` vertical ` indicadas, y el control especificado ` type`.

Utiliza ` setHeightForWidth()` si la altura preferida del widget depende de su anchura (por ejemplo, un ` QLabel ` con ajuste de línea).

Véase también setHorizontalStretch(), setVerticalStretch() y controlType().

[noexcept] QSizePolicy::ControlType QSizePolicy::controlType() const

Devuelve el tipo de control asociado al widget al que se aplica esta política de tamaño.

Véase también setControlType().

[constexpr noexcept] Qt::Orientations QSizePolicy::expandingDirections() const

Devuelve si un widget puede utilizar más espacio del que indica la función ` QWidget::sizeHint()`.

Un valor de Qt::Horizontal o Qt::Vertical significa que el widget puede expandirse horizontal o verticalmente (es decir, la política horizontal o vertical es Expanding o MinimumExpanding), mientras que Qt::Horizontal | Qt::Vertical significa que puede expandirse en ambas dimensiones.

Véase también horizontalPolicy() y verticalPolicy().

[constexpr noexcept] bool QSizePolicy::hasHeightForWidth() const

Devuelve « true » si la altura preferida del widget depende de su anchura; en caso contrario, devuelve « false ».

Véase también setHeightForWidth().

[constexpr noexcept] bool QSizePolicy::hasWidthForHeight() const

Devuelve ` true ` si el ancho del widget depende de su altura; en caso contrario, devuelve ` false`.

Véase también setWidthForHeight().

[constexpr noexcept] QSizePolicy::Policy QSizePolicy::horizontalPolicy() const

Devuelve la componente horizontal de la política de tamaño.

Véase también setHorizontalPolicy(), verticalPolicy() y horizontalStretch().

[constexpr noexcept] int QSizePolicy::horizontalStretch() const

Devuelve el factor de estiramiento horizontal de la política de tamaño.

Véase también setHorizontalStretch(), verticalStretch() y horizontalPolicy().

[constexpr noexcept] bool QSizePolicy::retainSizeWhenHidden() const

Devuelve si el diseño debe conservar el tamaño del widget cuando está oculto. El valor predeterminado es ` false `.

Véase también setRetainSizeWhenHidden().

[noexcept] void QSizePolicy::setControlType(QSizePolicy::ControlType type)

Establece el tipo de control asociado al widget al que se aplica esta política de tamaño en type.

El tipo de control especifica el tipo de widget al que se aplica esta política de tamaño. Lo utilizan algunos estilos, en particular QMacStyle, para insertar el espaciado adecuado entre widgets. Por ejemplo, las directrices de Aqua de macOS especifican que los botones deben estar separados por 12 píxeles, mientras que los botones de opción apilados verticalmente solo requieren 6 píxeles.

Véase también controlType() y QStyle::layoutSpacing().

[constexpr noexcept] void QSizePolicy::setHeightForWidth(bool dependent)

Establece el indicador que determina si la altura preferida del widget depende de su anchura, en « dependent ».

Véase también hasHeightForWidth() y setWidthForHeight().

[constexpr noexcept] void QSizePolicy::setHorizontalPolicy(QSizePolicy::Policy policy)

Establece la componente horizontal en el valor indicado policy.

Véase también horizontalPolicy(), setVerticalPolicy() y setHorizontalStretch().

[constexpr] void QSizePolicy::setHorizontalStretch(int stretchFactor)

Establece el factor de estiramiento horizontal de la política de tamaño en el valor dado stretchFactor. stretchFactor debe estar comprendido en el intervalo [0,255].

Cuando dos widgets están adyacentes entre sí en un diseño horizontal, establecer el factor de estiramiento horizontal del widget de la izquierda en 2 y el del widget de la derecha en 1 garantizará que el widget de la izquierda tenga siempre el doble de tamaño que el de la derecha.

Véase también horizontalStretch(), setVerticalStretch() y setHorizontalPolicy().

[constexpr noexcept] void QSizePolicy::setRetainSizeWhenHidden(bool retainSize)

Establece si un diseño debe conservar el tamaño del widget cuando este se oculta. Si el valor de « retainSize » es « true », el diseño no se verá afectado al ocultar el widget.

Véase también ` retainSizeWhenHidden()`.

[constexpr noexcept] void QSizePolicy::setVerticalPolicy(QSizePolicy::Policy policy)

Establece la componente vertical en el valor dado policy.

Véase también verticalPolicy(), setHorizontalPolicy() y setVerticalStretch().

[constexpr] void QSizePolicy::setVerticalStretch(int stretchFactor)

Establece el factor de estiramiento vertical de la política de tamaño en el valor dado stretchFactor. stretchFactor debe estar comprendido en el intervalo [0,255].

Cuando dos widgets están adyacentes entre sí en un diseño vertical, establecer el factor de estiramiento vertical del widget superior en 2 y el del widget inferior en 1 garantizará que el widget superior tenga siempre el doble de tamaño que el inferior.

Véase también verticalStretch(), setHorizontalStretch() y setVerticalPolicy().

[constexpr noexcept] void QSizePolicy::setWidthForHeight(bool dependent)

Establece el indicador que determina si el ancho del widget depende de su altura en « dependent ».

Esto solo es compatible con las subclases de ` QGraphicsLayout`. No es posible tener un diseño con restricciones de «altura por ancho» y «ancho por altura» al mismo tiempo.

Véase también ` hasWidthForHeight()` y ` setHeightForWidth()`.

[constexpr noexcept] void QSizePolicy::transpose()

Intercambia las políticas horizontales y verticales y las estira.

Véase también transposed().

[constexpr noexcept] QSizePolicy QSizePolicy::transposed() const

Devuelve un objeto de política de tamaño en el que se han intercambiado las políticas horizontal y vertical y los estiramientos.

Véase también transpose().

[constexpr noexcept] QSizePolicy::Policy QSizePolicy::verticalPolicy() const

Devuelve la componente vertical de la política de tamaño.

Véase también setVerticalPolicy(), horizontalPolicy() y verticalStretch().

[constexpr noexcept] int QSizePolicy::verticalStretch() const

Devuelve el factor de estiramiento vertical de la política de tamaño.

Véase también setVerticalStretch(), horizontalStretch() y verticalPolicy().

QSizePolicy::operator QVariant() const

Devuelve un objeto ` QVariant ` que almacena este ` QSizePolicy`.

[constexpr noexcept] bool QSizePolicy::operator!=(const QSizePolicy &other) const

Devuelve ` true ` si esta política es diferente de ` other`; en caso contrario, devuelve ` false`.

Véase también operator==().

[constexpr noexcept] bool QSizePolicy::operator==(const QSizePolicy &other) const

Devuelve « true » si esta política es igual a « other »; en caso contrario, devuelve « false ».

Véase también operator!=().

Elementos no miembros relacionados

[noexcept] size_t qHash(QSizePolicy key, size_t seed = 0)

Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.

QDataStream &operator<<(QDataStream &stream, const QSizePolicy &policy)

Escribe el tamaño policy en el flujo de datos stream.

Véase también Formato de los operadores de QDataStream.

QDataStream &operator>>(QDataStream &stream, QSizePolicy &policy)

Lee el tamaño policy del flujo de datos stream.

Véase también el formato de los operadores de QDataStream.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.