Grösser-Gleich >=

Der Grösser-Gleich-Operator führt einen Vergleich zweier Operanden durch und gibt den boolschen Wert true zurück, falls der erste Operand grässer oder gleich ist wie der zweite, ansonsten false. In C wird anstelle von true der Wert 1 und anstelle von false der Wert 0 zurückgegeben. Der Grösser-Gleich-Operator wird sehr häufig für Bedingungen in Kontrollstrukturen verwendet.

a is lower or equal to c
a is lower or equal to d

#include <stdio.h>

int main(){
  int a = 10;
  int b = 9;
  int c = 10;
  int d = 11;
  if(a <= b){printf("a is lower or equal to b\n");}
  if(a <= c){printf("a is lower or equal to c\n");}
  if(a <= d){printf("a is lower or equal to d\n");}
  return 0;
}

Siehe auch Grösser-Operator >, Kleiner-Operator <, Kleiner-Gleich-Operator <=, Bedingungen

Details

Der Grösser-Gleich-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, in C ein Integer-Typ, in C++ ein boolscher Typ.

Der Operator ist zulässig für arithmetische (Integer- und Fliesskomma-) Typen, boolsche Typen sowie Pointer. Handelt es sich bei den Typen der beiden Operanden um Pointer-Typen, so wird nach den Regeln der Pointer-Arithmetik vorgegangen. Handelt es sich bei den Typen der beiden Operanden um arithmetische Typen, so wird gegebenfalls eine automatische arithmetische Umwandlung vorgenommen. Entsprechen die Typen keinen der genannten Typen, so wird ein implizites Casting vorgenommen, welches gegebenfalls zu Compiler-Fehlern oder Warnungen führen kann. Warnungen sowohl von der Pointer-Arithmetik, der arithmetischen Umwandlung, als auch von impliziten Castings können mittels explizitem Casting unterdrückt werden.

Überladen des Operators

Der Grösser-Gleich-Operator hat grundsätzlich die semantische Bedeutung eines Grösser-Gleich-Tests zweier Operanden. Dem Programmierer steht jedoch frei, eine andere Semantik zu definieren.

Die Prototypen für das Überladen des Grösser-Gleich-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator >=(Type);
Type operator >=(Type) const;

Type operator >=(Type, Type);

Im folgenden Beispiel wird eine Klasse präsentiert für einen dreidimensionalen Vektor. Die Überladung des Grösser-Gleich-Operators überprüft, ob die euklidische Länge des ersten Vektors grösser oder gleich ist wie diejenige des zweiten Vektors.

v1 is longer-equal to v2.
v1 is longer-equal to v3.

#include <cstdio>
#include <cmath>

class Vector3{
  float a[3];
public:
  Vector3(float x, float y, float z){
    a[0]=x; a[1]=y; a[2]=z;
  }
  float length() const {return sqrt(
    a[0]*a[0] + a[1]*a[1] + a[2]*a[2]);
  }
  
  bool operator >=(Vector3& v2) const {
    return length() >= v2.length();
  }
};

int main(){
  Vector3 v1(2, 3, 4);
  Vector3 v2(1, 2, 3);
  Vector3 v3(3, 4, 2);
  if(v1 >= v2){printf("v1 is longer-equal to v2.\n");}
  if(v1 >= v3){printf("v1 is longer-equal to v3.\n");}
  return 0;
}