Компиляция нескольких файлов со структурами C++

#ifndef EXPRESSION
#define EXPRESSION
#include "Visitor.h"
 
// Base structure to store expressions
struct Expression
{
    virtual double evaluate() const = 0;    // returns value of object
    virtual void visit(Visitor * visitor) const  = 0;   // Visitor pattern
 
    virtual ~Expression(){}
};
 
#endif // EXPRESSION

#ifndef BINARYOPERATION
#define BINARYOPERATION
#include "Expression.h"
#include "Visitor.h"
 
// Structure for simple operations
struct BinaryOperation : Expression
{
    BinaryOperation(Expression const * left, char op, Expression const * right)
        : left(left), op(op), right(right)
    { }
 
    Expression const * get_left()  const;   // the left operand
    Expression const * get_right() const;   // the right operand
    char get_op() const;
    double evaluate() const{    // value of operation
        switch(op)  // op is operation symbol
        {
            case '+': return left->evaluate() + right->evaluate();
            case '-': return left->evaluate() - right->evaluate();
            case '*': return left->evaluate() * right->evaluate();
            case '/': return left->evaluate() / right->evaluate();
        }
    }
 
    virtual void visit(Visitor * visitor) const  // Visitor Pattern
    {
        visitor->visitBinaryOperation(this);
    }
 
    ~BinaryOperation(){     // numbers allocate with 'new'
        delete left;
        delete right;
    }
 
private:
    Expression const * left;    // left operand
    Expression const * right;   // right operand
    char op;    // operation symbol
};
 
#endif // BINARYOPERATION

#include "BinaryOperation.h"
 
Expression const * BinaryOperation::get_left()  const { return left; }
 
Expression const * BinaryOperation::get_right() const { return right; }
 
char BinaryOperation::get_op() const { return op; }
 
double BinaryOperation::evaluate() const{
    switch(op)
    {
        case '+': return left->evaluate() + right->evaluate();
        case '-': return left->evaluate() - right->evaluate();
        case '*': return left->evaluate() * right->evaluate();
        case '/': return left->evaluate() / right->evaluate();
    }
}

#ifndef NUMBER
#define NUMBER
#include "Expression.h"
#include "Visitor.h"
 
// Structure for numbers
 
struct Number : Expression
{
    Number(double value)
        : value(value)
    {}
 
    double evaluate() const {return value;}     // returns value of number
 
    virtual void visit(Visitor * visitor) const // Visitor pattern
    {
        visitor->visitNumber(this);
    }
private:
    double value;   // value of number
};
 
#endif // NUMBER

#ifndef VISITOR
#define VISITOR
#include "Number.h"
#include "BinaryOperation.h"
#include "Expression.h"
 
// Visitor pattern
 
struct Visitor {
    virtual void visitNumber(Number const * number) = 0;
    virtual void visitBinaryOperation(BinaryOperation const * binary) = 0;
    virtual ~Visitor() { }
};
 
#endif // VISITOR

#ifndef PRINTVISITOR
#define PRINTVISITOR
#include "Visitor.h"
 
// For Visitor pattern
// prints expression
struct PrintVisitor : Visitor {
 
    // If number -> print number
    void visitNumber(Number const * number)
    {
        cout << number->evaluate();
    }
 
    /* If object is binary operation ->
     * consider operands and print operation symbol
     */
    void visitBinaryOperation(BinaryOperation const * bop)  // if
    {
        cout << '(';    // saves the order of operations
        bop->get_left()->visit(this);   // next level of recursion
        std::cout << ' ' << bop->get_op() << ' ';
        bop->get_right()->visit(this);  //next level of recursion
        cout << ')';
    }
};
 
#endif // PRINTVISITOR

#include <iostream>
#include "Expression.h"
#include "Number.h"
#include "BinaryOperation.h"
 
using namespace std;
 
int main()
{
    Expression* expr = new BinaryOperation(new Number(4.5), '*', new Number(7));    // create expression (4.5 * 7)
    PrintVisitor visitor;
    expr->visit(&visitor); // print expr
 
    return 0;
}