C/C++ Schritt-für-Schritt - Seite 15

15. Schritt-für-Schritt C/C++ — C++ Programmierung - Operatorüberladung

Operatorüberladung

| | 1. Einführung

2. Operator
   • Regeln der Operatorüberladung
   • Einschränkungen bei der Operatorüberladung
3. Überladung unärer Operatoren
4. Überladung binärer Operatoren
5. Operatorüberladung mit Strings |

1. Einführung

| | // Weisen Sie eine Variable einer anderen zu
#include
using namespace std;
int main()
{
int a = 10, b;
b = a; // gültig
cout << b;
return 0;
} | // Weisen Sie ein Objekt einem anderen zu
#include
using namespace std;
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;
e2 = e1; // gültig
cout << endl << e2.eno << e2.sal;
return 0;
} |

Ausdrücke sind in jeder Sprache üblich; ein Ausdruck ist eine Sammlung von Operanden und Operatoren. Während eine Operation eine Sammlung von Ausdrücken ist.
Die obigen beiden Programme zeigen, wie Variablen/Objekte zusammen zugewiesen wurden.

Beide Programme sind gültig, sie demonstrieren die Verwendung des Gleichheitsoperators ( = ).

| | | |

Die Operatorüberladung ist eines der aufregendsten Merkmale der objektorientierten Programmierung. Sie wird verwendet, um Situationen wie die oben genannte illegale Strukturoperation zu überwinden. Sie kann komplexe, obskure Programmauflistungen in intuitiv offensichtliche verwandeln.

Durch die Operatorüberladung können wir sehen, wie die normalen C++-Operatoren neue Bedeutungen erhalten können, wenn sie auf benutzerdefinierte Datentypen angewendet werden. Das Schlüsselwort operator wird verwendet, um einen Operator zu überladen, und der resultierende Operator übernimmt die vom Programmierer bereitgestellte Bedeutung.

Zum Beispiel können wir mit Objekten eine direkte Zeichenfolgenzuweisungsoperation durchführen.

| | // Programm zur Zuweisung einer Zeichenfolge an eine andere
#include
#include
#include
using namespace std;
class string
{
char str;
public:
string() { }
string(char s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1(“Computer”);
string s2;
s2 = s1;
s2.putstring();
return 0;
} |

2. Operator

type operator operator-symbol ( parameter-list )

Das operator-Schlüsselwort deklariert eine Funktion, die angibt, was operator-symbol bedeutet, wenn es auf Instanzen einer Klasse angewendet wird. Dies gibt dem Operator mehr als eine Bedeutung oder “überlädt” ihn. Der Compiler unterscheidet zwischen den verschiedenen Bedeutungen eines Operators, indem er die Typen seiner Operanden untersucht.

Regeln der Operatorüberladung

• Sie können die folgenden Operatoren überladen:

| | ^= | &= | |= | << | >> | <<= | | | <= | >= | && | || | ++ | –– | | | ( ) | [ ] | new | delete | & | | | | | ~ | = | /= | %= | >>= | == | | | != | , | –> | –> | | |

• Wenn ein Operator sowohl als unärer als auch als binärer Operator verwendet werden kann, können Sie jede Verwendung separat überladen.

• Sie können einen Operator entweder mit einer nicht-statischen Mitgliedsfunktion oder einer globalen Funktion, die ein Freund einer Klasse ist, überladen. Eine globale Funktion muss mindestens einen Parameter haben, der vom Klassentyp oder ein Verweis auf den Klassentyp ist.

• Wenn ein unärer Operator mit einer Mitgliedsfunktion überladen wird, benötigt er keine Argumente. Wenn er mit einer globalen Funktion überladen wird, benötigt er ein Argument.

Wenn ein binärer Operator mit einer Mitgliedsfunktion überladen wird, benötigt er ein Argument. Wenn er mit einer globalen Funktion überladen wird, benötigt er zwei Argumente.

Einschränkungen bei der Operatorüberladung

• Sie können keine neuen Operatoren definieren, wie **.

• Sie können die Präzedenz oder Gruppierung eines Operators nicht ändern, noch können Sie die Anzahl der Operanden, die er akzeptiert, ändern.

• Sie können die Bedeutung eines Operators, wenn er auf integrierte Datentypen angewendet wird, nicht neu definieren.

• Überladene Operatoren können keine Standardargumente annehmen.

• Sie können kein Präprozessor-Symbol überladen, noch können Sie die folgenden Operatoren überladen:

| | . | .* | :: | ?: |

Der Zuweisungsoperator hat einige zusätzliche Einschränkungen. Er kann nur als nicht-statische Mitgliedsfunktion überladen werden, nicht als Freundfunktion. Es ist der einzige Operator, der nicht vererbt werden kann; eine abgeleitete Klasse kann den Zuweisungsoperator einer Basisklasse nicht verwenden.

3. Überladung unärer Operatoren

Lassen Sie uns mit der Überladung eines unären Operators beginnen. Unäre Operatoren wirken nur auf einen Operanden. (Ein Operand ist einfach eine Variable, die von einem Operator bearbeitet wird). Beispiele für unäre Operatoren sind die Inkrement- und Dekrementoperatoren ++ und –, sowie der unäre Minus.

Beispiel:
Das folgende Beispiel demonstriert die Verwendung des Inkrementoperators ++.

| | #include
using namespace std;
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count()  { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;                            // c1 = 0,  c2 = 0
cout << “\nC1 = “ << c1.get_count();       // anzeigen
cout << “\nC2 = “ << c2.get_count();

++c1; // c1 = 1
c2 = ++c1 ; // c1 = 2, c2 = 2

cout << “\nC1 = “ << c1.get_count();       // erneut anzeigen
cout << “\nC2 = “ << c2++.get_count();     // c2 = 3
return 0;
} |

Ein weiteres Beispiel zur Überladung des unären Minus.

| | #include
using namespace std;
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << “A = “ << a <<”B = “ << b;
}
void operator -()
{
a = -a; b = -b;
}
};

int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << “S : “;
s.putdata();
-s;
cout << endl << “S : “;
s.putdata();
return 0;
}
|

4. Überladung binärer Operatoren

Aber Operatoren können ebenso leicht wie unäre Operatoren überladen werden.  Wir werden Beispiele betrachten, die arithmetische Operatoren, Vergleichsoperatoren und arithmetische Zuweisungsoperatoren überladen.

Wir haben gerade gesehen, wie man einen unären Operator überlädt. Der gleiche Mechanismus kann verwendet werden, um einen binären Operator zu überladen.

| | // Überladung des + Operators
#include
using namespace std;
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< “ : “
<< mm << “ : “ << ss;
}
time operator+(time);
};

time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}

int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
} |

5. Operatorüberladung mit Strings

C/C++ behandelt Strings ganz anders; wir kopieren, verketten oder vergleichen Strings niemals mit Operatoren wie in anderen Sprachen. C/C++ hat eingebaute Funktionen, um die oben genannten Operationen durchzuführen. Aber C++ bietet die Möglichkeit, alles mit Strings unter Verwendung von Operatoren zu tun. Das bedeutet, dass wir den Operatoren zusätzliche Verantwortung übertragen müssen, um solche Dinge auszuführen.

Das folgende Beispiel demonstriert den Vergleich zwischen zwei Strings unter Verwendung des Vergleichsoperators ==.

| | // Programm zum Vergleichen von zwei Strings mit Operatorüberladung
#include
#include
#include
using namespace std;

enum boolean{ false, true };

class string
{
char str;
public:
string() { str = NULL; }
string(char *s) { str = s; }
int operator ==(string ts)
{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};

int main()
{
string s1(“Computer”);
string s2(“Computers”);

if(s1 == s2)
cout << “Gleich”;
else
cout << “Nicht Gleich”;

return 0;
} |

| | // Verkettung von zwei Strings
#include
#include
#include
using namespace std;

class string
{
char str;
public:
string()
{
str = new char[30] ; str = NULL;
}
string(char *s) { str = s; }
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;
}
};

int main()
{
string s1(“Computer”); string s2(“Institut”);
s1.putstring(); s2.putstring();
string s3;

s3 = s1 + s2;

s3.putstring();
return 0;
} |

Ref: Objektorientierte Programmierung in Turbo C++: Robert Lafore