cout << endl << (*meineLiteraturliste["Pa72"]).toString() << endl;

in der .h habe ich den Operator so überladen

Medium* operator[](const string& a);

und in der cpp so

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

gr ist die Übergebene Listengröße im Konstruktor

Ich bekomme aber immer Unbehandelte Ausnahme wegen einer Zugriffsverletzung beim Lesen an Position. Mir sagt dieser Fehler rein gar nichts. Hatte ich auch noch nie und im Moment komme ich nicht drauf.
es öffnet sich auch noch eine datei mit dem namen xstring. und dort wird auf

size_type size() const _NOEXCEPT
{	// return length of sequence
	return (this->_Mysize);
}

verwiesen

kann mir vll. jemand weiterhelfen?

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

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

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.

#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

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...

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...

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...;)

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!