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?

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

#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";
  }
}