`CRect`-Klasse

Artikel
10/12/2023

Ähnlich wie eine Windows-Struktur RECT .

Syntax

class CRect : public tagRECT

Member

Öffentliche Konstruktoren

Name	Beschreibung
`CRect::CRect`	Erstellt ein `CRect`-Objekt.

Öffentliche Methoden

Name	Beschreibung
`CRect::BottomRight`	Gibt den unteren rechten Punkt von `CRect`.
`CRect::CenterPoint`	Gibt den Mittelpunkt von `CRect`.
`CRect::CopyRect`	Kopiert die Abmessungen eines Quellrechtecks in `CRect`.
`CRect::DeflateRect`	Verringert die Breite und Höhe von `CRect`.
`CRect::EqualRect`	Bestimmt, ob `CRect` das angegebene Rechteck gleich ist.
`CRect::Height`	Berechnet die Höhe von `CRect`.
`CRect::InflateRect`	Vergrößert die Breite und Höhe von `CRect`.
`CRect::IntersectRect`	Legt `CRect` gleich dem Schnittpunkt zweier Rechtecke fest.
`CRect::IsRectEmpty`	Bestimmt, ob `CRect` leer ist. `CRect` ist leer, wenn die Breite und/oder Höhe 0 sind.
`CRect::IsRectNull`	Bestimmt, ob die `top`Variablen ", `bottom`" `left`und `right` "Member" gleich 0 sind.
`CRect::MoveToX`	Wechselt `CRect` zur angegebenen x-Koordinate.
`CRect::MoveToXY`	Wechselt `CRect` zu den angegebenen x- und y-Koordinaten.
`CRect::MoveToY`	Wechselt `CRect` zur angegebenen y-Koordinate.
`CRect::NormalizeRect`	Standardisiert die Höhe und Breite von `CRect`.
`CRect::OffsetRect`	Verschiebt `CRect` sich durch die angegebenen Offsets.
`CRect::PtInRect`	Bestimmt, ob der angegebene Punkt innerhalb `CRect`liegt.
`CRect::SetRect`	Legt die Abmessungen von `CRect`.
`CRect::SetRectEmpty`	Legt `CRect` den Wert auf ein leeres Rechteck fest (alle Koordinaten gleich 0).
`CRect::Size`	Berechnet die Größe von `CRect`.
`CRect::SubtractRect`	Subtrahiert ein Rechteck von einem anderen.
`CRect::TopLeft`	Gibt den oberen linken Punkt von `CRect`.
`CRect::UnionRect`	Legt `CRect` gleich der Vereinigung zweier Rechtecke fest.
`CRect::Width`	Berechnet die Breite von `CRect`.

Öffentliche Operatoren

Name	Beschreibung
`CRect::operator -`	Subtrahiert die angegebenen Offsets von `CRect` oder deblasiert `CRect` und gibt die resultierenden `CRect`zurück.
`CRect::operator LPCRECT`	Konvertiert ein `CRect`-Element in ein `LPCRECT`-Element.
`CRect::operator LPRECT`	Konvertiert ein `CRect`-Element in ein `LPRECT`-Element.
`CRect::operator !=`	Bestimmt, ob `CRect` nicht gleich einem Rechteck ist.
`CRect::operator &`	Erstellt die Schnittmenge und `CRect` ein Rechteck und gibt das resultierende Zurück `CRect`.
`CRect::operator &=`	Legt `CRect` gleich dem Schnittpunkt von `CRect` und einem Rechteck fest.
`CRect::operator \|`	Erstellt die Vereinigung und `CRect` ein Rechteck und gibt das resultierende Zurück `CRect`.
`CRect::operator \|=`	Legt `CRect` gleich der Vereinigung von `CRect` und einem Rechteck fest.
`CRect::operator +`	Fügt die angegebenen Offsets zu `CRect` oder überblasen `CRect` hinzu und gibt die resultierenden `CRect`zurück.
`CRect::operator +=`	Fügt die angegebenen Offsets zu `CRect` oder überblasen `CRect`.
`CRect::operator =`	Kopiert die Abmessungen eines Rechtecks in `CRect`.
`CRect::operator -=`	Subtrahiert die angegebenen Offsets von `CRect` oder deblasiert `CRect`.
`CRect::operator ==`	Bestimmt, ob `CRect` ein Rechteck gleich ist.

Hinweise

CRect enthält auch Memberfunktionen zum Bearbeiten von CRect Objekten und Windows-Strukturen RECT .

Ein CRect Objekt kann als Funktionsparameter übergeben werden, unabhängig davon, wo eine RECT Struktur vorhanden LPCRECTist oder LPRECT übergeben werden kann.

Hinweis

Diese Klasse wird von der tagRECT Struktur abgeleitet. (Der Name ist ein weniger häufig verwendeter Name tagRECT für die RECT Struktur.) Dies bedeutet, dass die Datenmmber (, , und bottom) der RECT Struktur barrierefreie Datenmmber sindCRect. righttopleft

A CRect contains member variables that define the top-left and bottom-right points of a rectangle.

Bei der Angabe eines , CRectmüssen Sie darauf achten, sie so zu konstruieren, dass sie normalisiert wird, d. h., der Wert der linken Koordinate ist kleiner als die rechte koordinate und der obere wert kleiner als der untere. Beispielsweise definiert eine obere linke Ecke von (10,10) und unten rechts von (20,20) ein normalisiertes Rechteck, aber eine obere linke Ecke von (20,20) und unten rechts von (10,10) ein nicht normalisiertes Rechteck. Wenn das Rechteck nicht normalisiert ist, können viele CRect Memberfunktionen falsche Ergebnisse zurückgeben. (Eine Liste dieser Funktionen finden Sie unter CRect::NormalizeRect .) Bevor Sie eine Funktion aufrufen, die normalisierte Rechtecke erfordert, können Sie nicht normalisierte Rechtecke normalisieren, indem Sie die NormalizeRect Funktion aufrufen.

Achten Sie beim Bearbeiten einer CRect Funktion mit den CDC::DPtoLP Funktionen und CDC::LPtoDP Membern auf Vorsicht. Wenn der Zuordnungsmodus eines Anzeigekontexts so ist, dass das Y-Ausmaß negativ ist, wie in MM_LOENGLISH, dann wird die CRect Transformation so CDC::DPtoLP geändert, dass der obere Bereich größer als der untere ist. Funktionen wie Height und Size geben dann negative Werte für die Höhe der transformierten CRectZurück, und das Rechteck wird nicht normalisiert.

Bei verwendung überladener CRect Operatoren muss der erste Operand ein CRectsein; die zweite kann entweder eine RECT Struktur oder ein CRect Objekt sein.

Vererbungshierarchie

tagRECT

CRect

Anforderungen

Headeratltypes.h:

`CRect::BottomRight`

Die Koordinaten werden als Verweis auf ein CPoint Objekt zurückgegeben, das in CRect.

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

Rückgabewert

Die Koordinaten der unteren rechten Ecke des Rechtecks.

Hinweise

Mit dieser Funktion können Sie entweder die untere rechte Ecke des Rechtecks abrufen oder festlegen. Legen Sie die Ecke mithilfe dieser Funktion auf der linken Seite des Zuordnungsoperators fest.

Beispiel

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

Berechnet den Mittelpunkt, CRect indem die werte links und rechts hinzugefügt und durch zwei dividiert und die oberen und untersten Werte und dividiert durch zwei hinzugefügt werden.

CPoint CenterPoint() const throw();

Rückgabewert

Ein CPoint Objekt, das den Mittelpunkt von CRect.

Beispiel

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

Kopiert das lpSrcRect Rechteck in CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parameter

lpSrcRect
Verweist auf die Struktur oder CRect das RECT Objekt, die kopiert werden soll.

Beispiel

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`

Erstellt ein CRect-Objekt.

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

Parameter

l
Gibt die linke Position von CRect.

t
Gibt den oberen Rand von CRect.

r
Gibt die rechte Position von CRect.

b
Gibt den unteren Rand von CRect.

srcRect
Bezieht sich auf die RECT Struktur mit den Koordinaten für CRect.

lpSrcRect
Verweist auf die RECT Struktur mit den Koordinaten für CRect.

point
Gibt den Ursprungspunkt für das zu konstruierende Rechteck an. Entspricht der oberen linken Ecke.

size
Gibt die Verschiebung von der oberen linken Ecke zur unteren rechten Ecke des zu erstellenden Rechtecks an.

topLeft
Gibt die obere linke Position von CRect.

bottomRight
Gibt die untere rechte Position von CRect.

Hinweise

Wenn keine Argumente angegeben sind, leftwerden , , topright, und bottom Member auf 0 festgelegt.

Die CRect(const RECT&) und CRect(LPCRECT) Konstruktoren führen eine CopyRect. Die anderen Konstruktoren initialisieren die Membervariablen des Objekts direkt.

Beispiel

// 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 wird aufgeblasen CRect , indem sie ihre Seiten in Richtung der Mitte bewegt.

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

Parameter

x
Gibt die Anzahl der Einheiten an, um die linke und rechte Seite von CRect.

y
Gibt die Anzahl der Einheiten an, um die die obere und untere Ebene von CRect.

size
A SIZE oder CSize der die Anzahl der Einheiten angibt, die verzögert CRectwerden sollen. Der cx Wert gibt die Anzahl der Einheiten an, die links und rechts zurückverzögert werden sollen, und der cy Wert gibt die Anzahl der Einheiten an, die oben und unten verzögert werden sollen.

lpRect
Verweist auf eine RECT Struktur oder CRect gibt die Anzahl der Einheiten an, die jede Seite zurückstellen sollen.

l
Gibt die Anzahl der Einheiten an, mit der die linke Seite CRectverzögert werden soll.

t
Gibt die Anzahl der Einheiten an, mit der der obere Bereich CRectverzögert werden soll.

r
Gibt die Anzahl der Einheiten an, um die rechte Seite von CRect.

b
Gibt die Anzahl der Einheiten an, mit der der untere Bereich CRectverzögert werden soll.

Hinweise

DeflateRect Dazu werden Einheiten links und oben addiert und Einheiten von rechts und unten subtrahiert. Die Parameter von DeflateRect sind signierte Werte; positive Werte verzögern CRect und negative Werte inblasen.

Die ersten beiden Überladungen verzögern beide Paare gegenüberliegender Seiten CRect , sodass ihre Gesamtbreite um zwei Mal x (oder cx) verringert wird und ihre Gesamthöhe um zwei Mal y (oder cy). Die anderen beiden Überladungen verzögern jede Seite unabhängig von CRect den anderen.

Beispiel

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`

Bestimmt, ob CRect das angegebene Rechteck gleich ist.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parameter

lpRect
Verweist auf eine Struktur oder CRect ein RECT Objekt, die die Koordinaten der oberen linken und unteren rechten Ecke eines Rechtecks enthält.

Rückgabewert

Nonzero, wenn die beiden Rechtecke die gleichen oberen, linken, unteren und rechten Werte aufweisen; andernfalls 0.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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`

Berechnet die Höhe, CRect indem der obere Wert vom unteren Wert subtrahiert wird.

int Height() const throw();

Rückgabewert

Die Höhe von CRect.

Hinweise

Der resultierende Wert kann negativ sein.

Hinweis

Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .

Beispiel

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

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

`CRect::InflateRect`

InflateRect aufblasen CRect , indem sie ihre Seiten von der Mitte weg bewegen.

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

Parameter

x
Gibt die Anzahl der Einheiten an, mit der die linken und rechten Seiten aufgeblasen CRectwerden sollen.

y
Gibt die Anzahl der Einheiten an, die oben und unten CRectaufgeblasen werden sollen.

size
A SIZE oder CSize der die Anzahl der Einheiten angibt, die aufgeblasen CRectwerden sollen. Der cx Wert gibt die Anzahl der Einheiten an, die links und rechts aufgeblasen werden sollen, und der cy Wert gibt die Anzahl der Einheiten an, die oben und unten aufgeblasen werden sollen.

lpRect
Verweist auf eine RECT Struktur oder CRect gibt die Anzahl der Einheiten an, die jede Seite aufgeblasen werden sollen.

l
Gibt die Anzahl der Einheiten an, mit der die linke Seite aufgeblasen CRectwerden soll.

t
Gibt die Anzahl der Einheiten an, mit der der obere Bereich CRectaufgeblasen werden soll.

r
Gibt die Anzahl der Einheiten an, die auf der rechten Seite aufgeblasen CRectwerden sollen.

b
Gibt die Anzahl der Einheiten an, die am unteren Rand CRectaufgeblasen werden sollen.

Hinweise

Subtrahiert dazu InflateRect Einheiten von links und oben und fügt Einheiten rechts und unten hinzu. Die Parameter sind InflateRect signierte Werte; positive Werte überblasen CRect und negative Werte verzögern sie.

Die ersten beiden Überladungen überblasen beide Paare gegenüberliegender Seiten CRect , sodass ihre Gesamtbreite um zwei Mal x (oder cx) erhöht wird und ihre Gesamthöhe um zwei Mal y (oder cy) erhöht wird. Die anderen beiden Überladungen überblasen jede Seite unabhängig CRect von den anderen.

Beispiel

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`

CRect Gleich dem Schnittpunkt zweier vorhandener Rechtecke.

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

Parameter

lpRect1
Verweist auf eine Struktur oder CRect ein RECT Objekt, die ein Quellrechteck enthält.

lpRect2
Verweist auf eine Struktur oder CRect ein RECT Objekt, die ein Quellrechteck enthält.

Rückgabewert

Nonzero, wenn die Schnittmenge nicht leer ist; 0, wenn die Schnittmenge leer ist.

Hinweise

Die Schnittmenge ist das größte Rechteck, das in beiden vorhandenen Rechtecke enthalten ist.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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`

Bestimmt, ob CRect leer ist.

BOOL IsRectEmpty() const throw();

Rückgabewert

Ist "Nonzero" CRect leer; 0 wenn CRect nicht leer.

Hinweise

Ein Rechteck ist leer, wenn die Breite und/oder Höhe 0 oder negativ sind. Unterscheidet sich von IsRectNulldem, was bestimmt, ob alle Koordinaten des Rechtecks Null sind.

Hinweis

Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .

Beispiel

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`

Bestimmt, ob die Werte oben, links, unten und rechts CRect gleich 0 sind.

BOOL IsRectNull() const throw();

Rückgabewert

Nonzero, wenn CRect"s top,left, bottom, and right values are all equal to 0; otherwise 0.

Hinweise

Unterscheidet sich von IsRectEmptyder, die bestimmt, ob das Rechteck leer ist.

Beispiel

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`

Rufen Sie diese Funktion auf, um das Rechteck auf die absolute x-Koordinate zu verschieben, die durch x.

void MoveToX(int x) throw();

Parameter

x
Die absolute x-Koordinate für die obere linke Ecke des Rechtecks.

Beispiel

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`

Rufen Sie diese Funktion auf, um das Rechteck auf die angegebenen absoluten x- und y-Koordinaten zu verschieben.

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

Parameter

x
Die absolute x-Koordinate für die obere linke Ecke des Rechtecks.

y
Die absolute y-Koordinate für die obere linke Ecke des Rechtecks.

point
Eine POINT Struktur, die die absolute obere linke Ecke des Rechtecks angibt.

Beispiel

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`

Rufen Sie diese Funktion auf, um das Rechteck auf die absolute y-Koordinate zu verschieben, die durch y.

void MoveToY(int y) throw();

Parameter

y
Die absolute y-Koordinate für die obere linke Ecke des Rechtecks.

Beispiel

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`

Normalisiert CRect , sodass sowohl die Höhe als auch die Breite positiv sind.

void NormalizeRect() throw();

Hinweise

Das Rechteck wird für die Positionierung des vierten Quadranten normalisiert, die Windows in der Regel für Koordinaten verwendet. NormalizeRect Vergleicht die obersten und untersten Werte und tauscht sie aus, wenn der obere Wert größer als der untere ist. Entsprechend werden die Werte links und rechts ausgetauscht, wenn die linke Seite größer als die rechte ist. Diese Funktion ist nützlich beim Umgang mit verschiedenen Zuordnungsmodi und umgekehrten Rechtecke.

Hinweis

Die folgenden CRect Memberfunktionen erfordern normalisierte Rechtecke, um ordnungsgemäß zu funktionieren: Height, Width, , Size, IsRectEmpty, PtInRect, UnionRectSubtractRectoperator ==IntersectRectEqualRectoperator |operator |=operator !=operator &und .operator &=

Beispiel

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

`CRect::OffsetRect`

Verschiebt CRect sich durch die angegebenen Offsets.

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

Parameter

x
Gibt den Betrag an, der nach links oder rechts verschoben werden soll. Es muss negativ sein, um nach links zu bewegen.

y
Gibt den Betrag an, der nach oben oder unten verschoben werden soll. Es muss negativ sein, um nach oben zu wechseln.

point
Enthält eine Struktur oder CPoint ein POINT Objekt, die beide Dimensionen angibt, um die verschoben werden soll.

size
Enthält eine Struktur oder CSize ein SIZE Objekt, die beide Dimensionen angibt, um die verschoben werden soll.

Hinweise

Verschiebt CRectx Einheiten entlang der X-Achse und y Einheiten entlang der Y-Achse. Die x Parameter y sind signierte Werte, sodass CRect sie nach links oder rechts und nach oben oder unten verschoben werden können.

Beispiel

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` Konvertiert ein `CRect` in ein `LPCRECT`.

operator LPCRECT() const throw();

Hinweise

Wenn Sie diese Funktion verwenden, benötigen Sie nicht den Address-of-Operator (&). Dieser Operator wird automatisch verwendet, wenn Sie ein CRect Objekt an eine Funktion übergeben, die eine LPCRECT.

`CRect::operator LPRECT`

Konvertiert ein CRect-Element in ein LPRECT-Element.

operator LPRECT() throw();

Hinweise

Beispiel

Sehen Sie sich das Beispiel für CRect::operator LPCRECT.

`CRect::operator =`

srcRect Zugewiesen zu CRect.

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

Parameter

srcRect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.

Beispiel

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

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

`CRect::operator ==`

Bestimmt, ob rect gleich CRect ist, indem die Koordinaten der oberen linken und unteren rechten Ecke verglichen werden.

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

Parameter

rect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.

Rückgabewert

Nonzero wenn gleich; andernfalls 0.

Hinweise

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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

Bestimmt, ob rect es nicht gleich CRect ist, indem die Koordinaten der oberen linken und unteren rechten Ecken verglichen werden.

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

Parameter

rect
Bezieht sich auf ein Quellrechteck. Kann ein RECT oder CRect.

Rückgabewert

Nonzero, wenn nicht gleich; andernfalls 0.

Hinweise

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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

Die ersten beiden Überladungen werden durch die angegebenen Offsets verschoben CRect .

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

Parameter

point
Eine Struktur oder CPoint ein POINT Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.

size
Eine Struktur oder CSize ein SIZE Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.

lpRect
Verweist auf eine Struktur oder CRect ein RECT Objekt, die die Anzahl der Einheiten enthält, um jede Seite zu CRectüberblasen.

Hinweise

Die Werte und y (odercx) cydes Parameters x werden hinzugefügtCRect.

Die dritte Überladung wird um die Anzahl der Einheiten aufgeblasen CRect , die in jedem Element des Parameters angegeben sind.

Beispiel

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

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

`CRect::operator -=`

Die ersten beiden Überladungen werden durch die angegebenen Offsets verschoben CRect .

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

Parameter

point
Eine Struktur oder CPoint ein POINT Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.

size
Eine Struktur oder CSize ein SIZE Objekt, die die Anzahl der Einheiten angibt, um das Rechteck zu verschieben.

lpRect
Verweist auf eine Struktur oder CRect ein RECT Objekt, die die Anzahl der Einheiten enthält, um jede Seite von CRect.

Hinweise

Die Werte der Parameter x und y (oder cx und cy) werden von CRect.

Die dritte Überladung wird um die Anzahl der Einheiten aufgeblasen CRect , die in jedem Element des Parameters angegeben sind. Beachten Sie, dass diese Überladung wie DeflateRectfolgt funktioniert.

Beispiel

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

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

`CRect::operator &=`

Legt CRect gleich der Schnittmenge von CRect und rect.

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

Parameter

rect
Enthält ein RECT oder CRect.

Hinweise

Die Schnittmenge ist das größte Rechteck, das in beiden Rechtecke enthalten ist.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

Sehen Sie sich das Beispiel für CRect::IntersectRect.

`CRect::operator |=`

Legt CRect gleich der Vereinigung von CRect und rect.

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

Parameter

rect
Enthält ein CRect oder RECT.

Hinweise

Die Vereinigung ist das kleinste Rechteck, das beide Quellrechtecke enthält.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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

Die ersten beiden Überladungen geben ein CRect Objekt zurück, das durch CRect die angegebenen Offsets ersetzt wird.

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

Parameter

point
Eine Struktur oder CPoint ein POINT Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.

size
Eine Struktur oder CSize ein SIZE Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.

lpRect
Verweist auf eine Struktur oder CRect ein RECT Objekt, die die Anzahl der Einheiten enthält, um jede Seite des Rückgabewerts aufzublasen.

Rückgabewert

Das CRect Ergebnis des Verschiebens oder Aufblasens CRect durch die Anzahl der im Parameter angegebenen Einheiten.

Hinweise

Die Parameter und (odercx) cyder y Parameter x werden der CRectPosition des Parameters hinzugefügt.

Die dritte Überladung gibt einen neuen CRect Wert zurück, der der Anzahl der einheiten entspricht CRect , die in jedem Element des Parameters angegeben sind.

Beispiel

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

Die ersten beiden Überladungen geben ein CRect Objekt zurück, das durch CRect die angegebenen Offsets ersetzt wird.

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

Parameter

point
Eine Struktur oder CPoint ein POINT Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.

size
Eine Struktur oder CSize ein SIZE Objekt, die die Anzahl der Einheiten angibt, um den Rückgabewert zu verschieben.

lpRect
Verweist auf eine Struktur oder CRect ein RECT Objekt, die die Anzahl der Einheiten enthält, um jede Seite des Rückgabewerts zu verzögern.

Rückgabewert

Das CRect Ergebnis einer Verschiebung oder Deflating CRect durch die Anzahl der einheiten, die im Parameter angegeben sind.

Hinweise

Die Parameter und (odercx) cyder y Parameter x werden von CRectder Position des Parameters subtrahiert.

Die dritte Überladung gibt einen neuen CRect Wert zurück, der der Anzahl der einheiten entspricht CRect , die in jedem Element des Parameters angegeben sind. Beachten Sie, dass diese Überladung wie DeflateRect, nicht SubtractRect.

Beispiel

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

Gibt einen CRect Schnittpunkt von CRect und rect2 zurück.

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

Parameter

rect2
Enthält ein RECT oder CRect.

Rückgabewert

Das CRect ist die Schnittmenge von CRect und rect2.

Hinweise

Die Schnittmenge ist das größte Rechteck, das in beiden Rechtecke enthalten ist.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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

Gibt ein CRect , das die Vereinigung von CRect und rect2.

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

Parameter

rect2
Enthält ein RECT oder CRect.

Rückgabewert

Das CRect ist die Vereinigung von CRect und rect2.

Hinweise

Die Vereinigung ist das kleinste Rechteck, das beide Rechtecke enthält.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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`

Bestimmt, ob der angegebene Punkt innerhalb CRectliegt.

BOOL PtInRect(POINT point) const throw();

Parameter

point
Enthält eine Struktur oder CPoint ein POINT Objekt.

Rückgabewert

Nonzero, wenn der Punkt innerhalb CRectliegt ; andernfalls 0.

Hinweise

Ein Punkt liegt darin CRect , wenn er auf der linken oder oberen Seite liegt oder sich auf allen vier Seiten befindet. Ein Punkt auf der rechten oder unteren Seite befindet sich außerhalb CRect.

Hinweis

Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .

Beispiel

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`

Legt die Abmessungen der CRect angegebenen Koordinaten fest.

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

Parameter

x1
Gibt die x-Koordinate der oberen linken Ecke an.

y1
Gibt die y-Koordinate der oberen linken Ecke an.

x2
Gibt die x-Koordinate der unteren rechten Ecke an.

y2
Gibt die y-Koordinate der unteren rechten Ecke an.

Beispiel

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

`CRect::SetRectEmpty`

Macht CRect ein NULL-Rechteck, indem alle Koordinaten auf Null festgelegt werden.

void SetRectEmpty() throw();

Beispiel

CRect rect;
rect.SetRectEmpty();

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

`CRect::SIZE`

Die cx Elemente cy des Rückgabewerts enthalten die Höhe und Breite von CRect.

CSize Size() const throw();

Rückgabewert

Ein CSize Objekt, das die Größe von CRect.

Hinweise

Die Höhe oder Breite kann negativ sein.

Hinweis

Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .

Beispiel

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

`CRect::SubtractRect`

Macht die Dimensionen des CRect Gleichen der Subtraktion von lpRectSrc2 von lpRectSrc1.

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

Parameter

lpRectSrc1
Verweist auf die Struktur oder CRect das Objekt, von der RECT ein Rechteck subtrahiert werden soll.

lpRectSrc2
Verweist auf die Struktur oder CRect das RECT Objekt, die vom Rechteck subtrahiert werden soll, auf das der lpRectSrc1 Parameter verweist.

Rückgabewert

Ist ungleich null (0), wenn die Funktion erfolgreich ausgeführt wird, andernfalls null (0).

Hinweise

Die Subtraktion ist das kleinste Rechteck, das alle Punkte lpRectScr1 enthält, die sich nicht im Schnittpunkt von lpRectScr1 und lpRectScr2.

Das durch lpRectSrc1 das angegebene Rechteck bleibt unverändert, wenn das durch lpRectSrc2 die Angegebene Rechteck nicht vollständig überlappt, das in lpRectSrc1 mindestens einer der x- oder y-Richtungen angegeben ist.

Wenn beispielsweise lpRectSrc1 (10.10,10,100.100) und lpRectSrc2 (50.50, 150.150) waren, würde das Rechteck lpRectSrc1 unverändert bleiben, wenn die Funktion zurückgegeben wird. Wenn lpRectSrc1 (10,10, 100.100) und lpRectSrc2 (50.10, 150.150.150) wären, würde das Rechteck, auf lpRectSrc1 das verwiesen wird, die Koordinaten (10.10, 50.100) enthalten, wenn die Funktion zurückgegeben wird.

SubtractRectist nicht mit dem Operator - oder Operator -=identisch. Keiner dieser Operatoren ruft jemals auf SubtractRect.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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`

Die Koordinaten werden als Verweis auf ein CPoint Objekt zurückgegeben, das in CRect.

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

Rückgabewert

Die Koordinaten der oberen linken Ecke des Rechtecks.

Hinweise

Sie können diese Funktion verwenden, um die obere linke Ecke des Rechtecks abzurufen oder festzulegen. Legen Sie die Ecke mithilfe dieser Funktion auf der linken Seite des Zuordnungsoperators fest.

Beispiel

Sehen Sie sich das Beispiel für CRect::CenterPoint.

`CRect::UnionRect`

Macht die Dimensionen CRect gleich der Vereinigung der beiden Quellrechtecke.

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

Parameter

lpRect1
Verweist auf ein RECT Quellrechteck oder CRect ein Quellrechteck.

lpRect2
Verweist auf ein RECT Quellrechteck oder CRect ein Quellrechteck.

Rückgabewert

Nonzero, wenn die Gewerkschaft nicht leer ist; 0, wenn die Gewerkschaft leer ist.

Hinweise

Die Vereinigung ist das kleinste Rechteck, das beide Quellrechtecke enthält.

Windows ignoriert die Dimensionen eines leeren Rechtecks; d. h. ein Rechteck ohne Höhe oder breite.

Hinweis

Beide Rechtecke müssen normalisiert werden, oder diese Funktion schlägt fehl. Sie können die Rechtecke vor NormalizeRect dem Aufrufen dieser Funktion normalisieren.

Beispiel

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`

Berechnet die Breite, indem CRect der linke Wert vom rechten Wert subtrahiert wird.

int Width() const throw();

Rückgabewert

Die Breite von CRect.

Hinweise

Die Breite kann negativ sein.

Hinweis

Das Rechteck muss normalisiert werden, oder diese Funktion schlägt möglicherweise fehl. Sie können das Rechteck vor dem Aufrufen dieser Funktion normalisieren NormalizeRect .

Beispiel

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

Siehe auch

CPoint Klasse
CSize Klasse
RECT

CRect-Klasse

Syntax

Member

Öffentliche Konstruktoren

Öffentliche Methoden

Öffentliche Operatoren

Hinweise

Vererbungshierarchie

Anforderungen

CRect::BottomRight

Rückgabewert

Hinweise

Beispiel

CRect::CenterPoint

Rückgabewert

Beispiel

CRect::CopyRect

Parameter

Beispiel

CRect::CRect

Parameter

Hinweise

Beispiel

CRect::DeflateRect

Parameter

Hinweise

Beispiel

CRect::EqualRect

Parameter

Rückgabewert

Beispiel

CRect::Height

Rückgabewert

Hinweise

Beispiel

CRect::InflateRect

Parameter

Hinweise

Beispiel

CRect::IntersectRect

Parameter

Rückgabewert

Hinweise

Beispiel

CRect::IsRectEmpty

Rückgabewert

Hinweise

Beispiel

CRect::IsRectNull

Rückgabewert

Hinweise

Beispiel

CRect::MoveToX

Parameter

Beispiel

CRect::MoveToXY

Parameter

Beispiel

CRect::MoveToY

Parameter

Beispiel

CRect::NormalizeRect

Hinweise

Beispiel

CRect::OffsetRect

Parameter

Hinweise

Beispiel

CRect::operator LPCRECT Konvertiert ein CRect in ein LPCRECT.

Hinweise

CRect::operator LPRECT

Hinweise

Beispiel

CRect::operator =

Parameter

Beispiel

CRect::operator ==

Parameter

Rückgabewert

Hinweise

`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` Konvertiert ein `CRect` in ein `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`