Classe `CRect`

Articolo
10/12/2023

Simile a una struttura di Windows RECT .

Sintassi

class CRect : public tagRECT

Membri

Costruttori pubblici

Nome	Descrizione
`CRect::CRect`	Costruisce un oggetto `CRect`.

Metodi pubblici

Nome	Descrizione
`CRect::BottomRight`	Restituisce il punto inferiore destro di `CRect`.
`CRect::CenterPoint`	Restituisce il punto centrale di `CRect`.
`CRect::CopyRect`	Copia le dimensioni di un rettangolo di origine in `CRect`.
`CRect::DeflateRect`	Riduce la larghezza e l'altezza di `CRect`.
`CRect::EqualRect`	Determina se `CRect` è uguale al rettangolo specificato.
`CRect::Height`	Calcola l'altezza di `CRect`.
`CRect::InflateRect`	Aumenta la larghezza e l'altezza di `CRect`.
`CRect::IntersectRect`	Imposta `CRect` un valore uguale all'intersezione di due rettangoli.
`CRect::IsRectEmpty`	Determina se `CRect` è vuoto. `CRect` è vuoto se la larghezza e/o l'altezza sono 0.
`CRect::IsRectNull`	Determina se le `top`variabili membro , `bottomleft`, e `right` sono tutte uguali a 0.
`CRect::MoveToX`	Passa `CRect` alla coordinata x specificata.
`CRect::MoveToXY`	Passa `CRect` alle coordinate x e y specificate.
`CRect::MoveToY`	Passa `CRect` alla coordinata y specificata.
`CRect::NormalizeRect`	Standardizza l'altezza e la larghezza di `CRect`.
`CRect::OffsetRect`	Sposta `CRect` in base agli offset specificati.
`CRect::PtInRect`	Determina se il punto specificato si trova all'interno `CRect`di .
`CRect::SetRect`	Imposta le dimensioni di `CRect`.
`CRect::SetRectEmpty`	Imposta `CRect` su un rettangolo vuoto (tutte le coordinate uguali a 0).
`CRect::Size`	Calcola le dimensioni di `CRect`.
`CRect::SubtractRect`	Sottrae un rettangolo da un altro.
`CRect::TopLeft`	Restituisce il punto in alto a sinistra di `CRect`.
`CRect::UnionRect`	Imposta `CRect` uguale all'unione di due rettangoli.
`CRect::Width`	Calcola la larghezza di `CRect`.

Operatori pubblici

Nome	Descrizione
`CRect::operator -`	Sottrae gli offset specificati da `CRect` o deflate `CRect` e restituisce l'oggetto risultante `CRect`.
`CRect::operator LPCRECT`	Converte `CRect` in `LPCRECT`.
`CRect::operator LPRECT`	Converte `CRect` in `LPRECT`.
`CRect::operator !=`	Determina se `CRect` non è uguale a un rettangolo.
`CRect::operator &`	Crea l'intersezione di `CRect` e un rettangolo e restituisce l'oggetto risultante `CRect`.
`CRect::operator &=`	Imposta `CRect` uguale all'intersezione di `CRect` e a un rettangolo.
`CRect::operator \|`	Crea l'unione di `CRect` e un rettangolo e restituisce l'oggetto risultante `CRect`.
`CRect::operator \|=`	Imposta `CRect` uguale all'unione di `CRect` e a un rettangolo.
`CRect::operator +`	Aggiunge gli offset specificati a `CRect` o gonfia e restituisce `CRect` l'oggetto risultante `CRect`.
`CRect::operator +=`	Aggiunge gli offset specificati a `CRect` o aumenta `CRect`.
`CRect::operator =`	Copia le dimensioni di un rettangolo in `CRect`.
`CRect::operator -=`	Sottrae gli offset specificati da `CRect` o deflasce `CRect`.
`CRect::operator ==`	Determina se `CRect` è uguale a un rettangolo.

Osservazioni:

CRect include anche funzioni membro per modificare CRect gli oggetti e le strutture di Windows RECT .

Un CRect oggetto può essere passato come parametro di funzione ovunque sia possibile passare una RECT struttura, LPCRECTo LPRECT .

Nota

Questa classe è derivata dalla tagRECT struttura . Il nome è un nome tagRECT meno comunemente usato per la RECT struttura. Ciò significa che i membri dati (left, top, righte bottom) della RECT struttura sono membri dati accessibili di CRect.

Contiene CRect variabili membro che definiscono i punti superiore sinistro e inferiore destro di un rettangolo.

Quando si specifica un oggetto CRect, è necessario prestare attenzione a crearlo in modo che venga normalizzato, in altre parole, in modo che il valore della coordinata sinistra sia minore di quello destro e quello superiore sia minore del basso. Ad esempio, un angolo superiore sinistro (10,10) e inferiore destro di (20,20) definisce un rettangolo normalizzato, ma un rettangolo in alto a sinistra (20,20) e inferiore destro di (10,10) definisce un rettangolo non normalizzato. Se il rettangolo non è normalizzato, molte CRect funzioni membro potrebbero restituire risultati non corretti. Per un elenco di queste funzioni, vedere CRect::NormalizeRect . Prima di chiamare una funzione che richiede rettangoli normalizzati, è possibile normalizzare i rettangoli non normalizzati chiamando la NormalizeRect funzione .

Prestare attenzione quando si modifica un CRect oggetto con le CDC::DPtoLP funzioni membro e CDC::LPtoDP . Se la modalità di mapping di un contesto di visualizzazione è tale che l'extent y sia negativo, come in MM_LOENGLISH, CDC::DPtoLP trasformerà in modo che la CRect parte superiore sia maggiore della parte inferiore. Le funzioni come Height e Size restituiscono quindi valori negativi per l'altezza dell'oggetto trasformato CRecte il rettangolo non verrà normalizzato.

Quando si usano operatori di CRect overload, il primo operando deve essere un CRect. Il secondo può essere una RECT struttura o un CRect oggetto .

Gerarchia di ereditarietà

tagRECT

CRect

Requisiti

Intestazione: atltypes.h

`CRect::BottomRight`

Le coordinate vengono restituite come riferimento a un CPoint oggetto contenuto in CRect.

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

Valore restituito

Coordinate dell'angolo inferiore destro del rettangolo.

Osservazioni:

È possibile usare questa funzione per ottenere o impostare l'angolo inferiore destro del rettangolo. Impostare l'angolo usando questa funzione sul lato sinistro dell'operatore di assegnazione.

Esempio

// 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`

Calcola il punto centrale di CRect aggiungendo i valori sinistro e destro e dividendo per due e aggiungendo i valori superiore e inferiore e dividendo per due.

CPoint CenterPoint() const throw();

Valore restituito

Oggetto CPoint che rappresenta il punto centrale di CRect.

Esempio

// 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 il lpSrcRect rettangolo in CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parametri

lpSrcRect
Punta alla struttura o CRect all'oggetto RECT da copiare.

Esempio

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`

Costruisce un oggetto 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();

Parametri

l
Specifica la posizione sinistra di CRect.

t
Specifica la parte superiore di CRect.

r
Specifica la posizione corretta di CRect.

b
Specifica la parte inferiore di CRect.

srcRect
Fa riferimento alla RECT struttura con le coordinate per CRect.

lpSrcRect
Punta alla RECT struttura con le coordinate per CRect.

point
Specifica il punto di origine per il rettangolo da costruire. Corrisponde all'angolo superiore sinistro.

size
Specifica lo spostamento dall'angolo superiore sinistro all'angolo inferiore destro del rettangolo da costruire.

topLeft
Specifica la posizione superiore sinistra di CRect.

bottomRight
Specifica la posizione inferiore destra di CRect.

Osservazioni:

Se non vengono specificati argomenti, lefti membri , top, e bottom vengono rightimpostati su 0.

I CRectcostruttori (const RECT&) e CRect(LPCRECT) eseguono un oggetto CopyRect. Gli altri costruttori inizializzano direttamente le variabili membro dell'oggetto.

Esempio

// 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`

DeflateRectCRect sgonfia spostando i lati verso il 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();

Parametri

x
Specifica il numero di unità da sgonfiare i lati sinistro e destro di CRect.

y
Specifica il numero di unità da sgonfiare la parte superiore e inferiore di CRect.

size
Oggetto SIZE o CSize che specifica il numero di unità da deflare CRect. Il cx valore specifica il numero di unità da sgonfiare i lati sinistro e destro e il cy valore specifica il numero di unità da sgonfiare la parte superiore e inferiore.

lpRect
Punta a una RECT struttura o CRect che specifica il numero di unità da sgonfiare ogni lato.

l
Specifica il numero di unità da sgonfiare il lato sinistro di CRect.

t
Specifica il numero di unità da sgonfiare la parte superiore di CRect.

r
Specifica il numero di unità da sgonfiare il lato destro di CRect.

b
Specifica il numero di unità da sgonfiare la parte inferiore di CRect.

Osservazioni:

A tale scopo, DeflateRect aggiunge unità a sinistra e in alto e sottrae le unità dalla destra e dal basso. I parametri di DeflateRect sono valori firmati; i valori positivi deflate CRect e i valori negativi lo gonfiano.

I primi due overload sgonfiano entrambe le coppie di lati opposti di CRect in modo che la larghezza totale venga ridotta di due volte (o cx) e l'altezza totale viene ridotta di due volte x y (o cy). Gli altri due overload sgonfiano ogni lato indipendentemente CRect dagli altri.

Esempio

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 se CRect è uguale al rettangolo specificato.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parametri

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene le coordinate dell'angolo superiore sinistro e inferiore destro di un rettangolo.

Valore restituito

Diverso da zero se i due rettangoli hanno gli stessi valori superiore, sinistro, inferiore e destro; in caso contrario, 0.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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`

Calcola l'altezza di CRect sottraendo il valore superiore dal valore inferiore.

int Height() const throw();

Valore restituito

Altezza di CRect.

Osservazioni:

Il valore risultante può essere negativo.

Nota

Il rettangolo deve essere normalizzato oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare il rettangolo prima di chiamare questa funzione.

Esempio

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

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

`CRect::InflateRect`

InflateRect gonfia spostando CRect i lati lontano dal suo 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();

Parametri

x
Specifica il numero di unità da gonfiare i lati sinistro e destro di CRect.

y
Specifica il numero di unità da gonfiare nella parte superiore e inferiore di CRect.

size
Oggetto SIZE o CSize che specifica il numero di unità da gonfiare CRect. Il cx valore specifica il numero di unità da gonfiare i lati sinistro e destro e il cy valore specifica il numero di unità da gonfiare in alto e in basso.

lpRect
Punta a una RECT struttura o CRect che specifica il numero di unità da gonfiare ogni lato.

l
Specifica il numero di unità da gonfiare sul lato sinistro di CRect.

t
Specifica il numero di unità da gonfiare nella parte superiore di CRect.

r
Specifica il numero di unità da gonfiare sul lato destro di CRect.

b
Specifica il numero di unità da gonfiare nella parte inferiore di CRect.

Osservazioni:

A tale scopo, InflateRect sottrae le unità da sinistra e dall'alto e aggiunge unità a destra e in basso. I parametri di InflateRect sono valori con segno; i valori positivi gonfiano CRect e i valori negativi la deflazionano.

I primi due overload gonfiano entrambe le coppie di lati opposti di CRect in modo che la larghezza totale venga aumentata di due volte x (o cx) e l'altezza totale viene aumentata di due volte y (o cy). Gli altri due overload gonfiano ogni lato indipendentemente CRect dagli altri.

Esempio

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`

Rende uguale CRect all'intersezione di due rettangoli esistenti.

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

Parametri

lpRect1
Punta a una struttura o CRect a un RECT oggetto che contiene un rettangolo di origine.

lpRect2
Punta a una struttura o CRect a un RECT oggetto che contiene un rettangolo di origine.

Valore restituito

Diverso da zero se l'intersezione non è vuota; 0 se l'intersezione è vuota.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli esistenti.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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 se CRect è vuoto.

BOOL IsRectEmpty() const throw();

Valore restituito

Diverso da zero se CRect è vuoto; 0 se CRect non è vuoto.

Osservazioni:

Un rettangolo è vuoto se la larghezza e/o l'altezza sono 0 o negative. Differisce da IsRectNull, che determina se tutte le coordinate del rettangolo sono zero.

Nota

Il rettangolo deve essere normalizzato oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare il rettangolo prima di chiamare questa funzione.

Esempio

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 se i valori superiore, sinistro, inferiore e destro di CRect sono tutti uguali a 0.

BOOL IsRectNull() const throw();

Valore restituito

Diverso da zero se i CRectvalori superiore, sinistro, inferiore e destro sono tutti uguali a 0; in caso contrario, 0.

Osservazioni:

Differisce da IsRectEmpty, che determina se il rettangolo è vuoto.

Esempio

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`

Chiamare questa funzione per spostare il rettangolo nella coordinata x assoluta specificata da x.

void MoveToX(int x) throw();

Parametri

x
Coordinata x assoluta per l'angolo superiore sinistro del rettangolo.

Esempio

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`

Chiamare questa funzione per spostare il rettangolo nelle coordinate x e y assolute specificate.

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

Parametri

x
Coordinata x assoluta per l'angolo superiore sinistro del rettangolo.

y
Coordinata y assoluta per l'angolo superiore sinistro del rettangolo.

point
Struttura POINT che specifica l'angolo superiore sinistro assoluto del rettangolo.

Esempio

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`

Chiamare questa funzione per spostare il rettangolo nella coordinata y assoluta specificata da y.

void MoveToY(int y) throw();

Parametri

y
Coordinata y assoluta per l'angolo superiore sinistro del rettangolo.

Esempio

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`

Normalizza in CRect modo che sia l'altezza che la larghezza siano positive.

void NormalizeRect() throw();

Osservazioni:

Il rettangolo viene normalizzato per il posizionamento del quarto quadrante, che Windows usa in genere per le coordinate. NormalizeRect confronta i valori superiore e inferiore e li scambia se la parte superiore è maggiore della parte inferiore. Analogamente, scambia i valori sinistro e destro se la sinistra è maggiore della destra. Questa funzione è utile quando si gestiscono diverse modalità di mapping e rettangoli invertiti.

Nota

Le funzioni membro seguenti CRect richiedono rettangoli normalizzati per funzionare correttamente: Height, , SizeWidthIsRectEmpty, , PtInRect, IntersectRectSubtractRectoperator ==UnionRectEqualRectoperator |operator |=operator !=operator &e .operator &=

Esempio

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

`CRect::OffsetRect`

Sposta CRect in base agli offset specificati.

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

Parametri

x
Specifica l'importo da spostare a sinistra o a destra. Deve essere negativo per spostarsi a sinistra.

y
Specifica l'importo da spostare verso l'alto o verso il basso. Deve essere negativo per alzarsi.

point
Contiene una struttura o CPoint un POINT oggetto che specifica entrambe le dimensioni in base alle quali spostarsi.

size
Contiene una struttura o CSize un SIZE oggetto che specifica entrambe le dimensioni in base alle quali spostarsi.

Osservazioni:

Sposta CRectx le unità lungo l'asse x e y le unità lungo l'asse y. I x parametri e y sono valori con segno, quindi CRect possono essere spostati verso sinistra o destra e verso l'alto o verso il basso.

Esempio

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` Converte un oggetto in `CRect` un oggetto `LPCRECT`.

operator LPCRECT() const throw();

Osservazioni:

Quando si usa questa funzione, non è necessario l'operatore address-of (&). Questo operatore verrà usato automaticamente quando si passa un CRect oggetto a una funzione che prevede un oggetto LPCRECT.

`CRect::operator LPRECT`

Converte CRect in LPRECT.

operator LPRECT() throw();

Osservazioni:

Esempio

Vedere l'esempio per CRect::operator LPCRECT.

`CRect::operator =`

srcRect Assegna a CRect.

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

Parametri

srcRect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Esempio

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

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

`CRect::operator ==`

Determina se rect è uguale a CRect confrontando le coordinate degli angoli superiore sinistro e inferiore destro.

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

Parametri

rect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Valore restituito

Diverso da zero se uguale; in caso contrario, 0.

Osservazioni:

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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 se rect non è uguale a CRect confrontando le coordinate degli angoli superiore sinistro e inferiore destro.

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

Parametri

rect
Fa riferimento a un rettangolo di origine. Può essere un RECT oggetto o CRect.

Valore restituito

Diverso da zero se non uguale; in caso contrario, 0.

Osservazioni:

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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 +=`

I primi due overload vengono spostati CRect dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità di misura per spostare il rettangolo.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità di misura per spostare il rettangolo.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da gonfiare ogni lato di CRect.

Osservazioni:

I valori e y (o cx e cy) del x parametro vengono aggiunti a CRect.

Il terzo overload viene gonfiato in base CRect al numero di unità specificate in ogni membro del parametro.

Esempio

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

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

`CRect::operator -=`

I primi due overload vengono spostati CRect dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità di misura per spostare il rettangolo.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità di misura per spostare il rettangolo.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da sgonfiare ogni lato di CRect.

Osservazioni:

I valori e y (o cx e cy) del x parametro vengono sottratti da CRect.

Il terzo overload sgonfia CRect in base al numero di unità specificate in ogni membro del parametro. Si noti che questo overload funziona come DeflateRect.

Esempio

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

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

`CRect::operator &=`

Imposta CRect uguale all'intersezione di CRect e rect.

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

Parametri

rect
Contiene un RECT oggetto o CRect.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

Vedere l'esempio per CRect::IntersectRect.

`CRect::operator |=`

Imposta CRect uguale all'unione di CRect e rect.

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

Parametri

rect
Contiene un CRect oggetto o RECT.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli di origine.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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 +`

I primi due overload restituiscono un CRect oggetto uguale a CRect spostato dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità per spostare il valore restituito.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità per spostare il valore restituito.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da gonfiare ogni lato del valore restituito.

Valore restituito

Oggetto CRect risultante dallo spostamento o dall'aumento CRect in base al numero di unità specificate nel parametro .

Osservazioni:

I parametri e y (o cx e cy) del x parametro vengono aggiunti alla CRectposizione del parametro .

Il terzo overload restituisce un nuovo CRect oggetto uguale a gonfiato in base al CRect numero di unità specificate in ogni membro del parametro.

Esempio

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

I primi due overload restituiscono un CRect oggetto uguale a CRect spostato dagli offset specificati.

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

Parametri

point
Struttura POINT o CPoint oggetto che specifica il numero di unità per spostare il valore restituito.

size
Struttura SIZE o CSize oggetto che specifica il numero di unità per spostare il valore restituito.

lpRect
Punta a una struttura o CRect a un RECT oggetto che contiene il numero di unità da sgonfiare ogni lato del valore restituito.

Valore restituito

Oggetto CRect risultante CRect dallo spostamento o dall'abbassamento in base al numero di unità specificate nel parametro .

Osservazioni:

I parametri e y (o cx e cy) del x parametro vengono sottratti dalla CRectposizione del parametro.

Il terzo overload restituisce un nuovo CRect oggetto uguale a deflato in base al CRect numero di unità specificate in ogni membro del parametro. Si noti che questo overload funziona come DeflateRect, non SubtractRect.

Esempio

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 &`

Restituisce un oggetto CRect che rappresenta l'intersezione tra CRect e rect2.

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

Parametri

rect2
Contiene un RECT oggetto o CRect.

Valore restituito

Oggetto CRect che rappresenta l'intersezione di CRect e rect2.

Osservazioni:

L'intersezione è il rettangolo più grande contenuto in entrambi i rettangoli.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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

Restituisce un oggetto CRect che rappresenta l'unione di CRect e rect2.

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

Parametri

rect2
Contiene un RECT oggetto o CRect.

Valore restituito

Oggetto CRect che rappresenta l'unione di CRect e rect2.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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 se il punto specificato si trova all'interno CRectdi .

BOOL PtInRect(POINT point) const throw();

Parametri

point
Contiene una struttura o CPoint un POINT oggetto .

Valore restituito

Diverso da zero se il punto si trova all'interno CRectdi ; in caso contrario, 0.

Osservazioni:

Un punto si trova all'interno se si trova sul lato sinistro o superiore o si trova all'interno CRect di tutti e quattro i lati. Un punto sul lato destro o inferiore si trova all'esterno CRectdi .

Nota

Il rettangolo deve essere normalizzato oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare il rettangolo prima di chiamare questa funzione.

Esempio

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`

Imposta le dimensioni di CRect sulle coordinate specificate.

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

Parametri

x1
Specifica la coordinata x dell'angolo superiore sinistro.

y1
Specifica la coordinata y dell'angolo superiore sinistro.

x2
Specifica la coordinata x dell'angolo inferiore destro.

y2
Specifica la coordinata y dell'angolo inferiore destro.

Esempio

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

`CRect::SetRectEmpty`

Crea CRect un rettangolo Null impostando tutte le coordinate su zero.

void SetRectEmpty() throw();

Esempio

CRect rect;
rect.SetRectEmpty();

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

`CRect::SIZE`

I cx membri e cy del valore restituito contengono l'altezza e la larghezza di CRect.

CSize Size() const throw();

Valore restituito

Oggetto CSize contenente le dimensioni di CRect.

Osservazioni:

L'altezza o la larghezza possono essere negative.

Nota

Il rettangolo deve essere normalizzato oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare il rettangolo prima di chiamare questa funzione.

Esempio

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

`CRect::SubtractRect`

Rende le dimensioni dell'oggetto CRect uguale alla sottrazione di lpRectSrc2 da lpRectSrc1.

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

Parametri

lpRectSrc1
Punta alla struttura o CRect all'oggetto RECT da cui deve essere sottratto un rettangolo.

lpRectSrc2
Punta alla struttura o CRect all'oggetto RECT che deve essere sottratto dal rettangolo a cui punta il lpRectSrc1 parametro .

Valore restituito

Diverso da zero se la funzione ha esito positivo; in caso contrario, 0.

Osservazioni:

La sottrazione è il rettangolo più piccolo che contiene tutti i punti in lpRectScr1 che non si trovano nell'intersezione di lpRectScr1 e lpRectScr2.

Il rettangolo specificato da lpRectSrc1 sarà invariato se il rettangolo specificato da lpRectSrc2 non sovrappone completamente il rettangolo specificato da lpRectSrc1 in almeno una delle direzioni x o y.

Ad esempio, se lpRectSrc1 fossero (10,10, 100,100) e lpRectSrc2 fossero (50,50, 150,150), il rettangolo a cui lpRectSrc1 punta sarebbe invariato quando la funzione restituita. Se lpRectSrc1 fossero (10,10, 100,100) e lpRectSrc2 fossero (50,10, 150,150), tuttavia, il rettangolo a lpRectSrc1 cui puntava conterrà le coordinate (10,10, 50,100) quando la funzione restituita.

SubtractRect non è uguale all'operatore - né operator -=. Nessuno di questi operatori chiama SubtractRectmai .

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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`

Le coordinate vengono restituite come riferimento a un CPoint oggetto contenuto in CRect.

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

Valore restituito

Coordinate dell'angolo superiore sinistro del rettangolo.

Osservazioni:

È possibile usare questa funzione per ottenere o impostare l'angolo superiore sinistro del rettangolo. Impostare l'angolo usando questa funzione sul lato sinistro dell'operatore di assegnazione.

Esempio

Vedere l'esempio per CRect::CenterPoint.

`CRect::UnionRect`

Rende le dimensioni di CRect uguale all'unione dei due rettangoli di origine.

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

Parametri

lpRect1
Punta a un RECT oggetto o CRect che contiene un rettangolo di origine.

lpRect2
Punta a un RECT oggetto o CRect che contiene un rettangolo di origine.

Valore restituito

Diverso da zero se l'unione non è vuota; 0 se l'unione è vuota.

Osservazioni:

L'unione è il rettangolo più piccolo che contiene entrambi i rettangoli di origine.

Windows ignora le dimensioni di un rettangolo vuoto; ovvero un rettangolo senza altezza o senza larghezza.

Nota

Entrambi i rettangoli devono essere normalizzati oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare i rettangoli prima di chiamare questa funzione.

Esempio

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`

Calcola la larghezza di CRect sottraendo il valore sinistro dal valore destro.

int Width() const throw();

Valore restituito

Larghezza di CRect.

Osservazioni:

La larghezza può essere negativa.

Nota

Il rettangolo deve essere normalizzato oppure questa funzione potrebbe non riuscire. È possibile chiamare NormalizeRect per normalizzare il rettangolo prima di chiamare questa funzione.

Esempio

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

Vedi anche

CPoint Classe
CSize Classe
RECT

Condividi tramite

Classe CRect

Sintassi

Membri

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Osservazioni:

Gerarchia di ereditarietà

Requisiti

CRect::BottomRight

Valore restituito

Osservazioni:

Esempio

CRect::CenterPoint

Valore restituito

Esempio

CRect::CopyRect

Parametri

Esempio

CRect::CRect

Parametri

Osservazioni:

Esempio

CRect::DeflateRect

Parametri

Osservazioni:

Esempio

CRect::EqualRect

Parametri

Valore restituito

Esempio

CRect::Height

Valore restituito

Osservazioni:

Esempio

CRect::InflateRect

Parametri

Osservazioni:

Esempio

CRect::IntersectRect

Parametri

Valore restituito

Osservazioni:

Esempio

CRect::IsRectEmpty

Valore restituito

Osservazioni:

Esempio

CRect::IsRectNull

Valore restituito

Osservazioni:

Esempio

CRect::MoveToX

Parametri

Esempio

CRect::MoveToXY

Parametri

Esempio

CRect::MoveToY

Parametri

Esempio

CRect::NormalizeRect

Osservazioni:

Esempio

CRect::OffsetRect

Parametri

Osservazioni:

Esempio

CRect::operator LPCRECT Converte un oggetto in CRect un oggetto LPCRECT.

Osservazioni:

CRect::operator LPRECT

Osservazioni:

Esempio

CRect::operator =

Parametri

Esempio

CRect::operator ==

Parametri

Valore restituito

Classe `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` Converte un oggetto in `CRect` un oggetto `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`