设计模式之翻译器模式

优点：没看懂。

体会：没有。

#pragma once
class Context
{
public:
    Context();

    ~Context();
};

#include "Context.h"


Context::Context()
{
}


Context::~Context()
{
}

 

#pragma once

class Context;

class Interpret_AbstractExpression
{
public:
    virtual ~Interpret_AbstractExpression();

    virtual void Interpret(const Context &con);

protected:
    Interpret_AbstractExpression();
};

#include "Interpret_AbstractExpression.h"
#include "Context.h"


Interpret_AbstractExpression::Interpret_AbstractExpression()
{
}


Interpret_AbstractExpression::~Interpret_AbstractExpression()
{
}

void Interpret_AbstractExpression::Interpret(const Context &con)
{
}

 

#pragma once
#include "Interpret_AbstractExpression.h"
#include <string>

class TerminalExpression :
    public Interpret_AbstractExpression
{
public:
    TerminalExpression(const std::string &statement);

    ~TerminalExpression();

    void Interpret(const Context &con);

private:
    std::string m_statement;
};

#include "TerminalExpression.h"
#include <iostream>


TerminalExpression::TerminalExpression(const std::string &statement)
{
    this->m_statement = statement;
}


TerminalExpression::~TerminalExpression()
{
}

void TerminalExpression::Interpret(const Context &con)
{
    std::cout << this->m_statement << "TerminalExpression::Interpret..." << std::endl;
    return;
}

 

#pragma once
#include "Interpret_AbstractExpression.h"

class NonterminalExpression :
    public Interpret_AbstractExpression
{
public:
    NonterminalExpression(Interpret_AbstractExpression *expression, int times);

    ~NonterminalExpression();

    void Interpret(const Context &con);

private:
    Interpret_AbstractExpression *m_expression;

    int m_times;
};

#include "NonterminalExpression.h"
#include "Context.h"


NonterminalExpression::NonterminalExpression(Interpret_AbstractExpression *expression, int times)
{
    this->m_expression = expression;

    this->m_times = times;
}


NonterminalExpression::~NonterminalExpression()
{
}

void NonterminalExpression::Interpret(const Context &con)
{
    for (int i = 0; i < m_times; i++)
    {
        this->m_expression->Interpret(con);
    }
}

 

测试

#include <iostream>
#include "Context.h"
#include "NonterminalExpression.h"
#include "TerminalExpression.h"

int main()
{
    Context *con = new Context();

    Interpret_AbstractExpression *te = new TerminalExpression("hello");

    Interpret_AbstractExpression *nte = new NonterminalExpression(te, 2);

    nte->Interpret(*con);

    if (nte)
    {
        delete nte;
        nte = NULL;
    }
    if (te)
    {
        delete te;
        te = NULL;
    }
    std::cout << "Hello World!\n"; 
}