#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>

void removeSemicolon(std::string &str){
	std::size_t pos = str.find(";");
	if(pos != std::string::npos)
		str.erase(str.begin() + pos, str.end());
}

bool isFinal(std::string str){ 
	return str.find("/final") != std::string::npos; 
}

bool isNotFinal(std::string str){ 
	return str.find("/final") == std::string::npos; 
}

bool isEmptyLine(std::string str){
	return str.empty();
}

int main(){
	std::ifstream in("file", std::ifstream::in);

	std::vector<std::string> lines;
	while(in){
		std::string line;
		std::getline(in, line);
		lines.push_back(line);
	}
	in.close();

	std::vector<std::string> finals(lines.size());
	lines.erase(std::remove_if(lines.begin(), lines.end(), isEmptyLine), lines.end());
	std::remove_copy_if(lines.begin(), lines.end(), finals.begin(), isNotFinal);
	lines.erase(std::remove_if(lines.begin(), lines.end(), isFinal), lines.end());
	finals.erase(std::remove_if(finals.begin(), finals.end(), isEmptyLine), finals.end());
	for(std::string &out : finals){
		removeSemicolon(out);
		//std::size_t pos = out.find("/final");
		//if(pos != std::string::npos)
		//	out.erase(out.begin() + pos, out.begin() + (pos + 6));

		std::cout << out << std::endl;
	}
	return 0;
}

Hi,
mein Ziel war es eine Datei einzulesen und alle Zeilen mit "/final" in einen Vector und alle anderen in einen anderen zu packen. Ich frag mich bloß ob das nicht besser geht. Sollte ich Funktionen wie isFinal lieber als Lambda machen?
Ich muss die Zeilen noch weiter bearbeiten dafür musste ich überprüfen ob ein Zeichen eine Zahl ist oder nicht. Wie macht man das am besten?

Was ist es denn wirklich, was Du einlesen willst?
Wohl keine strings , mit oder ohne "/final", sondern irgendwelche Objekte, die zeilenweise in einer Datei stehen. In diesem Fall würde ich auch direkt solche Objekte lesen und nicht strings .

game of throne s4e6;
walking dead s4e16;
criminal minds s9e19;
breaking bad s5e16/final;
prison break s4e24/final;
Homeland;

Die Klasse sollte ungefähr so aussehen:

class serie{
public:
	serie(std::string name, unsigned short staffel, unsigned short episode, bool final) :
		name(name), staffel(staffel), episode(episode), final(final){} //ist es ok das die Parameter und die Memeber den selben Namen haben?
private:
	std::string name;
	unsigned short staffel, episode;
	bool final;
};

Was versteht man denn unter klassischen Mitteln?
Furble Wurble hat mir eigentlich schon gut geholfen.

Eben das, was Furble Wurble meinte.

Bloß muss ich jetzt irgendwie das s1e1 in die 2 shorts bekommen. Bloß wie erkenne ich denn jetzt am besten eine Zahl?

Dann hast du nicht verstanden, was Furble Wurble meinte. Du sollst deine Daten direkt einlesen, nicht händisch irgendwelche Strings zerlegen. Die Streams bieten doch schon tolle Lesefunktionen für allerlei Datendarstellungen an. Daraus bastelst du dir ein paar schicke Funktionen, die du zu größeren Funktionen zusammen setzt, die du zu noch größeren Funktionen zusammen setzt, die dann letztendlich eine Lesefunktion für dein Gesamtobjekt ergeben (die du dann üblicherweise "operator>>" nennst, damit du so etwas wie cin >> meine_serie schreiben kannst^*)
Hier böten sich an:
-Funktionstemplate, welches einen Buchstaben liest und mit einer Vorgabe vergleicht. Schlägt der Vergleich fehl, wird ein Fehlerflag gesetzt. Hier am besten noch mit expliziter Nichtbeachtung von Groß- und Kleinschreibung.
-Einlesen von short gibt's ja schon.
-Damit dann Einlesen der Staffelinformation: Lese_und_prüfe<E>; Lese short -> Staffel; Lese_und_prüfe<S>; Lese short -> Episode

Ich kann's gerade leider nicht vormachen, da der Rechner an dem ich sitze nicht für Entwicklung ausgerüstet ist und remote oder bei ideone ist mir das zu fummelig.

^*: Die Bezeichnung "serie" für deine Klasse scheint mir sehr unpassend. Es scheint sich doch um eine einzelne Episode zu handeln. Aber "episode" wäre auch falsch, da es nicht die Episode selbst ist, sondern Information über ihren Titel. Also "titelinformation" oder ähnliches. Und eigentlich programmiert man auch auf englisch, wenn du nicht gerade für eine deutsche Behörde arbeitest.

Zu dem Namen der Klasse bzw. des Ziels des Programmes. Das Programm soll aus der Datei erkennen bei welcher Serie ich wie weit bin. Also soll das Programm erkennen bei Game of Thrones bin ich in der 3 Staffel in der 6 Episode. Die Serien die nicht mehr weiter Produziert werden sind halt mit /final makiert.
Das mit den Englischen besser ich nach War halt nur schnell geschrieben.

Man kann das zwar auch ziemlich gut direkt mit den klassischen Mitteln lesen, aber das Format scheint mir so dermaßen nach einem regulären Ausdruck zu schreien, dass ich die klassische Lösung mal lieber nicht vormache, sondern auf jemanden warte, der sich mit Regex auskennt.

Ich kenne mich natürlich kein bisschen mit Regex aus, aber einen Versuch habe ich gestartet - er versagt allerdings beim allerletzten Fall, wenn kein Leerzeichen nach dem Namen vorhanden ist... genauso versagt er, wenn ein Leerzeichen zwischen Episodeninformation oder /final und dem Semikolon vorhanden ist. Sicher kann das jemand korrigieren, der sich auskennt.

#include <string>
#include <algorithm>
#include <regex>

#include <ostream>
#include <istream>

class serie
{
public:
	serie( std::string const& name_ = "dummy",
	       unsigned short staffel_ = 0,
	       unsigned short episode_ = 0,
	       bool final_ = false) :
	  name_(name_), staffel_(staffel_), episode_(episode_), final_(final_){} //ist es ok das die Parameter und die Memeber den selben Namen haben?

	std::string const& name() const { return name_; }
	unsigned short staffel() const { return staffel_; }
	unsigned short episode() const { return episode_; }
	bool final() const { return final_; }

private:
	std::string name_;
	unsigned short staffel_, episode_;
	bool final_;

	friend std::istream& operator>>( std::istream& is, serie& s )
	{
		std::string str;
		if (!std::getline(is >> std::ws, str, ';'))
			return is;

		static const std::regex reg("(.+) +(s([0-9]+)e([0-9]+))? *(/final)?");
		std::smatch match;
		if (std::regex_match(str, match, reg))
		{
			s.name_ = match[1];

			if( match[2].matched )
			{
				s.staffel_ = std::stol(match[3]);
				s.episode_ = std::stol(match[4]);
			}
			else
				s.staffel_ = s.episode_ = 0;

			s.final_ = match[5].matched;
		}
		else
			is.setstate( std::ios_base::failbit );

		return is;
	}
};

#include <sstream>
#include <iostream>

int main()
{
	std::istringstream stream(
R"(game of throne s4e6;
walking dead s4e16/final;
criminal minds s9e19;
breaking bad s5e16/final;
prison break s4e24;
Homeland ;)"
);
	serie s;
	while (stream >> s)
		std::cout << "Name: " << s.name() << '\n'
		          << "\tStaffel: " << s.staffel() << (s.final()? " (die letzte!)" : "") << '\n'
		          << "\tEpisode: " << s.episode() << '\n';
}

Edit: Das Problem ist, dass der Ausdruck (.+) gerne auf den ganzen String gematcht wird statt nur auf den Namen. Wie kann man diesen eingrenzen?

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
terminate called after throwing an instance of 'std::regex_error'
  what():  regex_error

@Arcoth
Welchen Compiler nutzt du? Bei mir bekomme ich ein Laufzeitfehler:

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
terminate called after throwing an instance of 'std::regex_error'
  what():  regex_error

Kann sein, dass der Compiler das einfach nicht supported?
Du nutzt den GCC oder? Der unterstützt das AFAIK ab 4.8.

Ja ist hab so ein "MinGW Installer" mit dem ich das irgendwie installiert hab.
Hat jemand ein Link zu ner Anleitung wie ich GCC 4.8 bekomme. Hab damals einfach auf paar Button gedrückt und irgendwann hat das dann compiliert...

Du solltest den Installer nochmal neu runterladen und ausführen. Die aktuellste Version von MinGW ist 4.8.1-4

Ich hab da ja ganz viele "Package". Eins davon ist mingw32-gcc-g++ in der Version 4.8.1-4.
Woran kann das jetzt liegen?

Das bedeutet, du hast schon die aktuelle Version. Wenn du auf der Konsole g++ --version eingibst, sollte auch 4.8.1-4 kommen.

Mit meinem MinGW-w64 (gcc 4.9.0) kompiliert und läuft es einwandfrei.

Ist das mit Absicht das die main kein return hat? Muss ich das verstehen bzw. ist das erst "später" wichtig/Interessant?

return 0 in main (und zwar nur in main!) ist überflüssig, weil implizit eingefügt.

std::istream& operator>>( std::istream& is, serie& s )
{ 
	std::string str; 
	if (!std::getline(is >> std::ws, str, ';')) 
		return is; 

	static const std::regex reg("(s[[:space:]]*([0-9]+)[[:space:]]*e[[:space:]]*([0-9]+)*[[:space:]]*)([[:space:]]*/[[:space:]]*final)*"); 
	std::smatch match; 
	if (std::regex_search(str, match, reg)) 
	{ 
		s.name_ = match.prefix();
		s.staffel_ = std::stol(match[2]); 
		s.episode_ = std::stol(match[3]); 

		s.final_ = match[4].matched; 
	} 
	else
	{
		s.name_ = str;
		s.staffel_ = s.episode_ = 0;
		s.final_ = 0;
	}

	return is; 
}

Restliche Code ist gleich.
Mit Ausnahme das staffel jetzt episode heißst

Würde mich Interessieren ob ich eventuellen schwächen findet.

Würde mich freuen wenn ihr schaut ob es Fehler gibt bzw was ihr anders/besser machen würdet.

if (!std::getline(is, str, ';')) // der Regex kümmert sich um Leerzeichen drum rum
      return is;

    // \d: [0-9], \s: [[:space:]], +?: Non-greedy matching, ^ und $: alles anschauen, keinen Substring suchen
    static const std::regex reg(R"(^\s*(.+?)(\s+s(\d+)e(\d+))?(\s*/final)?\s*$)");
    std::smatch match;
    if (!std::regex_match(str, match, reg))
      assert(false); // always matches

Dein Regex schlägt fehl bei z.B. "prison s4e24 break s4e24;".

s.name_ = match[1];

    if (match[2].matched) {
      s.staffel_ = std::stol(match[3]);
      s.episode_ = std::stol(match[4]);
    } else {
      s.staffel_ = s.episode_ = 0;
    }
    s.final_ = match[5].matched;

    return is;

File: main.cpp, Line 41

Expression: false

Line 41:

assert(false); // always matches

"prison s4e24 break s4e24;"

So ein Format sollte nicht vorkommen.

if (!std::getline(is, str, ';')) // der Regex kümmert sich um Leerzeichen drum rum

Hab vergessen zu sagen das nach den ';' Kommentare kommen.

Trotzdem Danke.