`CRect`-klasse

Vergelijkbaar met een Windows-structuur RECT .

Syntaxis

class CRect : public tagRECT

Leden

Openbare constructors

Naam	Beschrijving
`CRect::CRect`	Maakt een `CRect`-object.

Openbare methoden

Naam	Beschrijving
`CRect::BottomRight`	Retourneert het rechteronderpunt van `CRect`.
`CRect::CenterPoint`	Retourneert het middelpunt van `CRect`.
`CRect::CopyRect`	Hiermee kopieert u de afmetingen van een bronrechthoek naar `CRect`.
`CRect::DeflateRect`	Hiermee wordt de breedte en hoogte van `CRect`.
`CRect::EqualRect`	Bepaalt of `CRect` deze gelijk is aan de opgegeven rechthoek.
`CRect::Height`	Berekent de hoogte van `CRect`.
`CRect::InflateRect`	Verhoogt de breedte en hoogte van `CRect`.
`CRect::IntersectRect`	Sets `CRect` zijn gelijk aan het snijpunt van twee rechthoeken.
`CRect::IsRectEmpty`	Bepaalt of `CRect` deze leeg is. `CRect` is leeg als de breedte en/of hoogte 0 zijn.
`CRect::IsRectNull`	Bepaalt of de `top`variabelen , `bottom`en `leftright` lidvariabelen allemaal gelijk zijn aan 0.
`CRect::MoveToX`	Hiermee gaat u `CRect` naar de opgegeven x-coördinaat.
`CRect::MoveToXY`	Hiermee verplaatst u `CRect` naar de opgegeven x- en y-coördinaten.
`CRect::MoveToY`	Hiermee gaat u `CRect` naar de opgegeven y-coördinaat.
`CRect::NormalizeRect`	Standaardiseert de hoogte en breedte van `CRect`.
`CRect::OffsetRect`	Verplaatst `CRect` door de opgegeven offsets.
`CRect::PtInRect`	Bepaalt of het opgegeven punt binnen `CRect`ligt.
`CRect::SetRect`	Hiermee stelt u de afmetingen van `CRect`.
`CRect::SetRectEmpty`	Hiermee stelt `CRect` u een lege rechthoek in (alle coördinaten gelijk aan 0).
`CRect::Size`	Berekent de grootte van `CRect`.
`CRect::SubtractRect`	Eén rechthoek van een andere rechthoek aftrekken.
`CRect::TopLeft`	Retourneert het linkerbovenpunt van `CRect`.
`CRect::UnionRect`	Sets `CRect` zijn gelijk aan de samenvoeging van twee rechthoeken.
`CRect::Width`	Berekent de breedte van `CRect`.

Openbare operators

Naam	Beschrijving
`CRect::operator -`	Trekt de opgegeven verschuivingen af van `CRect` of neemt `CRect` af en retourneert het resulterende `CRect`.
`CRect::operator LPCRECT`	Converteert een `CRect` naar een `LPCRECT`.
`CRect::operator LPRECT`	Converteert een `CRect` naar een `LPRECT`.
`CRect::operator !=`	Bepaalt of `CRect` deze niet gelijk is aan een rechthoek.
`CRect::operator &`	Hiermee maakt u het snijpunt van `CRect` en een rechthoek en retourneert u het resulterende `CRect`.
`CRect::operator &=`	Stelt gelijk `CRect` aan het snijpunt van `CRect` en een rechthoek.
`CRect::operator \|`	Hiermee maakt u de samenvoeging van `CRect` en een rechthoek en retourneert u het resulterende `CRect`.
`CRect::operator \|=`	Sets `CRect` zijn gelijk aan de samenvoeging van `CRect` en een rechthoek.
`CRect::operator +`	Hiermee worden de opgegeven verschuivingen toegevoegd aan `CRect` of vergroot `CRect` en wordt het resulterende resultaat `CRect`geretourneerd.
`CRect::operator +=`	Hiermee worden de opgegeven offsets toegevoegd aan `CRect` of inflaties `CRect`.
`CRect::operator =`	Hiermee kopieert u de afmetingen van een rechthoek naar `CRect`.
`CRect::operator -=`	Trekt de opgegeven offsets af van `CRect` of neemt `CRect`af.
`CRect::operator ==`	Bepaalt of `CRect` deze gelijk is aan een rechthoek.

Opmerkingen

CRect bevat ook lidfuncties voor het bewerken CRect van objecten en Windows-structuren RECT .

Een CRect object kan worden doorgegeven als een functieparameter waar een RECT structuur, LPCRECTof LPRECT kan worden doorgegeven.

Opmerking

Deze klasse is afgeleid van de tagRECT structuur. (De naam tagRECT is een minder gebruikte naam voor de RECT structuur.) Dit betekent dat de gegevensleden (left, top, righten bottom) van de RECT structuur toegankelijke gegevensleden van CRectzijn.

Een CRect bevat lidvariabelen die de punten linksboven en rechtsonder van een rechthoek definiëren.

Bij het opgeven van een CRect, moet u voorzichtig zijn om het zo te maken dat deze wordt genormaliseerd, met andere woorden, dat de waarde van de linkercoördinaat kleiner is dan de rechtercoördinaat en de bovenkant kleiner is dan de onderkant. In een linkerbovenhoek van (10,10) en rechtsonder van (20.20) wordt bijvoorbeeld een genormaliseerde rechthoek gedefinieerd, maar linksboven (20.20) en rechtsonder (10.10) wordt een niet-genormaliseerde rechthoek gedefinieerd. Als de rechthoek niet is genormaliseerd, kunnen veel CRect lidfuncties onjuiste resultaten retourneren. (Zie CRect::NormalizeRect voor een lijst met deze functies.) Voordat u een functie aanroept waarvoor genormaliseerde rechthoeken zijn vereist, kunt u niet-genormaliseerde rechthoeken normaliseren door de functie aan te NormalizeRect roepen.

Wees voorzichtig bij het bewerken van een CRect met de CDC::DPtoLP functies en CDC::LPtoDP leden. Als de toewijzingsmodus van een weergavecontext zodanig is dat de y-extent negatief is, zoals in MM_LOENGLISH, transformeert u CDC::DPtoLP de CRect waarde zodat de bovenkant groter is dan de onderkant. Functies zoals Height en Size retourneren vervolgens negatieve waarden voor de hoogte van de getransformeerde CRectwaarde en de rechthoek wordt niet genormaliseerd.

Wanneer u overbelaste CRect operators gebruikt, moet de eerste operand een CRectzijn; de tweede kan een RECT structuur of een CRect object zijn.

Overnamehiërarchie

tagRECT

CRect

Behoeften

koptekst:atltypes.h

`CRect::BottomRight`

De coördinaten worden geretourneerd als een verwijzing naar een CPoint object in CRect.

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

Retourwaarde

De coördinaten van de rechterbenedenhoek van de rechthoek.

Opmerkingen

U kunt deze functie gebruiken om de rechterbenedenhoek van de rechthoek op te halen of in te stellen. Stel de hoek in met behulp van deze functie aan de linkerkant van de toewijzingsoperator.

Voorbeeld

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

Berekent het middelpunt van CRect door de linker- en rechterwaarden toe te voegen en door twee te delen, en de bovenste en laagste waarden toe te voegen en door twee te delen.

CPoint CenterPoint() const throw();

Retourwaarde

Een CPoint object dat het middelpunt is van CRect.

Voorbeeld

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

Kopieert de lpSrcRect rechthoek naar CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parameterwaarden

lpSrcRect
Verwijst naar de structuur of CRect het RECT object dat moet worden gekopieerd.

Voorbeeld

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`

Maakt een CRect-object.

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();

Parameterwaarden

l
Hiermee geeft u de linkerpositie van CRect.

t
Hiermee geeft u de bovenkant van CRect.

r
Hiermee geeft u de juiste positie van CRect.

b
Hiermee geeft u de onderkant van CRect.

srcRect
Verwijst naar de RECT structuur met de coördinaten voor CRect.

lpSrcRect
Verwijst naar de RECT structuur met de coördinaten voor CRect.

point
Hiermee geeft u het oorsprongspunt voor de rechthoek die moet worden samengesteld. Komt overeen met de linkerbovenhoek.

size
Hiermee geeft u de verplaatsing van de linkerbovenhoek naar de rechterbenedenhoek van de rechthoek die moet worden samengesteld.

topLeft
Hiermee geeft u de positie linksboven van CRect.

bottomRight
Hiermee geeft u de positie rechtsonder van CRect.

Opmerkingen

Als er geen argumenten worden gegeven, left, , topen bottomrightleden worden ingesteld op 0.

De CRect(const RECT&) en CRect(LPCRECT) constructors voeren een CopyRect. De andere constructors initialiseren de lidvariabelen van het object rechtstreeks.

Voorbeeld

// 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 deflateert CRect door de zijkanten naar het midden te verplaatsen.

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();

Parameterwaarden

x
Hiermee geeft u het aantal eenheden op om de linker- en rechterkant van CRect.

y
Hiermee geeft u het aantal eenheden op om de boven- en onderkant van CRect.

size
A SIZE of CSize dat het aantal eenheden aangeeft dat moet worden afgeblazen CRect. De cx waarde geeft het aantal eenheden aan dat de linker- en rechterzijde moet worden gedeflatd en de cy waarde geeft het aantal eenheden op dat moet worden gedeflatd de bovenkant en onderkant.

lpRect
Verwijst naar een RECT structuur of CRect waarmee het aantal eenheden wordt aangegeven dat elke zijde moet worden afgeblazen.

l
Hiermee geeft u het aantal eenheden op om de linkerkant van CRect.

t
Hiermee geeft u het aantal eenheden op om de bovenkant van CRect.

r
Hiermee geeft u het aantal eenheden op om de rechterkant van CRect.

b
Hiermee geeft u het aantal eenheden dat de onderkant van CRect.

Opmerkingen

DeflateRect Hiervoor voegt u eenheden toe aan de linkerkant en boven en trekt u eenheden van rechts en onder af. De parameters van DeflateRect zijn ondertekende waarden; positieve waarden afnemen CRect en negatieve waarden worden vergroot.

De eerste twee overbelastingen deflateren beide paren van tegenovergestelde zijden, CRect zodat de totale breedte met twee keer x (of cx) wordt verlaagd en de totale hoogte met twee keer y (of cy). De andere twee overbelastingen deflateren elke kant van CRect onafhankelijk van de andere.

Voorbeeld

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`

Bepaalt of CRect deze gelijk is aan de opgegeven rechthoek.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parameterwaarden

lpRect
Verwijst naar een RECT structuur of CRect object dat de coördinaten linksboven en de rechterbenedenhoek van een rechthoek bevat.

Retourwaarde

Niet-nul als de twee rechthoeken dezelfde waarden hebben boven, links, onder en rechts; anders 0.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Berekent de hoogte van CRect door de hoogste waarde af te trekken van de laagste waarde.

int Height() const throw();

Retourwaarde

De hoogte van CRect.

Opmerkingen

De resulterende waarde kan negatief zijn.

Opmerking

De rechthoek moet worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoek te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

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

`CRect::InflateRect`

InflateRect vergroot CRect door de zijkanten weg te bewegen van het midden.

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();

Parameterwaarden

x
Hiermee geeft u het aantal eenheden op om de linker- en rechterkant van CRect.

y
Hiermee geeft u het aantal eenheden op om de boven- en onderkant van CRect.

size
A SIZE of CSize waarmee het aantal eenheden wordt opgegeven dat moet worden CRectopgepompt. De cx waarde geeft het aantal eenheden aan dat de linker- en rechterzijde moet worden opgepompt en de cy waarde geeft het aantal eenheden op dat moet worden opgeschaald boven en onder.

lpRect
Verwijst naar een RECT structuur of CRect waarmee het aantal eenheden wordt aangegeven dat elke zijde moet worden vergroot.

l
Hiermee geeft u het aantal eenheden op om de linkerkant van CRect.

t
Hiermee geeft u het aantal eenheden op om de bovenkant van CRect.

r
Hiermee geeft u het aantal eenheden op om de rechterkant van CRect.

b
Hiermee geeft u het aantal eenheden op om de onderkant van CRect.

Opmerkingen

Om dit te doen, InflateRect trekt u eenheden van links en boven af en voegt u eenheden toe aan de rechterkant en onderkant. De parameters van InflateRect zijn ondertekende waarden; positieve waarden worden vergroot CRect en negatieve waarden afnemen.

De eerste twee overbelastingen vergroten beide paren van tegenoverliggende zijden, CRect zodat de totale breedte met twee keer x (of cx) wordt verhoogd en de totale hoogte met twee keer y (of cy). De andere twee overbelastingen worden elke kant van onafhankelijk van CRect de andere opgeblazen.

Voorbeeld

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`

Maakt een CRect gelijk aan het snijpunt van twee bestaande rechthoeken.

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

Parameterwaarden

lpRect1
Verwijst naar een RECT structuur of CRect object dat een bronrechthoek bevat.

lpRect2
Verwijst naar een RECT structuur of CRect object dat een bronrechthoek bevat.

Retourwaarde

Niet-nul als het snijpunt niet leeg is; 0 als het snijpunt leeg is.

Opmerkingen

Het snijpunt is de grootste rechthoek in beide bestaande rechthoeken.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Bepaalt of CRect deze leeg is.

BOOL IsRectEmpty() const throw();

Retourwaarde

Niet-nul als CRect leeg is; 0 als CRect deze niet leeg is.

Opmerkingen

Een rechthoek is leeg als de breedte en/of hoogte 0 of negatief zijn. Verschilt van IsRectNull, waarmee wordt bepaald of alle coördinaten van de rechthoek nul zijn.

Opmerking

De rechthoek moet worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoek te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Bepaalt of de bovenste, linker-, onderste en rechterwaarden CRect allemaal gelijk zijn aan 0.

BOOL IsRectNull() const throw();

Retourwaarde

Niet-nul als CRectde waarden boven, links, onder en rechts allemaal gelijk zijn aan 0; anders 0.

Opmerkingen

Verschilt van IsRectEmpty, waarmee wordt bepaald of de rechthoek leeg is.

Voorbeeld

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`

Roep deze functie aan om de rechthoek te verplaatsen naar de absolute x-coördinaat die is opgegeven door x.

void MoveToX(int x) throw();

Parameterwaarden

x
De absolute x-coördinaat voor de linkerbovenhoek van de rechthoek.

Voorbeeld

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`

Roep deze functie aan om de rechthoek te verplaatsen naar de absolute x- en y-coördinaten die zijn opgegeven.

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

Parameterwaarden

x
De absolute x-coördinaat voor de linkerbovenhoek van de rechthoek.

y
De absolute y-coördinaat voor de linkerbovenhoek van de rechthoek.

point
Een POINT structuur die de absolute linkerbovenhoek van de rechthoek aangeeft.

Voorbeeld

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`

Roep deze functie aan om de rechthoek te verplaatsen naar de absolute y-coördinaat die is opgegeven door y.

void MoveToY(int y) throw();

Parameterwaarden

y
De absolute y-coördinaat voor de linkerbovenhoek van de rechthoek.

Voorbeeld

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`

Normaliseert CRect zodat zowel de hoogte als de breedte positief zijn.

void NormalizeRect() throw();

Opmerkingen

De rechthoek wordt genormaliseerd voor vierde kwadrantpositie, die windows doorgaans gebruikt voor coördinaten. NormalizeRect vergelijkt de hoogste en laagste waarden en wisselt ze om als de bovenkant groter is dan de onderkant. Op dezelfde manier worden de linker- en rechterwaarden gewisseld als de linkerwaarde groter is dan de rechter. Deze functie is handig bij het omgaan met verschillende toewijzingsmodi en omgekeerde rechthoeken.

Opmerking

Voor de volgende CRect lidfuncties zijn genormaliseerde rechthoeken vereist om goed te kunnen werken: Height, , WidthSize, IsRectEmpty, PtInRect, , operator |IntersectRectoperator ==SubtractRectEqualRectUnionRectoperator !=, operator |=en .operator &=operator &

Voorbeeld

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

`CRect::OffsetRect`

Verplaatst CRect door de opgegeven offsets.

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

Parameterwaarden

x
Hiermee geeft u de hoeveelheid naar links of rechts te verplaatsen. Het moet negatief zijn om naar links te gaan.

y
Hiermee geeft u de hoeveelheid omhoog of omlaag te verplaatsen. Het moet negatief zijn om omhoog te gaan.

point
Bevat een POINT structuur of CPoint object waarin beide dimensies worden opgegeven waarmee moet worden verplaatst.

size
Bevat een SIZE structuur of CSize object waarin beide dimensies worden opgegeven waarmee moet worden verplaatst.

Opmerkingen

Hiermee verplaatst u CRectx eenheden langs de x-as en y eenheden langs de y-as. De x waarden en y parameters zijn ondertekende waarden, dus CRect kunnen links of rechts en omhoog of omlaag worden verplaatst.

Voorbeeld

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`

Converteert een CRect naar een LPCRECT.

operator LPCRECT() const throw();

Opmerkingen

Wanneer u deze functie gebruikt, hebt u de operator adres van (&) niet nodig. Deze operator wordt automatisch gebruikt wanneer u een CRect object doorgeeft aan een functie die een LPCRECT.

`CRect::operator LPRECT`

Converteert een CRect naar een LPRECT.

operator LPRECT() throw();

Opmerkingen

Wanneer u deze functie gebruikt, hebt u de operator adres van (&) niet nodig. Deze operator wordt automatisch gebruikt wanneer u een CRect object doorgeeft aan een functie die een LPRECT.

Voorbeeld

Zie het voorbeeld voor CRect::operator LPCRECT.

`CRect::operator =`

Wordt srcRect toegewezen aan CRect.

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

Parameterwaarden

srcRect
Verwijst naar een bronrechthoek. Kan een RECT of CRect.

Voorbeeld

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

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

`CRect::operator ==`

Bepaalt of rect deze gelijk is aan CRect door de coördinaten van de hoeken linksboven en rechtsonder te vergelijken.

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

Parameterwaarden

rect
Verwijst naar een bronrechthoek. Kan een RECT of CRect.

Retourwaarde

Niet-nul indien gelijk; anders 0.

Opmerkingen

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

Bepaalt of rect deze niet gelijk is aan CRect door de coördinaten van de hoeken linksboven en rechtsonder te vergelijken.

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

Parameterwaarden

rect
Verwijst naar een bronrechthoek. Kan een RECT of CRect.

Retourwaarde

Niet-nul indien niet gelijk; anders 0.

Opmerkingen

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

De eerste twee overbelastingen worden verplaatst CRect door de opgegeven offsets.

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

Parameterwaarden

point
Een POINT structuur of CPoint object dat het aantal eenheden aangeeft dat de rechthoek moet worden verplaatst.

size
Een SIZE structuur of CSize object dat het aantal eenheden aangeeft dat de rechthoek moet worden verplaatst.

lpRect
Verwijst naar een RECT structuur of CRect object dat het aantal eenheden bevat dat elke zijde van CRect.

Opmerkingen

De parameter- x en y (of cx ) cywaarden worden toegevoegd aan CRect.

De derde overbelasting wordt CRect vergroot door het aantal eenheden dat is opgegeven in elk lid van de parameter.

Voorbeeld

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

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

`CRect::operator -=`

De eerste twee overbelastingen worden verplaatst CRect door de opgegeven offsets.

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

Parameterwaarden

point
Een POINT structuur of CPoint object dat het aantal eenheden aangeeft dat de rechthoek moet worden verplaatst.

size
Een SIZE structuur of CSize object dat het aantal eenheden aangeeft dat de rechthoek moet worden verplaatst.

lpRect
Verwijst naar een RECT structuur of CRect object dat het aantal eenheden bevat om elke kant van CRect.

Opmerkingen

De waarden van de parameter x en y (of cx en cy) worden afgetrokken van CRect.

De derde overbelasting wordt afgeblazen CRect door het aantal eenheden dat is opgegeven in elk lid van de parameter. Houd er rekening mee dat deze overbelastingsfuncties zoals DeflateRect.

Voorbeeld

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

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

`CRect::operator &=`

Sets CRect gelijk aan het snijpunt van CRect en rect.

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

Parameterwaarden

rect
Bevat een RECT of CRect.

Opmerkingen

Het snijpunt is de grootste rechthoek die zich in beide rechthoeken bevindt.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

Zie het voorbeeld voor CRect::IntersectRect.

`CRect::operator |=`

Sets CRect zijn gelijk aan de samenvoeging van CRect en rect.

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

Parameterwaarden

rect
Bevat een CRect of RECT.

Opmerkingen

De samenvoeging is de kleinste rechthoek die beide bronrechthoeken bevat.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

De eerste twee overbelastingen retourneren een CRect object dat gelijk is aan CRect verplaatst door de opgegeven offsets.

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

Parameterwaarden

point
Een POINT structuur of CPoint object dat het aantal eenheden aangeeft dat de retourwaarde moet worden verplaatst.

size
Een SIZE structuur of CSize object dat het aantal eenheden aangeeft dat de retourwaarde moet worden verplaatst.

lpRect
Verwijst naar een RECT structuur of CRect object dat het aantal eenheden bevat dat aan elke zijde van de retourwaarde moet worden opgepompt.

Retourwaarde

Het CRect resultaat van het verplaatsen of opblazen CRect van het aantal eenheden dat is opgegeven in de parameter.

Opmerkingen

De parameters van de parameter en y (of cx ency) worden toegevoegd aan CRectde positie van de parameterx.

De derde overbelasting retourneert een nieuwe CRect die gelijk is aan CRect het aantal eenheden dat is opgegeven in elk lid van de parameter.

Voorbeeld

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

De eerste twee overbelastingen retourneren een CRect object dat gelijk is aan CRect verplaatst door de opgegeven offsets.

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

Parameterwaarden

point
Een POINT structuur of CPoint object dat het aantal eenheden aangeeft dat de retourwaarde moet worden verplaatst.

size
Een SIZE structuur of CSize object dat het aantal eenheden aangeeft dat de retourwaarde moet worden verplaatst.

lpRect
Verwijst naar een RECT structuur of CRect object dat het aantal eenheden bevat dat aan elke zijde van de retourwaarde moet worden afgeblazen.

Retourwaarde

Het CRect resultaat van het verplaatsen of deflateren CRect door het aantal eenheden dat is opgegeven in de parameter.

Opmerkingen

De parameters van de parameter en y (of cx ency) worden afgetrokken van CRectde positie van de parameterx.

De derde overbelasting retourneert een nieuwe CRect die gelijk is aan CRect het aantal eenheden dat is opgegeven in elk lid van de parameter. Houd er rekening mee dat deze overbelastingsfuncties zoals DeflateRect, niet SubtractRect.

Voorbeeld

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

Retourneert een CRect snijpunt van CRect en rect2.

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

Parameterwaarden

rect2
Bevat een RECT of CRect.

Retourwaarde

A CRect dat is het snijpunt van CRect en rect2.

Opmerkingen

Het snijpunt is de grootste rechthoek die zich in beide rechthoeken bevindt.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

Retourneert een CRect die de samenvoeging is van CRect en rect2.

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

Parameterwaarden

rect2
Bevat een RECT of CRect.

Retourwaarde

Een CRect die de vereniging is van CRect en rect2.

Opmerkingen

De samenvoeging is de kleinste rechthoek die beide rechthoeken bevat.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Bepaalt of het opgegeven punt binnen CRectligt.

BOOL PtInRect(POINT point) const throw();

Parameterwaarden

point
Bevat een POINT structuur of CPoint object.

Retourwaarde

Niet-nul als het punt binnen CRectligt ; anders 0.

Opmerkingen

Een punt bevindt zich binnen CRect als het zich aan de linkerkant of bovenzijde bevindt of zich binnen alle vier de zijden bevindt. Een punt aan de rechterkant of onderzijde bevindt zich buiten CRect.

Opmerking

De rechthoek moet worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoek te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Hiermee stelt u de afmetingen van CRect de opgegeven coördinaten in.

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

Parameterwaarden

x1
Hiermee geeft u de x-coördinaat van de linkerbovenhoek.

y1
Hiermee geeft u de y-coördinaat van de linkerbovenhoek.

x2
Hiermee geeft u de x-coördinaat van de rechterbenedenhoek.

y2
Hiermee geeft u de y-coördinaat van de rechterbenedenhoek.

Voorbeeld

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

`CRect::SetRectEmpty`

Hiermee maakt CRect u een null-rechthoek door alle coördinaten in te stellen op nul.

void SetRectEmpty() throw();

Voorbeeld

CRect rect;
rect.SetRectEmpty();

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

`CRect::SIZE`

De cx en cy leden van de retourwaarde bevatten de hoogte en breedte van CRect.

CSize Size() const throw();

Retourwaarde

Een CSize object dat de grootte van CRect.

Opmerkingen

De hoogte of breedte kan negatief zijn.

Opmerking

De rechthoek moet worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoek te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

`CRect::SubtractRect`

Maakt de afmetingen van het CRect gelijk aan de aftrekken van lpRectSrc2lpRectSrc1.

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

Parameterwaarden

lpRectSrc1
Verwijst naar de structuur of CRect het RECT object waaruit een rechthoek moet worden afgetrokken.

lpRectSrc2
Verwijst naar de RECT structuur of CRect het object dat moet worden afgetrokken van de rechthoek waarnaar de lpRectSrc1 parameter verwijst.

Retourwaarde

Niet-nul als de functie is geslaagd; anders 0.

Opmerkingen

De aftrekking is de kleinste rechthoek die alle punten lpRectScr1 bevat die zich niet op het snijpunt van lpRectScr1 en lpRectScr2bevinden.

De opgegeven lpRectSrc1 rechthoek wordt ongewijzigd als de rechthoek die is opgegeven door lpRectSrc2 niet volledig overlapt met de rechthoek die is opgegeven lpRectSrc1 in ten minste één van de x- of y-richtingen.

Als dat bijvoorbeeld lpRectSrc1 (10,10, 100.100) was en lpRectSrc2 (50,50, 150,150) was, zou de rechthoek waarnaar wordt verwezen lpRectSrc1 , ongewijzigd zijn wanneer de functie wordt geretourneerd. Indien lpRectSrc1 (10.10, 100.100) en lpRectSrc2 (50.10, 150.150) waren, zou de rechthoek waarnaar wordt verwezen lpRectSrc1 echter de coördinaten bevatten (10,10, 50.100) toen de functie werd geretourneerd.

SubtractRect is niet hetzelfde als operator - noch operator -=. Geen van deze operators roept ooit SubtractRectaan.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

De coördinaten worden geretourneerd als een verwijzing naar een CPoint object in CRect.

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

Retourwaarde

De coördinaten van de linkerbovenhoek van de rechthoek.

Opmerkingen

U kunt deze functie gebruiken om de linkerbovenhoek van de rechthoek op te halen of in te stellen. Stel de hoek in met behulp van deze functie aan de linkerkant van de toewijzingsoperator.

Voorbeeld

Zie het voorbeeld voor CRect::CenterPoint.

`CRect::UnionRect`

Hiermee worden de afmetingen gelijk aan de samenvoeging CRect van de twee bronrechthoeken.

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

Parameterwaarden

lpRect1
Verwijst naar een RECT of CRect die een bronrechthoek bevat.

lpRect2
Verwijst naar een RECT of CRect die een bronrechthoek bevat.

Retourwaarde

Niet-nul als de samenvoeging niet leeg is; 0 als de samenvoeging leeg is.

Opmerkingen

De samenvoeging is de kleinste rechthoek die beide bronrechthoeken bevat.

Windows negeert de afmetingen van een lege rechthoek; Dat wil gezegd: een rechthoek die geen hoogte heeft of geen breedte heeft.

Opmerking

Beide rechthoeken moeten worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoeken te normaliseren voordat u deze functie aanroept.

Voorbeeld

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`

Berekent de breedte van CRect door de linkerwaarde af te trekken van de rechterwaarde.

int Width() const throw();

Retourwaarde

De breedte van CRect.

Opmerkingen

De breedte kan negatief zijn.

Opmerking

De rechthoek moet worden genormaliseerd of deze functie kan mislukken. U kunt aanroepen NormalizeRect om de rechthoek te normaliseren voordat u deze functie aanroept.

Voorbeeld

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

Zie ook

CPoint klasse
CSize klasse
RECT

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-07

Delen via

CRect-klasse

Syntaxis

Leden

Openbare constructors

Openbare methoden

Openbare operators

Opmerkingen

Overnamehiërarchie

Behoeften

CRect::BottomRight

Retourwaarde

Opmerkingen

Voorbeeld

CRect::CenterPoint

Retourwaarde

Voorbeeld

CRect::CopyRect

Parameterwaarden

Voorbeeld

CRect::CRect

Parameterwaarden

Opmerkingen

Voorbeeld

CRect::DeflateRect

Parameterwaarden

Opmerkingen

Voorbeeld

CRect::EqualRect

Parameterwaarden

Retourwaarde

Voorbeeld

CRect::Height

Retourwaarde

Opmerkingen

Voorbeeld

CRect::InflateRect

Parameterwaarden

Opmerkingen

Voorbeeld

CRect::IntersectRect

Parameterwaarden

Retourwaarde

Opmerkingen

Voorbeeld

CRect::IsRectEmpty

Retourwaarde

Opmerkingen

Voorbeeld

CRect::IsRectNull

Retourwaarde

Opmerkingen

Voorbeeld

CRect::MoveToX

Parameterwaarden

Voorbeeld

CRect::MoveToXY

Parameterwaarden

Voorbeeld

CRect::MoveToY

Parameterwaarden

Voorbeeld

CRect::NormalizeRect

Opmerkingen

Voorbeeld

CRect::OffsetRect

Parameterwaarden

Opmerkingen

Voorbeeld

CRect::operator LPCRECT

Opmerkingen

CRect::operator LPRECT

Opmerkingen

Voorbeeld

CRect::operator =

Parameterwaarden

Voorbeeld

CRect::operator ==

Parameterwaarden

Retourwaarde

`CRect`-klasse

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

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