Class member functions -> Verständnisproblem

kantaki

class Sales_item {
public:
    // operations on Sales_item objects
    double avg_price() const;
    bool same_isbn(const Sales_item &rhs) const
        { return isbn == rhs.isbn; }

private:
    std::string isbn;
    unsigned units_sold;
    double revenue;
};

Ich verstehe class member function leider immernoch nicht. Wahrscheinlich weil ich den zweck noch nicht verstanden habe.

ich lese immernoch primer, aber auch nach mehrfachem durchlesen verstehe ich es noch nicht zu 100% und ich möchte ungern einfach weiterlesen ohne es verstanden zu haben.

1. Welchen Vorteil haben Class member function gegenüber normalen functions ?

bool same_isbn(const Sales_item &rhs) const
        { return isbn == rhs.isbn; }

Okay kommen wir mal zum Kern meines Problems. Dieser Code vergleicht zwei strings (bzw objekte?) miteinander und gibt true oder false zurück.

Diese function wird mit

total.same_isbn(trans)

aufgerufen.

ich würde diesen teil als function wahrscheinlich so schreiben.

bool compare(const string &a, const string &b)
{ return a==b}

momentan weiß ich garnicht was

rhs.isbn

bedeutet.
also dieser ".".
Was ich mir denken kann ist das
trans, welcher ein string ist

const Sales_item &rhs

durch diesen aufruf ein objekt wird, der in dem isbn string, welcher in privat definiert ist, gespeichert wird.

Total

wird anscheinend auch in isbn gespeichert.
woher weiß der compiler das total in

string isbn

gespeichert werden soll ? was wäre wenn in privat mehrere strings deklariert worden wären. zb

std::string isbn, isbn2,isbn3,isbn4;

Ich weiß das sind so viele Fragen, ich erwarte garnicht eine Antwort. Mir würde ein link zu einem anderen Codebeispiel für Classmember functions ausreichen, bzw zu einem anfänger tutorial.

Habt ihr früher auch so viele Probleme mit diesem Kapitel gehabt oder geht es nur mir so ?

Danke

cooky451

class C // Eine Klasse C
{
public: // Public damit wir "wert" von außen ändern können
  int wert; // Jedes Objekt der Klasse C wird einen eigenen Wert haben
};

int main()
{
  C objekt; // Ein Objekt der Klasse "C"
  objekt.wert = 5; // Die Variable "wert" dieses Objekts hat jetzt den Wert 5
  C objekt2; // Ein neues Objekt
  objekt2.wert = 7; // Die Variable "wert" dieses Objekts hat jetzt den Wert 7
}

Hilft dir das irgendwie?

kantaki

cooky451 schrieb:

class C // Eine Klasse C
{
public: // Public damit wir "wert" von außen ändern können
  int wert; // Jedes Objekt der Klasse C wird einen eigenen Wert haben
};

int main()
{
  C objekt; // Ein Objekt der Klasse "C"
  objekt.wert = 5; // Die Variable "wert" dieses Objekts hat jetzt den Wert 5
  C objekt2; // Ein neues Objekt
  objekt2.wert = 7; // Die Variable "wert" dieses Objekts hat jetzt den Wert 7
}

Hilft dir das irgendwie?

okay dh mit einem objekt der klasse c kann ich per .wert auf die in public definierte variable zugreifen.

momentmal ich glaube ich verstehe den sinn.
beispiel:

class C // Eine Klasse C
{
public: // Public damit wir "wert" von außen ändern können
  int wert; // Jedes Objekt der Klasse C wird einen eigenen Wert haben
  string name;
  int alter;
};

int main()
{
  C Peter; // Ein Objekt der Klasse "C"
  Peter.koepfe= 5; 
  Peter.name = "Peter";
  Peter.alter = 22;

  c Tom;
  Tom.koepfe= 2; 
  Tom.name = "Tom";
  Tom.alter = 17;
}

dh die klasse ist sowas wie ein bauplan, wo man die variablen nur einmal deklarieren muss.
und ein objekt ist sowas wie ein.... puh... container in dem ich spezielle werte von variablen speichern kann ?

zum ersten mal sehe ich einen vorteil, man müsste dann nicht immer wieder die varibalen neu deklarieren, sondern kann einfach mit einem neuem objekt arbeiten.

okay mal schauen ob ich jetzt die class member function verstehe.

danke schonmal

wxSkip

Ein Objekt ist eine Variable vom Typ der Klasse. D.h. bei std::string str; ist std::string der Typ/die Klasse und str ein Objekt (eine Instanz der Klasse).
Memberfunktionen sind:
1. oft lesbarer als Funktionen, die das Objekt als Parameter nehmen (das compare-Beispiel ist IMHO ein schlechtes Beispiel dafür).
2. vererbbar
3. "polymorphisierbar", d.h. du kannst sie virtual deklarieren. (das kommt wahrscheinlich später in deinem Buch)

kantaki

okay ja bis auf eine kleine sache habe ich es verstanden !

Wo ist die verbindung von total zu isbn.

kleines beispiel aus dem buch primer :

sales_item item1;

cin >> item1;

cout << item1;

ich würde

cin >> item1.isbn

schreiben.

aber anscheinend ist es das selbe.

Kann mir das jemand erklären? Woher weiß der "computer" das die eingabe in einem string gespeichert werden muss ?

cooky451

kantaki schrieb:

zum ersten mal sehe ich einen vorteil, man müsste dann nicht immer wieder die varibalen neu deklarieren, sondern kann einfach mit einem neuem objekt arbeiten.

Soweit hast du den Vorteil einer Struktur verstanden. Strukturen (struct) sind nichts anderes als Klassen, mit dem Unterschied, dass alle Member automatisch "public" sind. (Bei Klassen sind sie automatisch "private", weshalb man für den Zugriff von außen ein "public:" davor schreiben muss.)

Bei der so genannten Objektorientieren Programmierung ist es üblich, einen Großteil (wenn nicht alle) Membervariablen vor dem "Nutzer" der Klasse zu verstecken. Die Schnittstelle soll hierbei möglichst klein gehalten werden, sodass schnell zu erkennen ist, wie man die Klasse zu nutzen hat. (Die Schnittstelle ist alles, was public, also von Außen erreichbar ist.)
Memberfunktionen können im Prinzip für alles, was das Objekt irgendwie verändert, oder mit einem anderen Objekt vergleicht verwendet werden.
Hier ein Beispiel:

#include <cctype> // std::isupper
#include <iostream>
#include <string>

class Human // Eine Klasse für einen Menschen
{
  std::string my_name; // Jeder Mensch braucht natürlich einen Namen. Das wäre was für einen Konstruktor, aber hier soll die Sache einfach gehalten werden.
public:
  bool setName(std::string name) // Die Funktion gibt zurück, ob das Setzten des Namens geklappt hat.
  {
    if (std::isupper(name[0])) // Nur "gültige" (eigentlich müsste man natürlich auf mehr prüfen) Namen werden zugelassen.
    {
      my_name = name;
      return true;
    }
    return false;
  }
  std::string getName() // Da die Variable "my_name" privat ist, brauchen wir eine Methode um den aktuellen Namen abfragen zu können.
  {
    return my_name;
  }
};

int main()
{
  Human child; // Ein neuer Mensch
  child.setName("Hans Peter"); // Mit dem Namen HP
  while (true)
  {
    std::cout << "Der aktuelle Name lautet: " << child.getName() << "\n";
    std::cout << "Bitte geben sie einen Namen ein: ";
    std::string name;
    std::getline(std::cin, name);
    if (child.setName(name))
      std::cout << "Name erfolgreich gesetzt.\n";
    else
      std::cout << "Name konnte nicht gesetzt werden.\n";
  }
}

Das mag so vielleicht nicht direkt einleuchten, schließlich könnte man auch einfach freie Funktionen dafür definieren. Aber bei größeren Beispielen werden die Vorteile schnell klar, auch von der Denkweise her. Angenommen du Programmierst ein Spiel. Da ist es wesentlich angenehmer zu schreiben "enemy.die();" statt "kill(enemy);". (Richtig einleuchtend wird's dann mit virtueller Vererbung, aber ich glaube das kommt bei dir erst noch.)

Als nächstes kommen dann Konstruktoren, Vererbung, static, friend?

wxSkip

Du überlädtst den >>-Operator für deine sales_item-Klasse. Das macht deinen aufrufenden Code unabhängig von weiteren Änderungen an der Klasse und es ist kürzer zu schreiben. Aber du kannst auch einfach mal ein paar Kapitel in deinem Buch weiterlesen und schauen, ob sich einiges von selbst erklärt.

kantaki

okay also suche ich nach überladen >> ? mal schauen ob ich was finde

danke

wxSkip

Kommt bestimmt noch in deinem Buch. Das wichtige ist, dass du jetzt mit << auch Objekte deiner Klasse ausgeben kannst.

kantaki

ach sieh einer an overloading functions ist direkt im nächsten abschnitt

wxSkip

Ooverloading operators kommt wahrscheinlich erst später.

Class member functions -&gt; Verständnisproblem

Class member functions -> Verständnisproblem