ich bin noch nicht so lange dabei und beschäftige mich gerade mit Pointern. Nun habe ich folgendes Beispiel:

#include <iostream>
using namespace std;

class Basisklasse {
  private: int a;
           int b;
  public: Basisklasse();
          void tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2);
};

Basisklasse::Basisklasse() {}

void tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2) {
  // Hier wird was Tolles gemacht
}

int main() {
  int wert1 = 1;
  int wert2 = 2;

  // *** Hier kommt nun das Problem ***
  tuWas(wert1, wert2);
}

Könnt ihr mir an der im Quelltext markierten Stelle sagen, wo hier mein Denkfehler liegt?

Ich möchte die Werte wert1 und wert2 an die Methode tuWas() übergeben. Allerdings sind in der Methode ja Zeiger auf die Basisklasse als Übergabewerte hinterlegt. Wie kann ich nun die beiden int-Werte an die Methode tuWas() übergeben? Klar, ich könnte schreiben:

void tuWas(int x, int y) {}

und die Methode entsprechend anders definieren, aber ich möchte doch schon gerne die Zeiger benutzen.

Ich bekomme dort immer den Fehler "Invalid conversion from 'int' to 'Basisklasse*', was ja im Grunde auch Sinn macht. Allerdings weiß ich nicht, wie ich das anders übergeben soll...

Und sorry für die eventuell noch nicht ganz korrekten Formulierungen... Danke im Voraus!!!

aber ich möchte doch schon gerne die Zeiger benutzen.

Ich würde sagen, das ist der Denkfehler. Überhaupt ist der ganze Sinn hinter Deinem Programm strittig.

Die Methode erwartet zwei Zeiger auf eine Basisklasse. Diese repräsentiert zwei Zahlen. Wenn Du zwei Zahlen hast, macht es logisch erstmal nur Sinn, dass das zu einer einzigen Basisklasse umgebaut wird.

Als nächstes ist tuWas eine Methode einer Klasse, d.h. Du brauchst von der Klasse ein Objekt, an welchem Du die Methode aufrufen kannst. Ich glaube, Du hast die Grundgedanken einer Klasse noch nicht verstanden. Für den Fall: Lies das Kapitel im Buch bitte nochmal nach (oder schmeiß das Buch weg, wenn es von Jürgen Wolf ist). Falls Du tatsächlich eine freie Funktion möchtest, die zufällig so heißt wie die Methode, ist das natürlich etwas anderes, aber für die Leser irritierend.

(oder schmeiß das Buch weg, wenn es von Jürgen Wolf ist).

Eisflamme schrieb:

(oder schmeiß das Buch weg, wenn es von Jürgen Wolf ist).

Das Buch, das ich benutze, ist von Helmut Erlenkötter

Eisflamme schrieb:

Überhaupt ist der ganze Sinn hinter Deinem Programm strittig.

Das ist ja auch nur der Teil eines Programms.

Hier der geänderte Quelltext:

#include <iostream>
using namespace std;

class Basisklasse {
  private: int a;
           int b;
  public:  int wert1;
           int wert2;
  public: Basisklasse();
          void tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2);
};

Basisklasse::Basisklasse() {
  wert1 = 1;
  wert2 = 2;
}

void Basisklasse::tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2) {
  // Hier wird was Tolles gemacht
}

int main() {

   Basisklasse b;

  // *** Hier kommt nun das Problem ***
  b.tuWas(b.wert1, b.wert2);
}

Fehler kommt nach wie vor, aber da lese ich erstmal noch mal das Kapitel über Pointer und Klassen.

#include <iostream>

using namespace std;

class Basisklasse
{
private:
    int a;
    int b; // Attribute sollten in Klassen auch immer private sein, aber gut
public:
    Basisklasse(int a, int b) : a(a), b(b) {}
    void tuWas();
};

void Basisklasse::tuWas()
{
    cout << "a ist " << a << " und b ist " << b << ".";
}

int main()
{
    Basisklasse einObjekt(10, 20);
    einObjekt.tuWas();
    return 0;
}

Ok, so, wie du es geschrieben hast, leuchtet es mir auch ein und macht ja auch Sinn. Mal kurz zum Hintergrund: Das von mir angesprochene Beispiel ist für eine Programmieraufgabe (natürlich nicht in so einfacher Form, das war nur, damit das Problem klar wird), und da wird gefordert, dass die Pointer genutzt werden (auch wenn es noch so merkwürdig und unlogisch ist).

nein es ist nicht unlogisch, für lernzwecke ist sowas ja vollkommen ok. aber du versuchst eine kuh dahin zu geben wo ein auto erwartet wird(int <---> zeiger auf eine klasse)

Basisklasse *pB;
pB = &b.wert1;

und b.wert1 im Konstruktor den Wert 1 zugewiesen bekommt, dann weise ich dem Zeiger pB doch im obigen Beispiel nur die Adresse von b.wert1 zu oder nicht? Und diese müsste ich doch auch an einen andere Zeiger übergeben können.

Du hast es scheinbar immer noch nicht verstanden.
Deine Typen passen doch nicht.
pB ist ein Zeiger auf Basisklasse, &b.wert1 liefert dir einen Zeiger auf int. Die kannst du nicht zuweisen, die Typen müssen schon stimmen.

Ja, dass die Typen nicht passen, habe ich nun verstanden, steht ja auch in der Fehlermeldung. Was ich aber nicht verstanden habe ist, wie ich das nun gelöst bekomme, den Wert an den Zeiger der Basisklasse zu übergeben. Dies ist ja ohne Weiteres nicht möglich, bedingt durch die angesprochene Typeninkompatibilität.

Ja, dass die Typen nicht passen, habe ich nun verstanden, steht ja auch in der Fehlermeldung. Was ich aber nicht verstanden habe ist, wie ich das nun gelöst bekomme,...

In dem du auch etwas entsprechendes übergibst;

Basisklasse b;
Basisklasse *pB;
pB = &b.wert1; // Unsinn
pB = &b; // Besser
// Über den Zeiger kannst du ja auf die Werte zugreifen:
int wert = pB->wert1;

#include <iostream>
using namespace std;

class Basisklasse {
  public: int wert1;
          int wert2;
  public:  Basisklasse();
           void tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2);
};

Basisklasse::Basisklasse() {
  wert1 = 1;
  wert2 = 2;
}

void Basisklasse::tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2) {

  Basisklasse bX;
  Basisklasse bY;

  pBasis1 = &bX;
  pBasis2 = &bY;

  int a = pBasis1->wert1;
  int b = pBasis2->wert2;

  cout << a<< " + " << b<< endl;

}

int main() {

  Basisklasse b;

  Basisklasse *pWert1;
  Basisklasse *pWert2;

  pWert1->wert1;
  pWert2->wert2;

  b.tuWas(pWert1,pWert2);

}

Ansonsten vielen Dank für die schnelle Hilfe!!!!!!!!

Soo, hab das Ganze nun so gelöst, und so funktioniert es auch. Gibt es noch Anregungen eurerseits zu dem folgenden Quellcode?

Das er Fehlerhaft ist, und eigentlich gnadenlos abschmieren sollte. Zudem scheinst du Zeiger nicht verstanden zu haben, und unnötige Kopien anzulegen.

Du übergibst (uninitialisiere) Zeiger, dereferenzierst diese, und weist das Ergebnis lokalen Variablen zu.

Ich glaube eher du willst so etwas (Auch wenn es weiterhin unsinnig ist):

void Basisklasse::tuWas(
  Basisklasse *p)
{
  // Da Zeiger können null sein können, auch behandeln.
  if(!p)
    return;
  // Über den Zeiger die Werte ausgeben
  cout << p->a << " + " << p->b<< endl;
}

int main()
{
  Basisklasse b;
  b.tuWas(&b);
}

Das er Fehlerhaft ist, und eigentlich gnadenlos abschmieren sollte. Zudem scheinst du Zeiger nicht verstanden zu haben, und unnötige Kopien anzulegen.

Du übergibst (uninitialisiere) Zeiger, dereferenzierst diese, und weist das Ergebnis lokalen Variablen zu.

Ich glaube eher du willst so etwas (Auch wenn es weiterhin unsinnig ist):

Eigentlich will ich glaube ich mehr sowas:

#include <iostream>
using namespace std;

class Basisklasse {
  public: int wert1;
          int wert2;
  public:  Basisklasse();
           void tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2);
};

Basisklasse::Basisklasse() {
  wert1 = 1;
  wert2 = 2;
}

void Basisklasse::tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2) {

  int a = pBasis1->wert1;
  int b = pBasis2->wert2; 

  cout << a << " + " << b << endl;

}

int main() {

  Basisklasse b;

  b.tuWas(&b,&b);

}

Aber wahrscheinlich hast du recht, das Prinzip der Zeiger muss ich echt noch ein paar mal lesen... und dann noch mal lesen ... und dann noch mal lesen.

Eigentlich will ich glaube ich mehr sowas:

//...
void Basisklasse::tuWas(Basisklasse *pBasis1, Basisklasse *pBasis2) {  
  int a = pBasis1->wert1;
  int b = pBasis2->wert2; 

  cout << a << " + " << b << endl;
}
//...

Auch hier hast du das Problem das Zeiger den Wert NULL/0 annehmen können (womit man Zeiger, denen man nicht direkt einen gültigen Wert zuweist, immer initialisieren sollte). Wenn ich deine Methode wie folgt verwende, solltest du eine Zugriffsverletzung bekommen:

int main() {
  Basisklasse b;
  b.tuWas(0,0);
}

Davon abgesehen wundert es mich, wie verschwenderisch du mit Leerzeilen umgehst, aber anderseits bei der Klammersetzung die kompakte Schreibweise vorziehst (was reine Geschmackssache ist, aber man einheitlich machen sollte). Für ein Forum solltest du zumindest die Leerzeilen auf die sinnvollen reduzieren (Damit andere den Code besser überblicken können).

Also bei Zeigern gibt es nicht viel zu verstehen. Die speichern einfach nur eine Adresse auf irgendeine andere Variable (wobei ein Klassenobjekt auch eine Variable ist). Prinzipiell haben Adressen ja das gleiche Format, weswegen man theoretisch überlegen könnte einfach nur einen speziellen Typ "Zeiger" zu nutzen.

Doch in C++ gibt es dann auch noch Typsicherheit bei so was. Das bedeutet, Du gibst auch an, auf was ein Zeiger zeigen muss.

TypAufDenDerZeigerZeigt* zeiger;

Jetzt kannst Du in zeiger Adressen von Objekten speichern mit der Einschränkung, dass diese Objekte vom Typ TypAufDenDerZeigerZeigt sein muss.

Zeiger nutzt man in C++ in deinem Zusammenhang (gibt noch andere), um call by reference umzusetzen. Würdest Du dein Objekt ohne Zeiger übergeben, würde nämlich call by value umgesetzt werden, d.h. das gesamte Objekte würde kopiert werden. Für Deine Anzeige macht das praktisch keinen Unterschied in der Ausgabe, aber die Kopie ist aufwendiger zu sagen "Ich habe die Baupläne für das Objekt mitgebracht, ich baue es Mal kurz auf" als nur kurz zu sagen "Hey, das Objekt, das ich meine, steht da hinten".

Der große Unterschied ist sonst, dass Du bei Zeigerübergabe beim Ändern von Werten der Objekte auch das Objekt in der main änderst (ist ja das gleiche, wir haben ja nur die Position mitegeteilt). Wenn Du es call by value übergibst, ist das ein neues Objekt. Wenn Du z.B. einen Baum kopierst und in Deiner Funktion einen Ast absägst, ist der Baum in der main unversehrt.

Und wenn jetzt eine Funktion erwartet, dass Du ihr "zeigst", wo ein Baum (Basisklasse) steht, dann kannst Du ihr nicht sagen, wo ein Ast (int) ist, denn das will die Funktion nicht haben. Sie ruft die Polizei (Compiler) und lässt den Positions-Angeber (Programmierer, hier OP) standrechtlich erschießen.

Daher: Immer auf die Typen achten, auch bei Zeigern!

Danke für ausführliche Erklärung. Ich werde nun mal probieren, das Ganze auf meine Aufgabe umzusetzen.