C++ ERREUR: avant la déclaration de " struct...?

cyclique de l'inclusion problème

Je déclarer avant l'une des classes dans l'en-tête de l'autre dans une tentative de résoudre leurs cyclique de l'inclusion. Voici mes deux fichiers:

Le premier fichier (Paramètre.h):

#pragma once
#include "Token.h"`

class Expression;

class Parameter {
public:

    Parameter() {
        string = new Token();
        identifier = new Token();
        expr = new Expression();
    }

    Token* string;
    Token* identifier;
    Expression* expr;
};

Le deuxième fichier (Expression.h):

#pragma once
#include "Token.h"
#include "Parameter.h"

class Expression {
public:
    Expression() {
        param1 = new Parameter();
        param2 = new Parameter();
        op = new Token();
    }

    Expression(Parameter* p1, Token* o, Parameter* p2) {
        param1 = p1;
        param2 = p2;
        op = o;
    }

    Parameter* param1;
    Parameter* param2;
    Token* op;
};

Comme vous pouvez le voir, je déclarer avant d'Expression en Paramètre.h, mais je suis encore en train de les deux erreurs suivantes:

avant la déclaration de 'struct' Expression

utilisation incorrecte incomplète de type 'struct' Expression

J'ai regardé plusieurs déjà publié de questions, mais encore, ne pouvait pas résoudre ce problème. Merci.

OriginalL'auteur amorimluc | 2013-02-20

  1. 9

    Vous ne pouvez pas déclarer avant Expression parce que vous avez besoin de l'intégralité de la déclaration pour cette:

    Parameter() {
    string = new Token();
    identifier = new Token();
    expr = new Expression();  //here!
}

    Ce que vous pouvez faire est de déplacer la mise en œuvre de la Parameter() constructeur de l'en-tête et dans un .cpp fichier.

    Il a travaillé! Merci.

    OriginalL'auteur juanchopanza

  2. 4

    Vous avez besoin de mettre constructeur de Paramètre dans un fichier cpp, lorsque vous appelez expr = new Expression(); dans le constructeur de l'Expression type de béton doit être connue.

    Paramètre.h

    #pragma once
#include "Token.h"

class Expression;

class Parameter {
public:

    Parameter();

    Token* token;
    Token* identifier;
    Expression* expr;
};

    Parameter.cpp

    #include "Parameter.h"

Parameter::Parameter()
: token(new Token()),
  identifier(new Token()),
  expr(new Expression())
{
}

    note de côté: peut utiliser des pointeurs intelligents au lieu de raw pointeurs en tant que membre de la classe? aussi nom de la variable string peut avoir un impact avec std::string.

    OriginalL'auteur billz

  3. 2

    Définir le corps du constructeur dans un autre fichier cpp. La déclaration anticipée de la classe vous permettent d'utiliser des pointeurs ou des références, bot n'est pas le constructeur de l'en avant a déclaré classe, que vous utilisez dans le constructeur de la classe "autres".
    dans un ccp fichier:

    #include "Parameter.h"
#include "Expression.h"   //  ??

Parameter::Parameter():   string (new Token()),
                          identifier(new Token()),
                          expr ( new Expression())
{}


Expression::Expression() param1 (new Parameter()),
                         param2 (new Parameter()),
                         op ( new Token())
{    }

    (maintenant vous êtes en sécurité si de nouvelles/constructeurs jeter)

    OriginalL'auteur qPCR4vir