2 verschiedene Rückgabetypen per Template

SeppJ

Was ist denn die Gemeinsamkeit von Tracks und Playlists? Dass man sie abspielen kann? Das klingt irgendwie nach Wurstbrot erbt von Supermarkt, weil beide was mit "kaufen" zu tun haben. Klingt eher so, als bestünde eine Playlist aus Tracks.

Biolunar

SeppJ schrieb:

Klingt eher so, als bestünde eine Playlist aus Tracks.

Genau das habe ich auch gedacht. In dem Fall bietet sich doch an den Track als Playlist mit nur einem Track (sich selbst) zurück zugeben.

Th69

Dann würde sich das Composite-pattern anbieten.

Ja eine Playlist enthält auch einen std::vector<Playlist> , jedoch enthält die Klasse Playlist eigene Funktionen, wie zB. die anzahl der Tracks usw. Tracks können jedoch auch alleine sein, heißt also dass Tracks zwar in einer Playlist vorhanden sind, jedoch auch alleine "stehen".

SeppJ

heyo schrieb:

Ja eine Playlist enthält auch einen std::vector<Playlist> , jedoch enthält die Klasse Playlist eigene Funktionen, wie zB. die anzahl der Tracks usw. Tracks können jedoch auch alleine sein, heißt also dass Tracks zwar in einer Playlist vorhanden sind, jedoch auch alleine "stehen".

Und wo kommt in dieser Beschreibung eine gemeinsame Basis von Track und Playlist vor?

hustbaer

@heyo
D.h. du willst Playlisten aus Tracks und weiteren "Unterplaylisten" zusammensetzen können?
Also wie Verzeichnisse Files und weitere Unterverzeichnisse enthalten können?

In dem Fall könnte man z.B. machen...
Variante 1:

class PlaylistItem
    abstrakt

class Playlist : PlaylistItem
    ptr_vector<PlaylistItem> items;

class Track : PlaylistItem
    ...

Analogie zu nem File-System wäre:
PlaylistItem entspricht FileSystemEntity
Playlist entspricht Directory
Track entspricht File

Variante 2 (IMO sauberer, da der Track so nix von dem Playlisten-Gedöns wissen muss):

class Playlist
    abstrakt

class SingleTrackPlaylist : Playlist
    Track track;

class CompositePlaylist : Playlist
    ptr_vector<Playlist> items;

Analogie zu nem File-System wäre:
Playlist entspricht FileSystemEntity
SingleTrackPlaylist entspricht File
CompositePlaylist entspricht Directory
Track entspricht dem Inhalt des Files (BLOB)

hustbaer schrieb:

class Playlist
    abstrakt

class SingleTrackPlaylist : Playlist
    Track track;

class CompositePlaylist : Playlist
    ptr_vector<Playlist> items;

Und zum Traversieren dann das Visitor-Pattern benutzen. (Kein dynamic_cast!)

Weil Track und Plalist zB beide ein Artwork, Länge, Titel usw. haben.

Ups, sorry hab die neuen Beiträge nicht gesehen.
Werde heute Abend noch Antworten.

SeppJ

heyo schrieb:

Weil Track und Plalist zB beide ein Artwork, Länge, Titel usw. haben.

Dann haben sie eine gemeinsame Basis, aber das heißt noch lange nicht, dass diese Objekte auch gemeinsam über Basisklassenzeiger verwaltet werden müssen. Es sei denn, deine Playlists haben Eigenschaften, wie von hustbaer beschrieben, dann kannst du auch eine seiner dort vorgeschlagenen Lösungen nehmen.

Wenn aber beispielsweise Playlists nur aus Tracks bestehen können (im Gegensatz zu Tracks und Unterplaylists) und dein Playerhauptprogramm bloß mit Playlists arbeitet, dann kommst du nie in die Verlegenheit, nicht zu wissen, welche Art von Objekt vorliegt. Weil dann dein Hauptprogramm einen vector<Playlist> (oder sonstigen Container) hat und deine Playlists einen vector<Track>. Trotzdem kannst du diese Objekte dann auch in Funktionen nutzen, die auf der Basisklasse arbeiten, denn jeder Track und jede Playlist ist dann schließlich auch eine gültige Instanz der Basisklasse.

hustbaer schrieb:

D.h. du willst Playlisten aus Tracks und weiteren "Unterplaylisten" zusammensetzen können?
Also wie Verzeichnisse Files und weitere Unterverzeichnisse enthalten können?

Nein, Unterplaylisten existieren nicht.

Wenn ich euch richtig verstanden habe, dann meint ihr einfach Playlist als Base-Klasse für Track zu verwenden?

Swordfish

eher:

#include <vector>

struct playable { void something() {} };
class track : public playable {};
class playlist : public playable { std::vector< track > tracks; };

void bar( playable &thing ) { thing.something(); }

int main()
{
	std::vector< playlist > playlists( 3 );
	track foo;

	playlists[ 0 ].something();
	foo.something();

	bar( playlists[ 0 ] );
	bar( foo );
}

?

hustbaer

heyo schrieb:

Wenn ich euch richtig verstanden habe, dann meint ihr einfach Playlist als Base-Klasse für Track zu verwenden?

NEIN!
Wie kann man das was SeppJ geschrieben hat nur so falsch verstehen? *facepalm*

Du sollst eine Klasse machen wo du reinpackst was gemeinsam ist, und dann sowohl Playlist als auch Track von dieser gemeinsamen Basisklasse ableiten.

@hustbare & @Swordfish
So hab ich es ja bereits. Nur dass ich bspw. eine Funktion get() möchte, welche je nachdem ob das Objekt der HTTP-Request (zB. 16 Objekte werden angefordert, welche dann Objekt für Objekt ausgelesen werden und dann in eine Klasse gefüllt werden) eine Playlist oder ein Track ist.

Nochmal was ich erreichen möchte, denn wir sind da glaub ich ein bisschen abgekommen:

class Base {
    public:
		QPixmap getArtwork(void);
		std::string getTitle(void);
		std::string getUsername(void);
};

class Track : public Base {
    public:
        std::string getStreamURL(void);
};

class Playlist : public Base {
    public:
        int getTrackCount(void);
		std::vector<Track> tracks;
};

class Dashboard {
	public:	
		bool isTrack(void);
		Track track;
		Playlist playlist;

		//Pseudo - Ziel
		Track/Playlist get(void) {
			if(isTrack())
				return Track;
			else
				return Playlist;
		}
};

Sry, falscher Code (könnte ein Mod bitte diese zwei zusammenführen? :)):

Edit v. Arcoth: Oben reineditiert.

hustbaer

Wo ist jetzt das Problem?
Du kannst z.B. entweder boost::variante<Track, Playlist> als Returntyp ^[*] verwenden oder sowas wie std::unique_ptr<Base> .

Dass eine Funktion nur einen Returntyp haben kann ist dir wohl hoffentlich klar ...?

*: Natürlich kannst du mit einem der beiden genannten Typen auch deine drei Member ersetzen.

hustbaer schrieb:

Wo ist jetzt das Problem?
Du kannst z.B. entweder boost::variante<Track, Playlist> als Returntyp ^[*] verwenden oder sowas wie std::unique_ptr<Base> .

Könntest Du mir da bitte mal ein Beispiel schreiben oder den Code unten verbessern? Denn ich bekomme das so nicht hin.

hustbaer schrieb:

Dass eine Funktion nur einen Returntyp haben kann ist dir wohl hoffentlich klar ...?

Ist mir klar.

Hier mal der Code:

class Dashboard {
	public:	
		bool isTrack(void) {
			return true; //Zwecksmäßig
		}
		Track track;
		Playlist playlist;
		boost::variant<Track, Playlist> dat;

		Dashboard() {
			if(isTrack())
				dat = track;
			else
				dat = playlist;
		}

		class visitor1 : public boost::static_visitor<Track> {
			public:
				Track operator()(Track t) {
					return t;
				}

		};

		class visitor2 : public boost::static_visitor<Playlist> {
			public:
				Playlist operator()(Playlist p) {
					return p;
				}
		};

		class visitor3 : public boost::static_visitor<Track>, boost::static_visitor<Playlist> {
			public:
				Track operator()(Track t) {
					return t;
				}
				Playlist operator()(Playlist p) {
					return p;
				}
		};

get() sieht so aus:

boost::variant<Track, Playlist> get(void) {
	if(isTrack())
		return dat.apply_visitor(visitor1());
	else
		return dat.apply_visitor(visitor2());
}

hustbaer

@heyo
Ich weiss ja immer noch nicht was du eigentlich hinbekommen willst.
Du schreibst "hier mal der Code". Schön. Und?
Wobei genau möchtest du Hilfe?

Du hattest ja geschrieben ich solle boost::variant oder std::unique_ptr verwenden. Nun habe ich es mit boost::variant versucht, jedoch weiß ich nicht mehr weiter.
Den Code den ich gepostet habe lässt sich fehlerfrei kompilieren, jedoch funktioniert das nicht so wie in den boost Docs.

Wie es in den Docs steht:

boost::variant< int, std::string > u("hello world");
std::cout << u; // output: hello world

Wie ich es versucht habe:

boost::variant<Track, Playlist> get(void) {
    if(isTrack())
        return dat.apply_visitor(visitor1());
    else
        return dat.apply_visitor(visitor2());
}

Dashboard ds;
ds.get().getStreamURL(); //Kein member vorhanden
Track t1 = boost::get<Track>(ds.get()); //Funktioniert; ist jedoch nicht das Ziel

Nun, jetzt frage ich mich warum das Beispiel von den Docs einwandfrei funktioniert... Wegen der Bitverschiebung?