ich habe 3 Datenklassen (Book, CD, DVD) in denen halt das übliche stattfindet...Konstruktor, Destruktor, getter & setter halt..

Es gibt jeweils getTitle() und getID() welche den Titel und die Ausleihnummer(ID) returned.

Jetzt habe ich eine Containerklasse (Library) in der ich verschiedene Objekte dieser Klassen erstelle und in einen vector<Library *> packe.

vector<Library *> myLibVec;

	Book myBook1("A Thousand Splendid Suns", 3, "Khaled Hosseini", "Bloomsbury Publishing", 2008);
	Book myBook2("Harry Potter and the Deathly Hallows", 4, "J.K.Rowling", "Bloomsbury Publishing", 2007);

	CD myCD1("A Certain Trigger", 5, "Maximo Park", 14);
	CD myCD2("WE DON'T NEED TO WHISPER", 6, "Angels & Airwaves", 11);

	DVD myDVD1("Heat", 1, 16, 171);
	DVD myDVD2("Unknown Identity", 2, 12, 114);

	Library *myLib;

	myLib = new Library(myBook1);
	myLibVec.push_back(myLib);

	myLib = new Library(myBook2);
	myLibVec.push_back(myLib);

	myLib = new Library(myCD1);
	myLibVec.push_back(myLib);

	myLib = new Library(myCD2);
	myLibVec.push_back(myLib);

	myLib = new Library(myDVD1);
	myLibVec.push_back(myLib);

	myLib = new Library(myDVD2);
	myLibVec.push_back(myLib);	

	vector<Library *>::iterator it;

	for(it = myLibVec.begin(); it != myLibVec.end(); it++) {

		(*it)->outputTitle(myLibVec); // Knackpunkt

	}

Wenn ich die Funktion outputTitle aufrufe, sollten eigentlich alle Titel und IDs, die im vector gespeichert sind, ausgegeben werden - das klappt noch nicht^^

void Library::outputTitle(vector<Library *> myLibV) {

	for(int i = 0; i < myLibV.size(); i++) {

		cout << *myLibV.at(i) << endl;

	}

}

ich hatte auch den Operator << überladen, damit ich das wie einen built-in-Datentyp verwenden kann, nur bin ich mir nicht sicher, wie genau ich ihn überladen soll, damit mein Vorhaben gelingt...

ostream& operator << (std::ostream& outStream, const Library& library) {

	outStream << "// Hier Inhalt rein^^" << endl;

	return outStream;

}

Kann mir da jemand weiterhelfen?

void Library::outputTitle(vector<Library *> myLibV) {

        cout << *myLibV << endl;

}

Ich übergebe den Vector, den ich iteriere, weil ich sonst nicht auf den Vector zugreifen kann in der outputTitle Funktion - wenns da eine andere Lösung gibt, sag ich nicht nein

Nochmal:

Ich habe Objekte von meinen verschiedenen Datenklassen, die ich in meinen Vector packe, allerdings als Datentyp meiner Klasse Library.

Jetzt möchte ich durch den vector<Library> iterieren und alle Titel und IDs, die dabei gefunden werden, ausgeben - das erweist sich als problematisch, da ich nicht mehr auf meine Funktion getTitle() etc. von den 3 Datenklassen zugreifen kann.

Noch ein paar Anmerkungen:

ich habe 3 Datenklassen (Book, CD, DVD) in denen halt das übliche stattfindet...Konstruktor, Destruktor, getter & setter halt..

Destruktor ist bei Datenklassen eigentlich nicht üblich. getter, setter nur, sofern es wirklich reine Datenklassen sind. Meistens erwartet man von seinen Klassen, dass sie auch was tun.

Library *myLib;

    myLib = new Library(myBook1);
    myLibVec.push_back(myLib);

1. Warum immer über die Zwischenstation myLib?
2. Warum überhaupt new?
3. Warum überhaupt Zeiger?

Dein Code sieht ein bisschen so aus, als wolltest du Polymorphie versuchen, hattest es aber nicht verstanden.

Das macht man auch ne Spur anders

class Entity {
public:
	virtual ~Entity() {}

	virtual std::string const& getTitle() const=0;
	virtual unsigned getID() const=0;
};

class Book : public Entity {
private
	std::string title;
	unsigned id;

public:
	Book(std::string const& title, unsigned id) : title(title), id(id)
	{}

	std::string getTitle() const { return title; }
	unsigned getID() const { return id; }
};

class Movie : public Entity {
private
	std::string title;
	unsigned id;

public:
	Movie(std::string const& title, unsigned id) : title(title), id(id)
	{}

	std::string getTitle() const { return title; }
	unsigned getID() const { return id; }
};

std::vector<Entity*> library;
//besser wäre: boost::ptr_vector

library.push_back(new Book(...));

for(it=library.begin(); it!=library.end(); ++it) {
   std::cout<< (*it)->getTitle() << "\n";
}

title und id könnten natürlich direkt von Entity verwaltet werden. Jedenfalls bietet Entity die Schnittstelle an die brauchst um mit Books und Movies umgehen zu können.

Deine Klasse Library ist unnötig und falsch.

Nur hab ich jetzt ein Problem (wahrscheinlich was ganz einfaches -.-)

meine Library.h sieht jetzt so aus:

#include <iostream>
#include <vector>
#include <string>

using std::ostream;

using namespace std;

#pragma once

class Library {

public:

	Library();
	virtual ~Library();

	virtual string const& getTitle() const;
        virtual double getID() const; 

	void add();
	int getCount(vector<Library *>) const;
	void outputTitle(vector<Library *>);
	void searchOutput(const string &, vector<Library *>);

};

class Book : public Library {

private:
	string title;
	double ID;
	string author;
	string publisher;
	int yearOfPublication;

public:

	Book();
	Book(string, double, string, string, int);
	~Book();

	string getTitle() const; // Hier Fehlermeldung -> siehe Unten
	double getID() const;
	string getAuthor() const;
	string getPublisher() const;
	int getYearOfPublication() const;

	void setTitle(string);
	void setID(double);
	void setAuthor(string);
	void setPublisher(string);
	void setYearOfPublication(int);

};

class DVD : public Library {

private:

	string title;
	double ID;
	int fsk;
	int duration;

public:

	DVD();
	DVD(string, double, int, int);
	virtual ~DVD();

	string getTitle() const;
	double getID() const;
	int getFsk() const;
	int getDuration() const;

	void setTitle(string);
	void setID(double);
	void setFsk(int);
	void setDuration(int);

};

class CD : public Library {

private:

	string title;
	double ID;
	string interpreter;
	int numberOfTitles;

public:

	CD();
	CD(string, double, string, int);
	virtual ~CD();

	string getTitle() const;
	double getID() const;
	string getInterpreter() const;
	int getNumberOfTitles() const;

	void setTitle(string);
	void setID(double);
	void setInterpreter(string);
	void setNumberOfTitles(int);

};

	ostream& operator << (std::ostream& outStream, const CD& CD);

	ostream& operator << (std::ostream& outStream, const Book& Book);

	ostream& operator << (std::ostream& outStream, const DVD& DVD);

	ostream& operator << (std::ostream& outStream, const Library& Library);

	void showLibrary();

In der Klasse Book beim getter für den Titel meckert er jetzt rum (hab die Stelle im Code mit nem Kommentar markiert) - hier mal der Text, der mir gezeigt wird:
"
std::string Book::getTitle() const

Error: Der Rückgabetyp ist nicht identisch mit dem Rückgabetyp ""const std::string&"" der überschriebenen virtuellen Funktion "Funktion "Library::getTitle"" oder ein Covariant-Rückgabetyp davon."

Was soll mir das sagen?^^

Edit:

Wieso mach ich nicht einfach:

string const& getTitle() const;

... sorry für den dummen Post^^

Bzw. eine Frage hab ich doch noch:

ich hab ja jetzt die beiden

virtual string const& getTitle() const;
virtual double getID() const;

was schreib ich dann in der .cpp Datei?

die Signatur in der abgeleiteten Klasse hat sich geändert (von 'string const& getTitle() const' zu 'string getTitle() const', also das erste const).

2. Was meinst du? Das?

string const& Book::getTitle() const
{
...
}