Wie gebe ich variable Anzahl an Zahlen am besten aus einer Klasse zurück?

Ich wollte mal fragen wie ihr folgendes Problem lösen würdet.
Ich hab eine Datei wo ich Serien(Fernsehserien) gespeichert habe die dazugehörigen Staffel und Folgen.
Das ganze habe ich jetzt auch eingelesen bekommen und das ganze ungefähr so gespeichert.

class Serie
  vector<Season> seasons;
class Season
  vector<Episode> episodes;
class Episode
  ...

Problem ist jetzt wie greife ich darauf zu?
Meine erste Überlegung war das man einfach einen Member in der Klasse Serie aufruft welcher einen Vector<Season>& zurückgibt und dann kann man einen Member in der Klasse Season aufrufen welchen einen Vector<Episode>& zurückgibt wobei mir das nicht wirklich gefällt.
Meine zweite Überlegung war das man alles über Member von Serie macht.

Serie breakingBad;
breakingBad.addEpisode(1,2,"Crystal");
std::cout << breakingBad.getEpisodeName(1,2);

Wobei die 1 für die Staffel und die 2 für die Folge steht.
Das Problem ist jetzt das nicht immer alle Folgen vorhanden also kann ich nicht einfach einen Member machen der mir ein int zurückgibt um die Anzahl der Staffeln zu erhalten sondern muss ich genau wissen welche Staffeln ich hab.
Dann hatte ich die Idee das man einen Vector<int> zurückgeben könnten mit den jeweiligen Staffeln Nummern aber irgendwie fand ich das nicht so gut.
Und als letztes ist mir noch sowas eingefallen.

class Serie{
public:
int getSeason();
...
private:
std::vector<Season> _seasons;
int currOutSeason;
}

int Serie::getSeason()
{
 if(_seasons.size() < 1)
  return -1;
 if( currOutSeason == -1 || currOutSeason => _season.size())
  currOutSeason = 0;
  return -2;

 return _seasons.at(currOutSeason++).getNr();
}

Hier sollte dann immer ein int zurückgegeben werden welcher der Staffel Nummer entspricht und beim nächsten Aufruf die nächste Staffel Nummer.
Welches mir auch nicht so wirklich gefällt welches würdet ihr nehmen oder was würdet ihr machen?

Soll ich die Frage nochmal stellen und diesmal besser formulieren?

hustbaer

Ich würde das Problem das du hast vermutlich ganz anders lösen. Aber dazu müsste man erstmal genauer wissen was du eigentlich machen willst. Also was das Programm eigentlich können soll.

Die konkrete Frage wie man am besten eine variable Anzahl von Zahlen zurückgibt kann ich dir aber beantworten:
Entweder du gibst einen Container zurück (und zwar so lange nichts dagegen spricht einen vector ), oder du machst aus der Funktion ein Template welches einen Output-Iterator als Parameter nimmt, wo es dann die Zahlen reinschreibt.

Also

// Variante 1

vector<int> GetFoos();
...
vector<int> foos = x.GetFoos();

// Variante 2
template <class OutIt>
void GetFoos(OutIt outputInterator);
...
vector<int> foos;
x.GetFoos(back_inserter(foos));

Vorteil von Variante 2 ist dass sich der Aufrufer aussuchen kann in welchem Container er die Werte bekommen will (bzw. allgemeiner: was er damit machen will - er muss sie ja nichtmal in einen Container stecken).
Wobei das eine Flexibilität ist die selten wirklich gebraucht wird.

Vorteil von Variante 1 ist dass sie einfacher ist (sowohl anzuwenden als auch zu implementieren).

Innerhalb des Objekts einen Iterationszustand zu speichern halte ich nicht für sinnvoll. Ich würde es eher so machen:

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

class Season
{
private:
  std::string name;
public:
  Season( const std::string& name ) : name{name} {} 
  std::string getName() const { return name;}
};

class Serie
{
private:
  std::vector<Season> seasons;

public:
  using Iter = std::vector<Season>::iterator;

  Iter begin() { return std::begin(seasons); }
  Iter end() { return std::end(seasons); }
  void addSeason( const Season& s ) { seasons.push_back(s); }
};

int main()
{
  Serie s;
  s.addSeason( { "Biene Maja" } );
  s.addSeason( { "Räuber Hotzenplotz" } );

  for( const auto& season : s ) {
    std::cerr << season.getName() << "\n";
  }
}

Ok,
also ich würdet es beide anders lösen. Die Idee von manni66 gefällt mir ganz gut. Ich werde erstmal damit versuchen hatte mich irgendwie drauf versteift das Interface nur durch die Klasse "Serie" zu realisieren.