wie funktioniert equal()

[Progressive]

wob schrieb:

Ich versuchs nochmal zu antworten, empfehle dir aber ein Buch oder mal nach Operator Overloading rumzusuchen.

Ja, hatte ebenein paar interessante Sachen gesehen, werd die mir morgen mal angucken.

wob schrieb:

Naja, wenn da irgendwo links >> rechts steht, übersetzt der Compiler dir das in den Funktionsaufruf operator>>(links, rechts) . Das funktioniert, wenn du einen passenden operator>> als freie Funktion definiert hast. Wenn du aber den Operator als Memberfunktion machst, dann kann der operator nur noch ein Argument nehmen (nämlich "rechts") und "links" ist fest auf das aktuelle Objekt eingestellt. Du könntest dann also nicht cout << apd schreiben, sondern müsstest apd << cout schreiben. Daher definiert man die Operatoren, die links des operators etwas anderes als *this haben können sollen, als freie Funktionen und nicht als Memberfunktionen.

Vielen Dank, das war sehr nützlich! Das hat schonmal ein paar Irritationen ausgemerzt

Beide sind doch in der Klasse deklariert.

Nein, sind sie nicht.

Mit friend davor sagst du nur: die folgende liebe Funktion, die nicht zu meiner Klasse gehört, darf trotzdem meine privaten Member benutzen. Damit wird die Funktion aber keine Memberfunktion.[/quote]
friend wusste ich sogar bereits :p

Bezüglich dem ~(istream in, APD& apd) ist

Das in den bisherigen Beispielen Gesagte trifft auch dann zu, wenn es sich bei den Übergabeparametern statt um einfache Typen (wie int, float oder double) um Objekte handelt:

class A {
// ...
};

int count( A a);

Hierbei wird ein Objekt vom Typ A per value an die Funktion count() übergeben. Weiter oben wurde gesagt, dass bei dieser Form der Übergabe eine Kopie des Parameters auf dem Stack angelegt wird.
https://www.kompf.de/cplus/artikel/funcpar.html

das, worum es geht ? Hatte nämlich vorhin auch gelesen, dass hierbei "..&" nicht der Adressoperator wäre bzw. man ihn damit nicht verwechseln dürfe
In meinem Kopf macht mir das "Objekt übergeben" irgendwie Schwierigkeiten. int, double, strings etc. übergeben, ja, klar.. aber wenn ich ein Objekt übergebe ? Wie oder wo genau wird geregelt, wie dieses verwertet wird ?
Wie eine Funktion einen übergebenen Parameter behandelt, ist ersichtlich..

[Progressive]

Hi,

auf http://www.cpp-tutor.de/cpp/le12/ueberl_spez.html ist die Thematik glaube gut erklärt. Ich kriege auch mehr und mehr eine Vorstellung, was prinzipiell eigentlich so von sich geht. Glaube ich jedenfalls.

Was mich die ganze Zeit irritiert hat, war die folgende "Schreibweise":

z.B.:

ostream& operator<<(ostream& out, const [b]APD& apd[/b])

Ich konnte mit APD& apd nichts anfangen, auch wenn ich es an und für sich lesen kann. APD& ist eine Referenz auf die Klasse APD und diese erhält dann lediglich den Namen apd. Richtig ?
Ich könnte also auch schreiben:

ostream& operator<<(ostream& out, const APD& Name-des-Zeigers-der-auf-die-Klasse-APD-zeigt)

?

Ich bin ja quasi gerade erst dabei, in C++ einzusteigen und das hatte mir ad hoc zuviel Ähnlichkeit mit "APD apd", was ja ein Objekt namens apd der Klasse APD erstellt..

[wob]

Ich konnte mit APD& apd nichts anfangen, auch wenn ich es an und für sich lesen kann. APD& ist eine Referenz auf die Klasse APD und diese erhält dann lediglich den Namen apd.

APD& apd ist nicht eine Referenz auf die Klasse APD, sondern apd ist eine Referenz auf ein Objekt der Klasse APD. (Was soll "Referenz auf Klasse" sein?)

Lies dir mal http://www.cplusplus.com/doc/tutorial/functions/ durch. Da ist ganz gut erklärt, wie Parameterübergabe an Funktionen funktioniert.

[Progressive]

wob schrieb:

APD& apd ist nicht eine Referenz auf die Klasse APD, sondern apd ist eine Referenz auf ein Objekt der Klasse APD. (Was soll "Referenz auf Klasse" sein?)

Das stimmt wohl. Hab mir den kompletten Link durchgelesen. Inline ist nice to know, der Rest ist soweit bekannt..
Das Objekt, auf das apd zeigt, ist das jenes, welches ich z.B. in main erstelle ?

Normalerweise ist die Definition doch so: int& a bedeutet, der Referenzoperator & zeigt auf die Variable a, vom Typ int.

Analog dachte ich also demnach: APD& ist eine Referenz, die auf die Variable apd vom Typ APD zeigt/vom Typ der Klasse APD.
edit: Ahso, das wäre ja dann ein Objekt von APD ?!

[Progressive]

wob schrieb:

Den opereator<< brauchst du, damit du in deinem Hauptprogramm sowas schreiben kannst:

APD apd(input);
// statt: apd.print();
std::cout << apd << '\n';

Dazu definiere den operator<< analog zu operator>>, also NICHT so wie du es gemacht hast, sondern definiere ihn analog AUSSERHALB der Klasse und gib ihm ostream& und const APD& als Parameter. Darin schreibst du dann mit << auf den ostream, den du am Ende returnst. Oder besser, rufe in dem operator<< einfach apd.print(os) auf, nachdem du dem print das ostream-Argument hinzugefügt hast.

Da erhalte ich dann

error: ‘std::ostream& APD::operator<<(std::ostream&, const APD&)’ must take exactly one argument
ostream& APD::operator<<(ostream& out, const APD& apd);

Entferne ich den zweiten Parameter, ergibt das

error: no ‘std::ostream& APD::operator<<(std::ostream&)’ member function declared in class ‘APD’
ostream& APD::operator<<(ostream& out);

Dabei steht dort:

ostream& APD::operator<<(ostream& out) 							
	{     
		out << m_SN;
		return out;
	}

[wob]

Du musst die vorherigen Antworten auch mal lesen+verstehen! Oder kauf dir ein Buch!

Mit APD::operator<< ist dieser bei dir ja wieder ein MEMBER von APD geworden, du sollst operator<< aber AUSSERHALB von APD definieren, also ohne APD:: davor.

Ein letzter Versuch für ein Minimalbeispiel:

#include <iostream>

class APD {
  public:
    void print(std::ostream &os) const;

  private:
    int some_variable = 42;
};

void APD::print(std::ostream &os) const { 
    os << some_variable;
}

std::ostream &operator<<(std::ostream &os, const APD &apd) {
    apd.print(os);
    return os;
}

int main() {
    APD apd;
    std::cout << apd << '\n';
}

[Progressive]

wob schrieb:

Du musst die vorherigen Antworten auch mal lesen+verstehen! Oder kauf dir ein Buch!

Mit APD::operator<< ist dieser bei dir ja wieder ein MEMBER von APD geworden, du sollst operator<< aber AUSSERHALB von APD definieren, also ohne APD:: davor.

Ein letzter Versuch für ein Minimalbeispiel:

#include <iostream>

class APD {
  public:
    void print(std::ostream &os) const;

  private:
    int some_variable = 42;
};

void APD::print(std::ostream &os) const { 
    os << some_variable;
}

std::ostream &operator<<(std::ostream &os, const APD &apd) {
    apd.print(os);
    return os;
}

int main() {
    APD apd;
    std::cout << apd << '\n';
}

Geil, es funktioniert
Wenngleich ich es wieder mal nicht ganz nachvollziehen kann aber ich hoffe mal, das kommt mit der weiteren Anwendung. Danke!

[Progressive]

Wo definiert/deklariert man void APD::print(std::ostream &os) const und std::ostream &operator<<(std::ostream &os, const APD &apd) denn am besten, wenn nicht in main ? Ich würde das ja gerne in eine Klasse auslagern aber das widerspricht ja scheinbar dem Sinn
Oder ist eine zweite Klasse vlt. gar nicht so schlecht ? Also bezüglich der "Eleganz"

edit: Hab's.

[Th69]

in "APD.cpp"

[Progressive]

Th69 schrieb:

in "APD.cpp"

:p