Clase `CRect`

Artículo
04/03/2023

Similar a una estructura RECT de Windows.

Sintaxis

class CRect : public tagRECT

Miembros

Constructores públicos

Nombre	Descripción
`CRect::CRect`	Construye un objeto `CRect`.

Métodos públicos

Nombre	Descripción
`CRect::BottomRight`	Devuelve el punto inferior derecho de `CRect`.
`CRect::CenterPoint`	Devuelve el punto central de `CRect`.
`CRect::CopyRect`	Copia las dimensiones de un rectángulo de origen en `CRect`.
`CRect::DeflateRect`	Disminuye el ancho y el alto de `CRect`.
`CRect::EqualRect`	Determina si `CRect` es igual al rectángulo especificado.
`CRect::Height`	Calcula el alto de `CRect`.
`CRect::InflateRect`	Aumenta el ancho y el alto de `CRect`.
`CRect::IntersectRect`	Establece `CRect` igual a la intersección de dos rectángulos.
`CRect::IsRectEmpty`	Determina si `CRect` está vacío. `CRect` está vacío si el ancho o alto son 0.
`CRect::IsRectNull`	Determina si las variables miembro `top`, `bottom`, `left` y `right` son iguales a 0.
`CRect::MoveToX`	Mueve `CRect` a la coordenada x especificada.
`CRect::MoveToXY`	Mueve `CRect` a las coordenadas x e y especificadas.
`CRect::MoveToY`	Mueve `CRect` a la coordenada y especificada.
`CRect::NormalizeRect`	Estandariza el alto y el ancho de `CRect`.
`CRect::OffsetRect`	Mueve `CRect` según los desplazamientos especificados.
`CRect::PtInRect`	Determina si el punto especificado se encuentra dentro de `CRect`.
`CRect::SetRect`	Establece las dimensiones de `CRect`.
`CRect::SetRectEmpty`	Establece `CRect` en un rectángulo vacío (todas las coordenadas iguales a 0).
`CRect::Size`	Calcula el tamaño de `CRect`.
`CRect::SubtractRect`	Resta un rectángulo de otro.
`CRect::TopLeft`	Devuelve el punto superior izquierdo de `CRect`.
`CRect::UnionRect`	Establece `CRect` igual a la unión de dos rectángulos.
`CRect::Width`	Calcula el ancho de `CRect`.

Operadores públicos

Nombre	Descripción
`CRect::operator -`	Resta los desplazamientos especificados de `CRect` o desinfla `CRect` y devuelve el objeto `CRect` resultante.
`CRect::operator LPCRECT`	Convierte `CRect` en `LPCRECT`.
`CRect::operator LPRECT`	Convierte `CRect` en `LPRECT`.
`CRect::operator !=`	Determina si `CRect` no es igual a un rectángulo.
`CRect::operator &`	Crea la intersección de `CRect` y un rectángulo y devuelve el objeto`CRect` resultante.
`CRect::operator &=`	Establece `CRect` igual a la intersección de `CRect` y un rectángulo.
`CRect::operator \|`	Crea la unión de `CRect` y un rectángulo y devuelve el objeto `CRect` resultante.
`CRect::operator \|=`	Establece `CRect` igual a la unión de `CRect` y un rectángulo.
`CRect::operator +`	Agrega los desplazamientos especificados a `CRect` o infla `CRect` y devuelve el objeto `CRect` resultante.
`CRect::operator +=`	Agrega los desplazamientos especificados a `CRect` o se infla `CRect`.
`CRect::operator =`	Copia las dimensiones de un rectángulo en `CRect`.
`CRect::operator -=`	Resta los desplazamientos especificados de `CRect` o se desinfla `CRect`.
`CRect::operator ==`	Determina si `CRect` es igual a un rectángulo.

Comentarios

CRect también incluye funciones miembro para manipular objetos CRect y estructuras RECT de Windows.

Un objeto CRect se puede pasar como un parámetro de función siempre que se pueda pasar una estructura RECT, LPCRECT o LPRECT.

Nota:

Esta clase se deriva de la estructura tagRECT. (El nombre tagRECT es un nombre que se usa con menos frecuencia para la estructuraRECT). Esto significa que los miembros de datos (left, top, right y bottom) de la estructura RECT son miembros de datos accesibles de CRect.

CRect contiene variables miembro que definen los puntos superior izquierdo e inferior derecho de un rectángulo.

Al especificar CRect, debe tener cuidado de construirlo de forma que se normalice, es decir, de modo que el valor de la coordenada izquierda sea menor que el de la derecha y la parte superior sea menor que la inferior. Por ejemplo, una parte superior izquierda de (10,10) y la parte inferior derecha de (20,20) define un rectángulo normalizado, pero una parte superior izquierda de (20,20) y la parte inferior derecha de (10,10) define un rectángulo no normalizado. Si el rectángulo no está normalizado, muchas funciones miembro CRect pueden devolver resultados incorrectos. (Consulte CRect::NormalizeRect para obtener una lista de estas funciones). Antes de llamar a una función que requiere rectángulos normalizados, puede normalizar los rectángulos no normalizados llamando a la función NormalizeRect.

Tenga cuidado al manipular CRect con las funciones miembro CDC::DPtoLP y CDC::LPtoDP. Si el modo de asignación de un contexto de presentación es tal que la extensión y es negativa, como en MM_LOENGLISH, CDC::DPtoLP transformará CRect para que su parte superior sea mayor que la parte inferior. Las funciones como Height y Size devolverán valores negativos para el alto del objeto CRecttransformado y el rectángulo no se normalizará.

Cuando se usan operadores CRect sobrecargados, el primer operando debe ser CRect; el segundo puede ser una estructura RECT o un objeto CRect.

Jerarquía de herencia

tagRECT

CRect

Requisitos

Encabezado: atltypes.h

`CRect::BottomRight`

Las coordenadas se devuelven como referencia a un objeto CPoint que se encuentra en CRect.

CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();

Valor devuelto

Coordenadas de la esquina inferior derecha del rectángulo.

Comentarios

Puede usar esta función para obtener o establecer la esquina inferior derecha del rectángulo. Establezca la esquina mediante esta función en el lado izquierdo del operador de asignación.

Ejemplo

// use BottomRight() to retrieve the bottom
// right POINT
CRect rect(210, 150, 350, 900);
CPoint ptDown;

ptDown = rect.BottomRight();

// ptDown is now set to (350, 900)
ASSERT(ptDown == CPoint(350, 900));

// or, use BottomRight() to set the bottom
// right POINT
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);

CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
rect2.BottomRight() = ptLow;

// rect2 is now (10, 10, 180, 180)
ASSERT(rect2 == CRect(10, 10, 180, 180));

`CRect::CenterPoint`

Calcula el punto central de CRect sumando los valores izquierdo y derecho y dividiendo entre dos, y haciendo lo mismo para los valores superior e inferior.

CPoint CenterPoint() const throw();

Valor devuelto

Un objeto CPoint que es el punto central de CRect.

Ejemplo

// Code from this OnPaint() implementation can be pasted into your own application
// to draw lines that would look like a letter "Y" within your dialog.
void CMyDlg::OnPaint()
{
    CPaintDC dc(this);

    // device context for painting

    // get the size and position of the client area of
    // your window

    CRect rect;
    GetClientRect(&rect);

    // Move the current pen to the top left of the window. We call the
    // TopLeft() member of CRect here and it returns a CPoint object we
    // pass to the override of CDC::MoveTo() that accepts a CPoint.

    dc.MoveTo(rect.TopLeft());

    // Draw a line from the top left to the center of the window.
    // CenterPoint() gives us the middle point of the window as a
    // CPoint, and since CDC::LineTo() has an override that accepts a
    // CPoint, we can just pass it along.

    dc.LineTo(rect.CenterPoint());

    // Now, draw a line to the top right of the window. There's no
    // CRect member which returns a CPoint for the top right of the
    // window, so we'll reference the CPoint members directly and call
    // the CDC::LineTo() override which takes two integers.

    dc.LineTo(rect.right, rect.top);

    // The top part of the "Y" is drawn. Now, we'll draw the stem. We
    // start from the center point.

    dc.MoveTo(rect.CenterPoint());

    // and then draw to the middle of the bottom edge of the window.
    // We'll get the x-coordinate from the x member of the CPOINT
    // returned by CenterPoint(), and the y value comes directly from
    // the rect.

    dc.LineTo(rect.CenterPoint().x, rect.bottom);
}

`CRect::CopyRect`

Copia el rectángulo lpSrcRect en CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parámetros

lpSrcRect
Apunta a la estructura RECT o al objeto CRect que se va a copiar.

Ejemplo

CRect rectSource(35, 10, 125, 10);
CRect rectDest;

rectDest.CopyRect(&rectSource);

// rectDest is now set to (35, 10, 125, 10)

RECT rectSource2;
rectSource2.left = 0;
rectSource2.top = 0;
rectSource2.bottom = 480;
rectSource2.right = 640;

rectDest.CopyRect(&rectSource2);

// works against RECT structures, too!
// rectDest is now set to (0, 0, 640, 480)

`CRect::CRect`

Construye un objeto CRect.

CRect() throw();
CRect(int l, int t, int r, int b) throw();
CRect(const RECT& srcRect) throw();
CRect(LPCRECT lpSrcRect) throw();
CRect(POINT point, SIZE size) throw();
CRect(POINT topLeft, POINT bottomRight) throw();

Parámetros

l
Especifica la posición izquierda de CRect.

t
Especifica la parte superior de CRect.

r
Especifica la posición derecha de CRect.

b
Especifica la parte inferior de CRect.

srcRect
Hace referencia a la estructura RECT con las coordenadas para CRect.

lpSrcRect
Apunta a la estructura RECT con las coordenadas para CRect.

point
Especifica el punto de origen del rectángulo que se va a construir. Corresponde a la esquina superior izquierda.

size
Especifica el desplazamiento desde la esquina superior izquierda hasta la esquina inferior derecha del rectángulo que se va a construir.

topLeft
Especifica la posición superior izquierda de CRect.

bottomRight
Especifica la posición inferior derecha de CRect.

Comentarios

Si no se proporcionan argumentos, los miembros left, top, right y bottom se establecen en 0.

Los constructores CRect(const RECT&) y CRect(LPCRECT) realizan CopyRect. Los demás constructores inicializan las variables miembro del objeto directamente.

Ejemplo

// default constructor is equivalent to CRect(0, 0, 0, 0)
CRect emptyRect;

// four-integers are left, top, right, and bottom
CRect rect(0, 0, 100, 50);
ASSERT(rect.Width() == 100);
ASSERT(rect.Height() == 50);

// Initialize from RECT structure
RECT sdkRect;
sdkRect.left = 0;
sdkRect.top = 0;
sdkRect.right = 100;
sdkRect.bottom = 50;

CRect rect2(sdkRect);
// by reference
CRect rect3(&sdkRect);

// by address
ASSERT(rect2 == rect);
ASSERT(rect3 == rect);

// from a point and a size
CPoint pt(0, 0);
CSize sz(100, 50);
CRect rect4(pt, sz);
ASSERT(rect4 == rect2);

// from two points
CPoint ptBottomRight(100, 50);
CRect rect5(pt, ptBottomRight);
ASSERT(rect5 == rect4);

`CRect::DeflateRect`

DeflateRect desinfla CRect al mover los lados hacia su centro.

void DeflateRect(int x, int y) throw();
void DeflateRect(SIZE size) throw();
void DeflateRect(LPCRECT lpRect) throw();
void DeflateRect(int l, int t, int r, int b) throw();

Parámetros

x
Especifica el número de unidades que se desinflan en los lados izquierdo y derecho de CRect.

y
Especifica el número de unidades que se desinflan en la parte superior e inferior de CRect.

size
Un valor SIZE o CSize que especifica el número de unidades que se desinflan en CRect. El valor cx especifica el número de unidades que se desinflan en los lados izquierdo y derecho, y el valor cy especifica el número de unidades que se desinflan en las partes superior e inferior.

lpRect
Apunta a una estructura RECT o CRect que especifica el número de unidades que se desinflan en cada lado.

l
Especifica el número de unidades que se desinflan en el lado izquierdo de CRect.

t
Especifica el número de unidades que se desinflan en la parte superior de CRect.

r
Especifica el número de unidades que se desinflan en el lado derecho de CRect.

b
Especifica el número de unidades que se desinflan en la parte inferior de CRect.

Comentarios

Para ello, DeflateRect agrega unidades a la izquierda y a la parte superior, y resta unidades de la derecha y de la parte inferior. Los parámetros de DeflateRect son valores con firma; los valores positivos desinflan CRect y los valores negativos lo inflan.

Las dos primeras sobrecargas desinflan ambos pares de lados opuestos de CRect de modo que su ancho total se reduce dos veces x (o cx) y su altura total se reduce dos veces y (o cy). Las otras dos sobrecargas desinflan cada lado de CRect independientemente de las demás.

Ejemplo

CRect rect(10, 10, 50, 50);
rect.DeflateRect(1, 2);
ASSERT(rect.left == 11 && rect.right == 49);
ASSERT(rect.top == 12 && rect.bottom == 48);

CRect rect2(10, 10, 50, 50);
CRect rectDeflate(1, 2, 3, 4);
rect2.DeflateRect(&rectDeflate);
ASSERT(rect2.left == 11 && rect2.right == 47);
ASSERT(rect2.top == 12 && rect2.bottom == 46);

`CRect::EqualRect`

Determina si CRect es igual al rectángulo especificado.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parámetros

lpRect
Apunta a una estructura RECT o un objeto CRect que contiene las coordenadas de esquina superior izquierda e inferior derecha de un rectángulo.

Valor devuelto

Distinto de cero si los dos rectángulos tienen los mismos valores superior, izquierdo, inferior y derecho; de lo contrario, 0.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1.EqualRect(rect2));
ASSERT(!rect1.EqualRect(rect3));
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect1.EqualRect(&test));

`CRect::Height`

Calcula el alto de CRect restando el valor superior del valor inferior.

int Height() const throw();

Valor devuelto

Alto de CRect.

Comentarios

El valor resultante puede ser negativo.

Nota:

El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar el rectángulo antes de llamar a esta función.

Ejemplo

CRect rect(20, 30, 80, 70);
int nHt = rect.Height();

// nHt is now 40
ASSERT(nHt == 40);

`CRect::InflateRect`

InflateRect infla CRect al mover los lados fuera de su centro.

void InflateRect(int x, int y) throw();
void InflateRect(SIZE size) throw();
void InflateRect(LPCRECT lpRect) throw();
void InflateRect(int l, int t, int r,  int b) throw();

Parámetros

x
Especifica el número de unidades que se inflan en los lados izquierdo y derecho de CRect.

y
Especifica el número de unidades que se inflan en la parte superior e inferior de CRect.

size
Un valor SIZE o CSize que especifica el número de unidades que se inflan en CRect. El valor cx especifica el número de unidades que se inflan en los lados izquierdo y derecho y el valor cy especifica el número de unidades que se inflan en las partes superior e inferior.

lpRect
Apunta a una estructura RECT o CRect que especifica el número de unidades que se inflan cada lado.

l
Especifica el número de unidades que se inflan en el lado izquierdo de CRect.

t
Especifica el número de unidades que se inflan en la parte superior de CRect.

r
Especifica el número de unidades que se inflan en el lado derecho de CRect.

b
Especifica el número de unidades que se inflan en la parte inferior de CRect.

Comentarios

Para ello, InflateRect resta unidades de la izquierda y de la parte superior y agrega unidades a la derecha y a la parte inferior. Los parámetros de InflateRect son valores con firma; los valores positivos inflan CRect y los valores negativos lo desinflan.

Las dos primeras sobrecargas inflan ambos pares de lados opuestos de CRect para que su ancho total se incremente dos veces x (o cx) y su altura total se incremente dos veces y (o cy). Las otras dos sobrecargas inflan cada lado de CRect independientemente de las demás.

Ejemplo

CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);

// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));

`CRect::IntersectRect`

Hace que CRect sea igual a la intersección de dos rectángulos existentes.

BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parámetros

lpRect1
Apunta a una estructura RECT o un objeto CRect que contiene un rectángulo de origen.

lpRect2
Apunta a una estructura RECT o un objeto CRect que contiene un rectángulo de origen.

Valor devuelto

Distinto de cero si la intersección no está vacía; 0 si la intersección está vacía.

Comentarios

La intersección es el rectángulo más grande contenido en los dos rectángulos existentes.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect rectOne(125,  0, 150, 200);
CRect rectTwo(0, 75, 350, 95);
CRect rectInter;

rectInter.IntersectRect(rectOne, rectTwo);
ASSERT(rectInter == CRect(125, 75, 150, 95));
// operator &= can do the same task:

CRect rectInter2 = rectOne;
rectInter2 &= rectTwo;
ASSERT(rectInter2 == CRect(125, 75, 150, 95));

`CRect::IsRectEmpty`

Determina si CRect está vacío.

BOOL IsRectEmpty() const throw();

Valor devuelto

Distinto de cero si CRect está vacío; 0 si CRect no está vacío.

Comentarios

Un rectángulo está vacío si el ancho o alto son 0 o negativos. Difiere de IsRectNull, que determina si todas las coordenadas del rectángulo son cero.

Nota:

El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar el rectángulo antes de llamar a esta función.

Ejemplo

CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectEmpty());
ASSERT(!rectSome.IsRectEmpty());
CRect rectEmpty(35, 35, 35, 35);
ASSERT(rectEmpty.IsRectEmpty());

`CRect::IsRectNull`

Determina si los valores superior, izquierdo, inferior y derecho de CRect son iguales a 0.

BOOL IsRectNull() const throw();

Valor devuelto

Distinto de cero si los valores superior, izquierdo, inferior y derecho de CRect son iguales a 0; de lo contrario, 0.

Comentarios

Difiere de IsRectEmpty, que determina si el rectángulo está vacío.

Ejemplo

CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectNull());
ASSERT(!rectSome.IsRectNull());
// note that null means _all_ zeros

CRect rectNotNull(0, 0, 35, 50);
ASSERT(!rectNotNull.IsRectNull());

`CRect::MoveToX`

Llame a esta función para mover el rectángulo a la coordenada x absoluta especificada por x.

void MoveToX(int x) throw();

Parámetros

x
Coordenada x absoluta para la esquina superior izquierda del rectángulo.

Ejemplo

CRect rect(0, 0, 100, 100);
rect.MoveToX(10);

// rect is now (10, 0, 110, 100);
ASSERT(rect == CRect(10, 0, 110, 100));

`CRect::MoveToXY`

Llame a esta función para mover el rectángulo a las coordenadas x e y absolutas especificadas.

void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();

Parámetros

x
Coordenada x absoluta para la esquina superior izquierda del rectángulo.

y
Coordenada y absoluta para la esquina superior izquierda del rectángulo.

point
Una estructura POINT que especifica la esquina superior izquierda absoluta del rectángulo.

Ejemplo

CRect rect(0, 0, 100, 100);
rect.MoveToXY(10, 10);
// rect is now (10, 10, 110, 110);
ASSERT(rect == CRect(10, 10, 110, 110));

`CRect::MoveToY`

Llame a esta función para mover el rectángulo a la coordenada y absoluta especificada por y.

void MoveToY(int y) throw();

Parámetros

y
Coordenada y absoluta para la esquina superior izquierda del rectángulo.

Ejemplo

CRect rect(0, 0, 100, 100);
rect.MoveToY(10);
// rect is now (0, 10, 100, 110);
ASSERT(rect == CRect(0, 10, 100, 110));

`CRect::NormalizeRect`

Normaliza CRect para que tanto el alto como el ancho sean positivos.

void NormalizeRect() throw();

Comentarios

El rectángulo se normaliza para el posicionamiento del cuarto cuadrante, que Windows suele usar para las coordenadas. NormalizeRect compara los valores superior e inferior y los intercambia si la parte superior es mayor que la parte inferior. De forma similar, intercambia los valores izquierdo y derecho si la izquierda es mayor que la derecha. Esta función es útil cuando se trabaja con diferentes modos de asignación y rectángulos invertidos.

Nota:

Las siguientes funciones miembro CRect requieren rectángulos normalizados para funcionar de forma correcta: Height, Width, Size, IsRectEmpty, PtInRect, EqualRect, UnionRect, IntersectRect, SubtractRect, operator ==, operator !=, operator |, operator |=, operator & y operator &=.

Ejemplo

CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);

`CRect::OffsetRect`

Mueve CRect según los desplazamientos especificados.

void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();

Parámetros

x
Especifica cuánto se moverá a la izquierda o a la derecha. Debe ser negativo moverse a la izquierda.

y
Especifica cuánto se moverá hacia arriba o hacia abajo. Debe ser negativo para moverse hacia arriba.

point
Contiene una estructura POINT o un objeto CPoint que especifica las dos dimensiones por las que se va a mover.

size
Contiene una estructura SIZE o un objeto CSize que especifica las dos dimensiones por las que se va a mover.

Comentarios

Mueve unidades CRectx a lo largo del eje X y unidades y a lo largo del eje Y. Los parámetros x y y son valores con firma, por lo CRect se puede mover a la izquierda o a la derecha y hacia arriba o hacia abajo.

Ejemplo

CRect rect(0, 0, 35, 35);
rect.OffsetRect(230, 230);

// rect is now (230, 230, 265, 265)
ASSERT(rect == CRect(230, 230, 265, 265));

`CRect::operator LPCRECT` convierte `CRect` en `LPCRECT`.

operator LPCRECT() const throw();

Comentarios

Cuando se usa esta función, no se necesita el operador address-of (&). Este operador se usará de forma automática al pasar un objeto CRect a una función que espera LPCRECT.

`CRect::operator LPRECT`

Convierte CRect en LPRECT.

operator LPRECT() throw();

Comentarios

Cuando se usa esta función, no se necesita el operador address-of (&). Este operador se usará de forma automática al pasar un objeto CRect a una función que espera LPRECT.

Ejemplo

Vea el ejemplo de CRect::operator LPCRECT.

`CRect::operator =`

Asigna srcRect a CRect.

void operator=(const RECT& srcRect) throw();

Parámetros

srcRect
Hace referencia a un rectángulo de origen. Puede ser RECT o CRect.

Ejemplo

CRect rect(0, 0, 127, 168);
CRect rect2;

rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));

`CRect::operator ==`

Determina si rect es igual a CRect comparando las coordenadas de sus esquinas superior izquierda e inferior derecha.

BOOL operator==(const RECT& rect) const throw();

Parámetros

rect
Hace referencia a un rectángulo de origen. Puede ser RECT o CRect.

Valor devuelto

Distinto de cero si es igual; de lo contrario, 0.

Comentarios

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 == rect2);
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect1 == test);

`CRect::operator !=`

Determina si rect no es igual a CRect comparando las coordenadas de sus esquinas superior izquierda e inferior derecha.

BOOL operator!=(const RECT& rect) const throw();

Parámetros

rect
Hace referencia a un rectángulo de origen. Puede ser RECT o CRect.

Valor devuelto

Distinto de cero si no es igual; de lo contrario, 0.

Comentarios

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999,  6,  3);
ASSERT(rect1 != rect3);
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect3 != test);

`CRect::operator +=`

Las dos primeras sobrecargas mueven CRect mediante los desplazamientos especificados.

void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();

Parámetros

point
Una estructura POINT o un objeto CPoint que especifica el número de unidades que se va a mover el rectángulo.

size
Una estructura SIZE o un objeto CSize que especifica el número de unidades que se va a mover el rectángulo.

lpRect
Apunta a una estructura RECT o un objeto CRect que contiene el número de unidades que se inflan en cada lado de CRect.

Comentarios

Los valores x y y del parámetro (o cx y cy) se agregan a CRect.

La tercera sobrecarga infla CRect mediante el número de unidades especificadas en cada miembro del parámetro.

Ejemplo

CRect   rect1(100, 235, 200, 335);
CPoint  pt(35, 65);
CRect   rect2(135, 300, 235, 400);

rect1 += pt;
ASSERT(rect1 == rect2);

`CRect::operator -=`

Las dos primeras sobrecargas mueven CRect mediante los desplazamientos especificados.

void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();

Parámetros

point
Una estructura POINT o un objeto CPoint que especifica el número de unidades que se va a mover el rectángulo.

size
Una estructura SIZE o un objeto CSize que especifica el número de unidades que se va a mover el rectángulo.

lpRect
Apunta a una estructura RECT o un objeto CRect que contiene el número de unidades que se desinfla cada lado de CRect.

Comentarios

Los valores x y y del parámetro (o cx y cy) se restan de CRect.

La tercera sobrecarga desinfla CRect mediante el número de unidades especificadas en cada miembro del parámetro. Tenga en cuenta que esta sobrecarga funciona como DeflateRect.

Ejemplo

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);

rect1 -= pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);

`CRect::operator &=`

Establece CRect igual a la intersección de CRect y rect.

void operator&=(const RECT& rect) throw();

Parámetros

rect
Contiene RECT o CRect.

Comentarios

La intersección es el rectángulo más grande que se encuentra en ambos rectángulos.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

Vea el ejemplo de CRect::IntersectRect.

`CRect::operator |=`

Establece CRect igual a la unión de CRect y rect.

void operator|=(const RECT& rect) throw();

Parámetros

rect
Contiene CRect o RECT.

Comentarios

La unión es el rectángulo más pequeño que contiene ambos rectángulos de origen.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);

rect1 |= rect2;
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect1);

`CRect::operator +`

Las dos primeras sobrecargas devuelven un objeto CRect que es igual a CRect desplazados por los desplazamientos especificados.

CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();

Parámetros

point
Una estructura POINT o un objeto CPoint que especifica el número de unidades que se va a mover el valor devuelto.

size
Una estructura SIZE o un objeto CSize que especifica el número de unidades que se va a mover el valor devuelto.

lpRect
Apunta a una estructura RECT o un objeto CRect que contiene el número de unidades que se inflan en cada lado del valor devuelto.

Valor devuelto

El valor CRect resultante de mover o inflar CRect por el número de unidades especificadas en el parámetro.

Comentarios

Los parámetros x y y (o cx y cy) del parámetro se agregan a la posición de CRect.

La tercera sobrecarga devuelve un nuevo valor CRect que es igual a CRect inflado por el número de unidades especificadas en cada miembro del parámetro.

Ejemplo

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 + pt;
CRect   rectResult(135, 300, 235, 400);
ASSERT(rectResult == rect2);

`CRect::operator -`

Las dos primeras sobrecargas devuelven un objeto CRect que es igual a CRect desplazados por los desplazamientos especificados.

CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();

Parámetros

point
Una estructura POINT o un objeto CPoint que especifica el número de unidades que se va a mover el valor devuelto.

size
Una estructura SIZE o un objeto CSize que especifica el número de unidades que se va a mover el valor devuelto.

lpRect
Apunta a una estructura RECT o un objeto CRect que contiene el número de unidades que se desinflan en cada lado del valor devuelto.

Valor devuelto

El valor CRect resultante de mover o desinflar CRect por el número de unidades especificadas en el parámetro.

Comentarios

Los parámetros x y y (o cx y cy) del parámetro se restan de la posición de CRect.

La tercera sobrecarga devuelve un nuevo valor CRect que es igual a CRect desinflado por el número de unidades especificadas en cada miembro del parámetro. Tenga en cuenta que esta sobrecarga funciona como DeflateRect, no SubtractRect.

Ejemplo

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 - pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect2 == rectResult);

`CRect::operator &`

Devuelve CRect, que es la intersección de CRect y rect2.

CRect operator&(const RECT& rect2) const throw();

Parámetros

rect2
Contiene RECT o CRect.

Valor devuelto

Un valor CRect que es la intersección de CRect y rect2.

Comentarios

La intersección es el rectángulo más grande que se encuentra en ambos rectángulos.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3 = rect1 & rect2;
CRect   rectResult(100, 100, 200, 200);
ASSERT(rectResult == rect3);

`CRect::operator |`

Devuelve un valor CRect que es la unión de CRect y rect2.

CRect operator|(const RECT&
rect2) const throw();

Parámetros

rect2
Contiene RECT o CRect.

Valor devuelto

Un valor CRect que es la unión de CRect y rect2.

Comentarios

La unión es el rectángulo más pequeño que contiene ambos rectángulos.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3 = rect1 | rect2;
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);

`CRect::PtInRect`

Determina si el punto especificado se encuentra dentro de CRect.

BOOL PtInRect(POINT point) const throw();

Parámetros

point
Contiene una estructura POINT o un objeto CPoint.

Valor devuelto

Distinto de cero si el punto se encuentra dentro de CRect; de lo contrario, 0.

Comentarios

Un punto está dentro de CRect si se encuentra en el lado izquierdo o superior o en el interior de los cuatro lados. Un punto en el lado derecho o inferior está fuera de CRect.

Nota:

El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar el rectángulo antes de llamar a esta función.

Ejemplo

CRect rect(5, 5, 100, 100);
CPoint pt1(35, 50);
CPoint pt2(125, 298);

// this is true, because pt1 is inside the rectangle
ASSERT(rect.PtInRect(pt1));

// this is NOT true, because pt2 is outside the rectangle
ASSERT(!rect.PtInRect(pt2));

// note that the right and the bottom aren't inside
ASSERT(!rect.PtInRect(CPoint(35, 100)));
ASSERT(!rect.PtInRect(CPoint(100, 98)));

// but the top and the left are inside
ASSERT(rect.PtInRect(CPoint(5, 65)));
ASSERT(rect.PtInRect(CPoint(88, 5)));

// and that PtInRect() works against a POINT, too
POINT pt;
pt.x = 35;
pt.y = 50;
ASSERT(rect.PtInRect(pt));

`CRect::SetRect`

Establece las dimensiones de CRect en las coordenadas especificadas.

void SetRect(int x1, int y1, int x2, int y2) throw();

Parámetros

x1
Especifica la coordenada x de la esquina superior izquierda.

y1
Especifica la coordenada y de la esquina superior izquierda.

x2
Especifica la coordenada x de la esquina inferior derecha.

y2
Especifica la coordenada y de la esquina inferior derecha.

Ejemplo

CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));

`CRect::SetRectEmpty`

Convierte CRect en un rectángulo nulo al establecer todas las coordenadas en cero.

void SetRectEmpty() throw();

Ejemplo

CRect rect;
rect.SetRectEmpty();

// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());

`CRect::SIZE`

Los miembros cx y cy del valor devuelto contienen el alto y el ancho de CRect.

CSize Size() const throw();

Valor devuelto

Un objeto CSize que contiene el tamaño de CRect.

Comentarios

El alto o el ancho pueden ser negativos.

Nota:

El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar el rectángulo antes de llamar a esta función.

Ejemplo

CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);

`CRect::SubtractRect`

Hace las dimensiones de CRect iguales a la resta de lpRectSrc1 menos lpRectSrc2.

BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();

Parámetros

lpRectSrc1
Apunta a la estructura RECT o el objeto CRect del que se va a restar un rectángulo.

lpRectSrc2
Apunta a la estructura RECT o el objeto CRect que se va a restar del rectángulo al que apunta el parámetro lpRectSrc1.

Valor devuelto

Es distinto de cero si la función se realiza correctamente; de lo contrario, es 0.

Comentarios

La resta es el rectángulo más pequeño que contiene todos los puntos de lpRectScr1 que no están en la intersección de lpRectScr1 y lpRectScr2.

El rectángulo especificado por lpRectSrc1 no se modificará si el rectángulo especificado por lpRectSrc2 no se superpone completamente al rectángulo especificado por lpRectSrc1 en al menos una de las direcciones X o Y.

Por ejemplo, si lpRectSrc1 fuera (10,10, 100,100) y lpRectSrc2 fuera (50,50, 150,150), el rectángulo al que apunta lpRectSrc1 no se modificaría cuando se devolviera la función. Si lpRectSrc1 fuera (10,10, 100,100) y lpRectSrc2 (50,10, 150,150), sin embargo, el rectángulo al que apunta lpRectSrc1 contendría las coordenadas (10,10, 50,100) cuando se devolviera la función.

SubtractRect no es lo mismo que operador - ni que operador -=. Ninguno de estos operadores llama a SubtractRect.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

RECT   rectOne;
RECT   rectTwo;

rectOne.left = 10;
rectOne.top = 10;
rectOne.bottom = 100;
rectOne.right = 100;

rectTwo.left = 50;
rectTwo.top = 10;
rectTwo.bottom = 150;
rectTwo.right = 150;

CRect   rectDiff;

rectDiff.SubtractRect(&rectOne, &rectTwo);
CRect   rectResult(10, 10, 50, 100);

ASSERT(rectDiff == rectResult);

// works for CRect, too, since there is
// implicit CRect -> LPCRECT conversion

CRect rect1(10, 10, 100, 100);
CRect rect2(50, 10, 150, 150);
CRect rectOut;

rectOut.SubtractRect(rect1, rect2);
ASSERT(rectResult == rectOut);

`CRect::TopLeft`

Las coordenadas se devuelven como referencia a un objeto CPoint que se encuentra en CRect.

CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();

Valor devuelto

Las coordenadas de la esquina superior izquierda del rectángulo.

Comentarios

Puede usar esta función para obtener o establecer la esquina superior izquierda del rectángulo. Establezca la esquina mediante esta función en el lado izquierdo del operador de asignación.

Ejemplo

Vea el ejemplo de CRect::CenterPoint.

`CRect::UnionRect`

Hace que las dimensiones de CRect sean iguales a la unión de los dos rectángulos de origen.

BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parámetros

lpRect1
Apunta a un valor RECT o CRect que contiene un rectángulo de origen.

lpRect2
Apunta a un valor RECT o CRect que contiene un rectángulo de origen.

Valor devuelto

Distinto de cero si la unión no está vacía; 0 si la unión está vacía.

Comentarios

La unión es el rectángulo más pequeño que contiene ambos rectángulos de origen.

Windows omite las dimensiones de un rectángulo vacío; es decir, un rectángulo que no tiene alto o no tiene ancho.

Nota:

Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar los rectángulos antes de llamar a esta función.

Ejemplo

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3.UnionRect(&rect1, &rect2);
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);

`CRect::Width`

Calcula el ancho de CRect restando el valor izquierdo del valor derecho.

int Width() const throw();

Valor devuelto

Ancho de CRect.

Comentarios

El ancho puede ser negativo.

Nota:

El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect para normalizar el rectángulo antes de llamar a esta función.

Ejemplo

CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);

Vea también

CPoint (clase)
CSize (clase)
RECT

Compartir a través de

Clase CRect

Sintaxis

Miembros

Constructores públicos

Métodos públicos

Operadores públicos

Comentarios

Jerarquía de herencia

Requisitos

CRect::BottomRight

Valor devuelto

Comentarios

Ejemplo

CRect::CenterPoint

Valor devuelto

Ejemplo

CRect::CopyRect

Parámetros

Ejemplo

CRect::CRect

Parámetros

Comentarios

Ejemplo

CRect::DeflateRect

Parámetros

Comentarios

Ejemplo

CRect::EqualRect

Parámetros

Valor devuelto

Ejemplo

CRect::Height

Valor devuelto

Comentarios

Ejemplo

CRect::InflateRect

Parámetros

Comentarios

Ejemplo

CRect::IntersectRect

Parámetros

Valor devuelto

Comentarios

Ejemplo

CRect::IsRectEmpty

Valor devuelto

Comentarios

Ejemplo

CRect::IsRectNull

Valor devuelto

Comentarios

Ejemplo

CRect::MoveToX

Parámetros

Ejemplo

CRect::MoveToXY

Parámetros

Ejemplo

CRect::MoveToY

Parámetros

Ejemplo

CRect::NormalizeRect

Comentarios

Ejemplo

CRect::OffsetRect

Parámetros

Comentarios

Ejemplo

CRect::operator LPCRECT convierte CRect en LPCRECT.

Comentarios

CRect::operator LPRECT

Comentarios

Ejemplo

CRect::operator =

Parámetros

Ejemplo

CRect::operator ==

Parámetros

Valor devuelto

Clase `CRect`

`CRect::BottomRight`

`CRect::CenterPoint`

`CRect::CopyRect`

`CRect::CRect`

`CRect::DeflateRect`

`CRect::EqualRect`

`CRect::Height`

`CRect::InflateRect`

`CRect::IntersectRect`

`CRect::IsRectEmpty`

`CRect::IsRectNull`

`CRect::MoveToX`

`CRect::MoveToXY`

`CRect::MoveToY`

`CRect::NormalizeRect`

`CRect::OffsetRect`

`CRect::operator LPCRECT` convierte `CRect` en `LPCRECT`.

`CRect::operator LPRECT`

`CRect::operator =`

`CRect::operator ==`

`CRect::operator !=`

`CRect::operator +=`

`CRect::operator -=`

`CRect::operator &=`

`CRect::operator |=`

`CRect::operator +`

`CRect::operator -`

`CRect::operator &`

`CRect::operator |`

`CRect::PtInRect`

`CRect::SetRect`

`CRect::SetRectEmpty`

`CRect::SIZE`

`CRect::SubtractRect`

`CRect::TopLeft`

`CRect::UnionRect`