Mein Programm soll einige Dateien Parsen und dabei für gewisse Dateien bestimmte Parsing Funktionen benutzen.

Ich wollte also an die read_file Funktion den Filepath und den richtigen Functionpointer übergeben.

Ich bekomme allerdings wenn ich im Konstruktor der Klasse den Funktionspointer zuweisen will beim kompilieren einen Fehler:

error C2276: '&': Ungültige Operation auf Ausdruck einer gebundenen Memberfunktion

HIer das Beispiel:

Mgr.hpp

class Mgr {

public:
Mgr();

void parse_template_keys(std::string & tmp, std::string & caption, std::string & action);

void(Mgr::*parse_templ_k_ptr)(std::string &, std::string &, std::string &);
};

Mgr.cpp

Mgr::Mgr() {
    parse_templ_k_ptr = &parse_template_keys;
}

Ich hoffe ihr könnt mir helfen.

Gruß
Christian

Ich wollte also an die read_file Funktion den Filepath und den richtigen Functionpointer übergeben.

Memberfunktionszeiger sind keine Zeiger.

Chp++ schrieb:

Ich bekomme allerdings wenn ich im Konstruktor der Klasse den Funktionspointer zuweisen will beim kompilieren einen Fehler:

error C2276: '&': Ungültige Operation auf Ausdruck einer gebundenen Memberfunktion

Mgr::Mgr() {
    parse_templ_k_ptr = &parse_template_keys;
}

Um Zeiger auf Member zu erzeugen, ist immer ein qualifizierter Bezeichner erforderlich:

Mgr::Mgr()
  : parse_templ_k_ptr( &Mgr::parse_template_keys )
{}

parse_templ_k_ptr = &Mgr::parse_template_keys;

Allgemeine Frage: Weißt du wirklich, was du da tust? Und sind Funktionszeiger das richtige Mittel für dein Problem? Dein Problem ist leider nicht genau genug spezifiziert, daher kann ich das nicht genau sagen. Was ich jedoch bemerke ist, dass es sehr ungewöhnlich ist, einen Dateinamen an eine Lesefunktion zu übergeben (warum sollte sich eine Lesefunktion um Dateien kümmern?), daher bin ich auch stutzig gegenüber den Funktionszeigern. Die sind ein von Anfängern oft missbrauchtes Mittel. (Das heißt nicht, dass es falsch ist. Deshalb frage ich ja, ob du dir wirklich sicher bist.)

edit: Da war camper schneller.

Danke an alle.
@Sepp
Ich habe mich glaube ich unglücklich ausgedrückt. Um sicherzugehen, dass ich nichts grundlegend Falsch mache hier nochmal genauer.

Ich möchte mehrere Dateien auslesen.
Die Dateien stammen nicht von mir und ich kann sie auch leider nicht ändern.

In den ersten Dateien möchte ich Keys, die mit einer gewissen Syntax, in der Textdatei markiert sind auslesen und speichern. Dafür habe ich eine Parsing-Funktion geschrieben. Ich nenne sie mal Alpha.

Als nächsten Schritt lese ich weitere Dateien ein in der die Keys leider eine andere Syntax haben. Dafür habe ich eine weitere Parsing Funktion geschrieben. Beta.

Danach verarbeite ich die gesammelten Daten.
Ich habe das so implementiert:

Ich habe eine Member Funktion die die Dateien mit ifstream öffnet und mit getline die Zeile in einen String speichert.
Ich übergebe dieser Funktion ein Fileobjekt ,dass den Filepath enthält sowie einen Funktionszeiger zur passenden Parsing Funktion.
Nachdem getline die Zeile in den String gespeichert hat rufe ich den Funktionspointer auf um den eingesammelten String zu parsen/analysieren.

Das Hauptproblem ist, dass ich durch das Lesen der Datei nicht erkennen kann welche Funktion ich aufrufen muss.
Die Syntax der Schlüsselwörter unterscheidet sich in einer Art und Weise, dass ich bei dem Versuch eine Parsing Funktion für alle zu schreiben gescheitert bin.
Auch mein Versuch eine Funktion zu schreiben die automatisch erkennt welche Lesefunktion ich aufrufen muss hat nicht funktioniert.

D.h. bevor ich lese muss ich wissen welche Parsing-Funktion die richtige Funktion ist.
Ich weiß leider nicht, wie ich es anders hätte machen können, ohne eine weitere Lese-Funktion zu schreiben und einen weiteren vector zu implementieren für die zweite Sorte von Dateien.

Ich dachte eine generische Lesefunktion wäre die beste Lösung.

Das Hauptproblem ist, dass ich durch das Lesen der Datei nicht erkennen kann welche Funktion ich aufrufen muss.

Und wie findest du es letztendlich heraus?

Die Syntax der Schlüsselwörter unterscheidet sich in einer Art und Weise, dass ich bei dem Versuch eine Parsing Funktion für alle zu schreiben gescheitert bin.

Vielleicht kommen wir auf eine Lösung. Zeig mal die beiden Formate.

Ich habe eine Member Funktion die die Dateien mit ifstream öffnet und mit getline die Zeile in einen String speichert.
Ich übergebe dieser Funktion ein Fileobjekt ,dass den Filepath enthält sowie einen Funktionszeiger zur passenden Parsing Funktion.
Nachdem getline die Zeile in den String gespeichert hat rufe ich den Funktionspointer auf um den eingesammelten String zu parsen/analysieren.

Das klingt umständlich und hat die schon genannten Probleme. Warum öffnet eine Lesefunktion eine Datei? Warum die Daten zwischenspeichern, anstatt direkt parsen?

Ich dachte eine generische Lesefunktion wäre die beste Lösung.

Was macht denn diese generische Lesefunktion überhaupt noch? Das klingt so als hättest du eine Funktion um den typischen C++-Lese-Dreizeiler geschrieben, um dann mit viel Code und Aufwand diesen nicht ausschreiben zu brauchen.

Und wie findest du es letztendlich heraus?

Gar nicht. Ich hatte es beim erstellen des Vectors der die Filepaths zum öffnen enthält fest verdrahtet.

Allerdings sieht man manchmal den Wald vor lauter Bäumen nicht mehr.
Ich kann anhand der Syntax des Filenamens erkennen welche Funktion ich aufrufen muss.
Die Sache mit den Funktionspointern kann ich mir also sparen.

SeppJ schrieb:

Vielleicht kommen wir auf eine Lösung. Zeig mal die beiden Formate.

Gerne, aber ich würde erstmal am Wochenende (im ausgeschlafen Zustand) doch noch einmal einen Versuch starten, wenn es dann nicht klappt komme ich auf das Angebot zurück.

SeppJ schrieb:

Das klingt umständlich und hat die schon genannten Probleme. Warum öffnet eine Lesefunktion eine Datei? Warum die Daten zwischenspeichern, anstatt direkt parsen?

Das versteh ich nicht so ganz.
Welche Funktion soll denn sonst die Datei öffnen?

Also bei mir würde das mit den Änderungen irgendwie so ausehen.:

bool load_action_keys (string & filepath)
{
	//analyse filename to know which parse function I need and set char with
	// corresponding value
	char parse_mode = filename_parse_result(filepath);

	// open file
	ifstream input(filepath);

	if (!input.is_open());
		return false;

	string tmp;
	tmp.reserve(40);

	while(input.good()
	{
		getline(input, tmp);

		switch (char_parse_mode)
		{
			case 'A': { parse_func_alpha(tmp); } break;
			case 'B': { parse_func_beta(tmp); } break;
		}
	}
}
// Edit durch Arcoth: Formatiert. Künftig bitte selber machen!

Oder wie würdet ihr das machen?
Ich habe File I/O noch nicht so oft gemacht.
Ich habe im Moment keinen Compiler zur Hand ich hoffe ich habe es richtig geschrieben.
Du meinst, dass ich gleich char für char auslesen und analysieren soll?
Getline schien mir irgendwie auf den ersten Blick als naheliegende Wahl.

Ich kann anhand der Syntax des Filenamens erkennen welche Funktion ich aufrufen muss.
Die Sache mit den Funktionspointern kann ich mir also sparen.

Ich muss zugeben, dass ich das schon erwartet hatte und die Fragen bewusst so gestellt habe, dass du darauf kommst.

Welche Funktion soll denn sonst die Datei öffnen?

Normalerweise arbeiten Lesefunktionen ganz abstrakt auf Streams. Was kümmert es einen Parser, wo die Daten herkommen. Derjenige, der sich darum kümmert, ist doch derjenige, der auch den Parser aufruft.
Also

Datenobjekt data;
ifstream file("foo.bar");
read_data(file, data);

oder, wenn man den Namen der Funktion etwas geschickter wählt:

Datenobjekt data;
ifstream file("foo.bar");
file >> data;

Diese Schreibweise dürfte dir bekannt vorkommen, oder?

Ich habe File I/O noch nicht so oft gemacht.

Man merkt's. Aber wie oben erwähnt ist es für eine LEsefunktion eigentlich egal, woher die Daten kommen. Deine Schleife funktioniert jedoch in gar keinem Fall richtig: Zuerst prüfst du auf Fehler, dann liest du, dann verarbeitest du ungeprüft das Ergebnis. Falsche Reihenfolge, findest du nicht? Sollte wohl eher Lesen, Prüfen auf Erfolg, Verarbeiten sein. So oder ähnlich sehen Leseschleifen in C++^* aus:

while(lesen(daten))
  verarbeite(daten);

Du meinst, dass ich gleich char für char auslesen und analysieren soll?

Nicht direkt. Kommt drauf an. Was machen deine Parsefunktionen denn? Die packen den String doch sicherlich direkt wieder in einen Stringstream und du liest dann aus diesem. Warum dann nicht direkt aus der Originalquelle lesen?

^*: Und in allen anderen C-artigen Sprachen. Wenn du deine Art und Weise aus irgendeinem Buch oder Tutorial hast, dann ist das ein sehr guter Grund, diese Quelle in Zukunft nie wieder zu nutzen und alles zu vergessen, was darin steht. Der Autor hat keine Ahnung. Kommt leider oft vor.

Man merkt's. Aber wie oben erwähnt ist es für eine LEsefunktion eigentlich egal, woher die Daten kommen. Deine Schleife funktioniert jedoch in gar keinem Fall richtig: Zuerst prüfst du auf Fehler, dann liest du, dann verarbeitest du ungeprüft das Ergebnis. Falsche Reihenfolge, findest du nicht? Sollte wohl eher Lesen, Prüfen auf Erfolg, Verarbeiten sein. So oder ähnlich sehen Leseschleifen in C++^* aus:

while(lesen(daten))
  verarbeite(daten);

Entschuldige das habe ich nicht ganz verstanden.
Ich habe den Part mal angepasst so wie ich das verstanden habe?

ifstream input(filepath);

    if (!input.is_open()) 
        return false;

    while (getline(input,tmp))
    {
        switch (parse_mode)
        {
        case 'A': { parse_func_alpha(tmp); } break;
        case 'B': { parse_func_beta(tmp); } break;
        }

    }

SeppJ schrieb:

Nicht direkt. Kommt drauf an. Was machen deine Parsefunktionen denn? Die packen den String doch sicherlich direkt wieder in einen Stringstream und du liest dann aus diesem. Warum dann nicht direkt aus der Originalquelle lesen?

Mir ist gerade nicht ganz klar was du damit meinst.
Meine Parsing-Funktion sieht so aus. (Ich hoffe es ist nicht zuviel Code zum pasten.)
Ich suche in der Datei eine Action und die dazugehörige Caption.
Jede Caption hat ein ?@{caption} am Anfang allerdings können mehrere Captions hintereinander vorkommen UND die Caption geht über den Key hinaus.

bsp. Caption: ?@{Caption} = blabla blubblub

Mich interessiert auch nur die Caption direkt über einer Action die Syntax einer Action ist leider nicht unique @{key.blabla.bla}.
Es gibt auch @{junk} der genauso aussieht wie eine Action.
Glücklicherweise fangen alle Actions mit "key" an.

Wenn ich die Action und die dazugehörige Caption habe baue ich ein Action-Objekt.
Wenn ich etwas besser machen kann dann bitte sagen.

void Mgr::parse_template_keys(string & tmp, string & caption, string & action) {
    string::const_iterator it;
    string::const_iterator it_begin;
    string::const_iterator it_end;

    // U = unknown; C = caption, A = action
    char switch_value = 'U';
    bool in_key = false;

    //was ist es??
    for (it = tmp.begin(); it != tmp.end(); ++it){
        if (*it == '?') {
            switch_value = 'C';
            break;
        }
        if (*it == '@') {

            if (tmp.find("key") != string::npos)
            {
                switch_value = 'A';
                break;
            }
        }
    }
    //weiche zum entsprechenden parsing code
    switch (switch_value) {
        // caption
    case ('C') : {
                     for (it = tmp.begin(); it != tmp.end(); ++it) {

                         if (*it == '@')
                             it_begin = it;

                         if (*it >= 65 && *it <= 90)
                             it_end = it + 1;

                     }
                     string temp_copy(it_begin, it_end);
                     caption = std::move(temp_copy);
    }    break;

                     //action
    case ('A') : {
                     for (it = tmp.begin(); it != tmp.end(); ++it) {

                         if (in_key == true) {
                             it_begin = it;
                             in_key = false;
                         }
                         if (*it == '{')
                             in_key = true;

                         if (*it == '}') {
                             it_end = it;
                             break;
                         }
                     }
                     string temp_copy(it_begin, it_end);
                     action = std::move(temp_copy);
    }break;

    default: { tmp.clear(); }

    }

        if (action.empty() == false) {
            action_list.push_back(unique_ptr<Action>(new Action(std::move(caption), std::move(action))));
            action.clear();
        }
    }

Entschuldige das habe ich nicht ganz verstanden.
Ich habe den Part mal angepasst so wie ich das verstanden habe?

ifstream input(filepath);
  
    if (!input.is_open()) 
        return false;
    
    while (getline(input,tmp))
    {
        switch (parse_mode)
        {
        case 'A': { parse_func_alpha(tmp); } break;
        case 'B': { parse_func_beta(tmp); } break;
        }
    
    }

Ja. So klappt das auch bei Lesefehlern (Dateiende!) korrekt.

Wenn ich etwas besser machen kann dann bitte sagen.

Puh, ganz schön kompliziert. Da sind eine Menge Detailsverbesserungen möglich, beispielsweise:

string temp(begin, end);
anderer_string = std::move(temp);

anderer_String.assign(begin, end);

Irgendwie bin ich verwirrt, wie du std::move und seinen Nutzen kennen kannst, aber gleichzeitig dir Grundlagen über Strings unbekannt zu sein scheinen.
(Übrigens: Fast immer wenn man etwas "temp" oder ähnlich nennt, ist dies ein guter Hinweis, dass man das Objekt gar nicht braucht. Temporäre Zwischenwerte braucht man nur im Falle schlechter Schnittstellen. Die C++-Standardbibliotheksschnittstellen gehören in der Regel nicht dazu und wenn es deine eigenen Schnittstellen sind, dann verbessere sie!)

Oder dein ganzes geswitche: Das ist doch bei dir bloß eine super umständliche Art und Weise für ein einfaches if!

if(Bedingung A)
  modus = 1;
else if (Bedingung B)  // bei dir fehlt übrigens das else in der Logik
  modus = 2;

switch (modus)
{
  1: Code 1; break;
  2: Code 2; break;
}

if(Bedingung A)
  Code 1;
else if (Bedingung B)
  Code 2;

Wieder bin ich erstaunt über die Diskrepanz zwischen den benutzten Sprachmitteln (da weißt du viel) und wie sie letztendlich benutzt werden (da weißt fast gar nichts). Hast du den Code alleine geschrieben? (Teilweise?) abgeschrieben?

Und Buchstaben schreibt man im Code auch als Buchstaben. Schreib 'A' statt 65, dann weiß auch jeder, was gemeint ist.

Was soll der Teil überhaupt? Soll das den letzten Großbuchstaben finden? Wo kommt das in deinem Format vor?

ABER: Wie schon erwähnt würde ich hier gar nicht über einen String gehen, sondern direkt lesen. Das heißt alle obigen Tipps sind nur als Hinweise zu sehen, ich würde den Code insgesamt ganz anders schreiben. Leider ist mir unklar, was genau du willst, daher kann ich es nicht vormachen. Gib mal ein paar Beispieldaten und wie sich der Zustand von Mgr ändern soll, wenn diese verarbeitet werden.

Wieder bin ich erstaunt über die Diskrepanz zwischen den benutzten Sprachmitteln (da weißt du viel) und wie sie letztendlich benutzt werden (da weißt fast gar nichts). Hast du den Code alleine geschrieben? (Teilweise?) abgeschrieben?

Nein, ich habe alles alleine geschrieben.
Ich habe vor einem Jahr kurz Javascript angefangen und bin dann aber gleich auf C++ umgestiegen, weil mir das erste "Hello World" soviel Spaß gemacht hat und ich eine getypte Sprache einfach toll fand.

Ich muss auch sagen, dass ich es toll finde wie komplex und kompliziert die Sprache ist.
Ich mache das nicht beruflich sondern ist ein Hobby von mir nachdem Feierabend.
Ab und zu programmier ich auch etwas um mir das Leben auf Arbeit zu erleichtern.

Ich habe vor allem durch Bücher gelernt, wobei ich wirklich große Probleme hatte geeignetes Lernmaterial zu finden. Ich habe zuhause an die 10 C++ Bücher rumliegen und leider sind nur die Bücher gut die sich um Detailfragen/Optimierungen der Sprache drehen.
z.B.:
Effective C++ programmieren
More Effective C++
Effective STL
C++11

Allerdings sind das alles Bücher in denen es um Detailverbesserungen geht und nicht um "Wie implementiere ich eine File-Lese Funktion".
Da habe ich bis jetzt kein einziges anständiges Buch gefunden.
Vielleicht könnt ihr mir da weiterhelfen ein passendes Buch zu finden?

Wenn man alleine vor dem Rechner sitzt und sozusagen in seinem eigenen Saft schmort ist es, finde ich, einfach schwer da "Programm funktioniert" nicht gleichbedeutend mit gutem Code oder einer guten Architektur ist.

SeppJ schrieb:

Und Buchstaben schreibt man im Code auch als Buchstaben. Schreib 'A' statt 65, dann weiß auch jeder, was gemeint ist.

Was soll der Teil überhaupt? Soll das den letzten Großbuchstaben finden? Wo kommt das in deinem Format vor?

Ich wusste nicht, dass ich die größer/gleich Operatoren auch auf die chars anwenden kann. Daher habe ich die Nummern verwendet.

Das ist für die Caption. Die kann manchmal so aussehen:
"?{Text} = FOO BAR\t\t\t\t" (Anführungszeichen wegdenken)

Ich schiebe also den End-Iterator an der Stelle immer weiter, bis ich zum letzten Großbuchstaben komme, da ich die Tabulatoren Zeichen nicht mitnehmen will.

Vielen Dank für den Tip mit dem assign.
Ich habe genau sowas gesucht.
Ich hätte in der cplusplus reference genauer gucken müssen.