[] Überladung

Ja das Problem ist eventuell das ich das Thema mit den Pointern noch nicht so ganz verstanden habe. Wir haben zuerst Ausführlich Java gelernt und da ist das alles anders.
das ist Meine Medium Klasse mit dem Get Kuerzel. muss ich da einen Pointer zurückgeben für die Anfrage?

string Medium::getKuerzel()
		{
			string tmp =  kuerzel;
			return tmp;
		}

getKuerzel() sieht unverdächtig aus.

IceKing201 schrieb:

Ja das Problem ist eventuell das ich das Thema mit den Pointern noch nicht so ganz verstanden habe.

:xmas1:

Wir koennen ja ein wenig debuggen.
Unten habe ich Deinen Code ein wenig verändert, um Dir bei der Beantwortung der Fragen a und c zu helfen.
Erstmal wird sichergestellt, dass die Funktion einen Pointer aus der Liste, oder NULL zurückgibt.
Dann habe ich noch eine Sicherung eingebaut, die schaut, ob wir es wirklich mit einem Zeiger zu tun haben.
Der Aufrufer müsste jetzt sowas schreiben

if(lit_liste["FurbleWurble"] != NULL)
// gefunden
else
// nicht gefunden

(Klar, warum dieser Tanz nötig ist?)

#include <cassert>

//...

Medium* Literaturliste :: operator[](const string& a)
{
    Medium* tmp = NULL;
    for(int i = 0; i < gr; i++)
    {
        assert(litListe[i] != NULL);
        if(litListe[i]->getKuerzel() == a)
        {
             tmp = litListe[i];
        }
    }
    return tmp;
}

danke für deine Hilfe.
Habe das ganze jetzt mal versucht. Aber es geht immer noch nicht der Fehler liegt wo anders
Muss ich mal weiter suchen

IceKing201 schrieb:

danke für deine Hilfe.
Habe das ganze jetzt mal versucht. Aber es geht immer noch nicht der Fehler liegt wo anders
Muss ich mal weiter suchen

Viel Erfolg!

IceKing201 schrieb:

gr ist die Übergebene Listengröße im Konstruktor

Okay. D.h. die Liste wird mit einer festen Anzahl von Objekten initialisiert. Richtig?
Kann ich den C'tor mal sehen? Und die Definition von Literaturliste?

Mein Verdacht ist, dass Du Pointer dereferenzierst, die gar nicht auf Medium-Objekte zeigen.

sry, meine freundin hat mich in twilight geschleppt ^^

#include "Literaturliste.h"
#include <iostream>
#include <string>
#include <cassert> 
using namespace std;

	Literaturliste::Literaturliste(){}

	Literaturliste::Literaturliste(int gr)
	{
		this->platz = 0;
		this->gr = gr;
		this->litListe = new Medium*[gr]; 
	}

	void Literaturliste::eintragen(Medium* z)
	{
	  if(platz < gr)
	  {
			litListe[platz] = z;
			platz = platz +1;
	  }
	  else
	  {
			cout << "liste voll" <<endl;
	  }	
	}

	Medium* Literaturliste :: operator[](const string& a)
	{
		Medium* tmp = NULL;
		for(int i = 0; i < gr; i++)
		{
			assert(litListe[i] != NULL);
			if(litListe[i]->getKuerzel() == a)
			{
				tmp = litListe[i];
			}
		}
		return tmp;
	}

	ostream& operator<< (ostream& out, const Literaturliste& a)
	{
		for(int i=0; i < a.gr ; i++)
		{
			out << a.litListe[i]->toString()<<endl<<endl;
		}
		return out;

	}

das ist die Literatur liste mit dem Komparator oben. Bin immer noch nicht drauf gekommen ich vermute ich greife irgendwo falsch auf das Feld oder so zu

Aha.

Hmm. Pointer sind in diesem Fall noch nicht mal das Hauptproblem.

Bis wohin darfst Du Deine Liste denn überhaupt durchsuchen, wenn Du Sie durchsuchst?
gr oder platz ? (Fangfrage!)

Und dann: warum überhaupt diese Geschichte mit Pointern?
Arrays und Pointer sind die größten Fehlerquellen hier im Forum, und Du hast beides im Listing. Da ist auf jeden Fall Frust und Überraschung vorprogrammiert...

bis auf platz, hast recht ansonsten laufe ich zu weit aber löst das problem nicht
und ja am verzweifeln bin ich langsam weil ich nicht drauf komme :-D, wie gesagt da mit den pointern steige ich noch nicht so ganz durch. fand es von anfang an auch etwas blöd das man mit java angefangen hat und c++ jetzt mehr oder weniger im Schnelldurchgang macht. aber hilft jetzt alles nichts.
wie kann ich es denn am besten vermeiden?

IceKing201 schrieb:

wie kann ich es denn am besten vermeiden?

1. Du ersetzt die Pointer durch Referenzen, bzw. normale Objekte:

class Literaturliste{
public:
  Literaturliste::Literaturliste(int);
  void eintragen(const Medium&);
  Medium& operator[](const string&);
  friend ostream& operator<< (ostream&, const Literaturliste&);
private:
  int platz;
  int gr;
  Medium* litListe;  // Pointer auf array von Medium
};

Das erfordert ein paar Anpassungen hier und da, macht aber alles schon viel robuster.
Dann:
2. Du ersetzt auch noch das Array durch einen Container aus der STL. z.B. std::vector .

class Literaturliste{
public:
  Literaturliste::Literaturliste(int);
  void eintragen(const Medium&);
  Medium& operator[](const string&);
  friend ostream& operator<< (ostream&, const Literaturliste&);
private:
  int platz;
  int gr;
  std::vector<Medium> litListe;
};

Das ist überschaubar viel Aufwand. Und spätestens mit Schritt 2 unterscheidet sich das nicht mehr viel von der Implementierung von Java.
Allerdings musst Du Dich mit dem STL Container vertraut machen...

Ach herje...
Ich lese gerade in Deinem Eingangsposting:

IceKing201 schrieb:

wir haben Eine Klasse Medium, von dieser sind einige Medien abgeleitet.
In der Klasse Literaturliste wird eine Liste mit verscheidenen Medien erstellt.

Damit lässt sich die Aufgabe nicht ganz so realisieren, wie ich mir das vorgestellt hatte...

Jetzt ist aber erstmal Feierabend für mich...;)

also es geht... hab die ganze zeit an der falschen stelle gesucht.
Das Problem war das er bei

cout << "Literaturliste:" << endl << meineLiteraturliste;

bei der Überladung des << OP auch bis zu gr, und nicht nur bis platz gesucht hat.
deswegen ist er gar nicht erst zum[] bekommen....
total dummer Fehler tut mir leid.
Aber dennoch danke für deine Hilfe. Hat mir auch so weiter geholfen in der ganzen Problematik :-).
Deinen letzten Tipp werde ich ersuchen auch noch umzusetzen danke!