Iterator deklariert als privates Mitglied einer Klasse funktioniert nicht richtig

Question

Ich habe ein Programm, das eine Datei scannt und alles in einem Vektor von Token speichern (eine Klasse, die ich erstellt habe, um jedes Token zu speichern). Danach werden alle Token analysiert und geprüft, ob sie im richtigen Format sind (korrekte Grammatik). Ich werde jedes Token mit Iterator werfen. Aus irgendeinem Grund mag mein Klassen-Parser die Art, wie ich den Iterator deklariere, nicht. Das ist meine Hauptfunktion:

int main(){ 
    DatalogProgram DLP; 
    bool passed = true; 
     ifstream in; 
     Scanner scanner; 
     in.open("File7.txt"); 
//  in.open(argv[1]); 
     Parser parse(scanner.getTokens(), &DLP); 
     scanner.scan(in); 
     try { 
      parse.checkDatalog(); 
     } 
     catch (Token* token) { 
      cout << "Failure!\n "; 
      cout << "(" << token->getType(token->type) << ",\"" << token->value << "\"," << token->lineNumber << ")"; 
      passed = false; 
     } 
     if (passed) 
     { 
      cout << "Success!\n"; 
      DLP.printScheme(); 
      DLP.printFact(); 
      DLP.printRule(); 
      DLP.printQuery(); 
     } 
     system("pause"); 
    return 0; 
} 

Dies ist mein Parser-Header-Datei, wo ich meinen Iterator erklären:

#pragma once 

#include "DatalogProgram.h" 
#include "Predicate.h" 
#include "Rule.h" 
#include "Token.h" 
#include <set> 
#include <vector> 

using namespace std; 
class Parser : public Token { 

public: 
    Parser() { it = tokens.begin(); } 
    Parser(vector<Token*> tokens, DatalogProgram *DLP) { this->tokens = tokens; this->DLP = DLP; it = tokens.begin(); } 
    ~Parser() { } 

    bool checkDatalog(); 
    void checkScheme(); 
    void checkSchemeList(); 
    void checkIdList(Predicate* scheme); 
    void checkFact(); 
    void checkFactList(); 
    void checkQuery(); 
    void checkQueryList(); 
    void checkStringList(Predicate* pred); 
    void checkRule(); 
    void checkRuleList(); 
    void checkHeadPredicate(Rule* rule); 
    Predicate* checkPredicate(); 
    void checkPredicateList(Rule* rule); 
    string checkParameter(); 
    void checkParameterList(Predicate* pred); 
    string checkExpression(); 
    string checkOperator(); 

    bool match(TokenType second, Token *token); 
    void domainPrinter(); 
private: 
    vector<Token*> tokens; 
    DatalogProgram *DLP; 
    vector<Token*>::iterator it; 
    set<string> domain; 
    stringstream expression; 


}; 

DatalogProgram.h:

`#pragma once 

#include "Scanner.h" 
#include "Rule.h" 
#include "Predicate.h" 
#include "Parser.h" 

//using namespace std; 
class DatalogProgram : public Token { 

public: 
    DatalogProgram() { } 
    ~DatalogProgram() { } 
    inline void addScheme(Predicate scheme) { schemes.push_back(scheme); } 
    inline void addRule(Rule rule) { rules.push_back(rule); } 
    inline void addFact(Predicate fact) { facts.push_back(fact); } 
    inline void addQuery(Predicate query) { queries.push_back(query); } 

    void printScheme(); 
    void printFact(); 
    void printRule(); 
    void printQuery(); 
    void printPredicate(vector <Predicate> printing); 

    vector<Predicate> schemes; 
    vector<Rule> rules; 
    vector<Predicate> facts; 
    vector<Predicate> queries; 
}; 
` 

Und das ist mein Fehler: Bevor ich versuche zu kompilieren, Visual Studio sagt nicht, dass es einen Fehler auf meinem Parser.h:

Answer 1

Es gibt eine rekursive Header-Abhängigkeit. Das wird in C++ nicht funktionieren. Vorwärts DatalogProgram innen parser.h erklären und parser.h die Abhängigkeit von DatalogProgram.h

#include "DatalogProgram.h" <-- Delete this line. 
struct DatalogProgram; 

class Parser : public Token { 
    .... 

Answer 2

Die gezeigten Header-Dateien sind völlig gebrochen zu entfernen.

Die main Übersetzungseinheit enthält höchstwahrscheinlich die DatalogProgram.h Kopfzeile.

DatalogProgram.h sofort umfasst Parser.h:

#pragma once 

/* ... */ 

#include "Parser.h" 

Und Parser.h geht dann Datalog.h wieder aufzunehmen:

#pragma once 

#include "DatalogProgram.h" 

jedoch seit DatalogProgram.h bereits aufgenommen worden, #pragma once dies völlig ignoriert. Compilation geht dann weiter, bis:

Parser(vector<Token*> tokens, DatalogProgram *DLP) 

Aber da DatalogProgram noch nicht definiert worden ist, diese Klasse nicht definiert wurde. Dies führt zu Ihrem Kompilierungsfehler.

Sie müssen herausfinden, was Ihre Inter-Header-Dateiabhängigkeiten sein sollten, und beheben Sie die zirkuläre Abhängigkeit; höchstwahrscheinlich durch Verwendung von Forward-Deklarationen.