日本一区二区三区,搞av网址,亚洲中文字幕不卡无码

意圖

給定一個語言，定義它的文法的一種表示，并定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。

結構

解釋器的結構圖

動機

如果一種特定類型的問題出現的頻率足夠高，那么可能值得將問題的各個部分表述為一個簡單語言中的句子。這樣就可以構建一個解釋器，該解釋器通過解釋這些句子來解決這類問題。

解釋器模式描述了如何為簡單的語言定義一個文法，如何在該語言中表示一個句子，以及如何解釋這些句子。

適用性

當有一個語言需要解釋執行，并且語言中的句子能表示為抽象語法樹時，可以使用解釋器模式。

注意事項

解釋器模式并沒有解釋如何創建一個抽象語法樹，也就是說，它不涉及到語法分析；
解釋器表達式不一定要定義解釋操作，或者也可以將解釋操作委托給一個“訪問者”（Visitor）對象，避免在各個表達式中繁瑣地定義這些操作；
終結表達式可以用享元模式（Flyweight）共享。

示例一

問題

定義一個正則表達式，用于檢查一個字符串是否匹配。正則表達式的文法定義如下：

expression ::= liternal | alternation | sequence | repetition | '(' expression ')'

alternation ::= expression '|' expression
sequence ::= expression '&' expression
**repetition := expression '*' **
liternal := 'a' | 'b' | 'c'| ... { 'a' | 'b' | 'c' | ...}*

創建：
"raining" & ( "dogs" | "cats") *

輸入：
rainingcatscats

輸出：
true

實現（C#）

為了實現這個簡易的正則表達式解析器，我們定義了如下幾個表達式類：

正則表達式解析器

// 正則表達式的抽象基類
public abstract class  RegularExpression
{
    public abstract string Match(string input);
}

// 字面表達式
public sealed class LiternalExpression : RegularExpression
{
    private readonly string liternal;

    public LiternalExpression(string liternal)
    {
        this.liternal = liternal;
    }

    public override string ToString()
    {
        return  "\""+ liternal + "\"";
    }

    public override string Match(string input)
    {
        if(!input.StartsWith(liternal)) 
            return input;
        else
            return input.Substring(liternal.Length);
        
    }
}

// 或操作表達式
public sealed class AlternationExpression : RegularExpression
{
    private readonly RegularExpression left;
    private readonly RegularExpression right;

    public AlternationExpression(RegularExpression left, RegularExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public override string ToString()
    {
        return string.Format("({0} | {1})", left.ToString(), right.ToString());
    }

    public override string Match(string input)
    {               
        var rest = left.Match(input);
        return rest == input ? right.Match(input) : rest;
    }
}

// 與操作表達式
public sealed class SequenceExpression : RegularExpression
{
    private readonly RegularExpression left;
    private readonly RegularExpression right;

    public SequenceExpression(RegularExpression left, RegularExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public override string ToString()
    {
        return string.Format("({0} & {1})",left.ToString(),right.ToString());
    }

    public override string Match(string input)
    {       
        var rest = left.Match(input);

        if(rest != input) return right.Match(rest);

        return rest;
    }
}

// 重復操作表達式
public sealed class RepetitionExpression : RegularExpression
{
    private readonly RegularExpression repetition;

    public RepetitionExpression(RegularExpression repetition)
    {
        this.repetition = repetition;
    }

    public override string ToString()
    {
        return string.Format("{0} *", repetition.ToString());
    }

    public override string Match(string input)
    {
        var repetition2 = repetition;
        var rest = repetition2.Match(input);
        while(rest != input) 
        {
            if(!(repetition2 is LiternalExpression))
            {
                repetition2 = new LiternalExpression(input.Substring(0,input.Length - rest.Length));
            } 

            input = rest;
            rest = repetition2.Match(input);
        }

        return rest;
    }
}

// 測試！注意添加命名空間: using System;
public class App
{
    public static void Main(string[] args)
    {
        // "raining" & ( "dogs" | "cats") *
        LiternalExpression raining = new LiternalExpression("raining");
        LiternalExpression dogs = new LiternalExpression("dogs");
        LiternalExpression cats = new LiternalExpression("cats");

        AlternationExpression dogsOrCats = new AlternationExpression(dogs,cats);
        RepetitionExpression repetition = new RepetitionExpression(dogsOrCats);
        SequenceExpression sequence = new SequenceExpression(raining,repetition);

        //打印出正則表達式的結構
        Console.WriteLine(sequence.ToString());

        Console.WriteLine("input = \"{0}\", result = {1}",
                "rainingcatscats", 
                sequence.Match("rainingcatscats") == string.Empty);
        Console.WriteLine("input = \"{0}\", result = {1}",
                "rainingdogsdogs", 
                sequence.Match("rainingdogsdogs") == string.Empty);
        Console.WriteLine("input = \"{0}\", result = {1}",
                "rainingCatsCats", 
                sequence.Match("rainingCatCats") == string.Empty);
    }
}

// 控制臺輸出：
//  ("raining" & ("dogs" | "cats") *)
//  input = "rainingcatscats", result = True
//  input = "rainingdogsdogs", result = True
//  input = "rainingCatsCats", result = False

示例二

問題

實現對布爾表達式進行操作和求值。文法定義如下：

boolean ::= Variable | Constant | Or | And | Not | '(' boolean ') '

Or ::= boolean '|' boolean
And ::= boolean '&' boolean
Not := '!' boolean
Constant := 'true' | 'false'
**Variable := 'A' | 'B' | ... | 'X' | 'Y' | 'Z' **

創建：
( true & X ) | ( Y & ( !X ) )

輸入：
X = fase, Y = true

輸出：
true

實現（C#）

同樣，我們先設計出相關表達式的結構圖：

布爾表達式結構圖

// 布爾表達式的抽象基類
public abstract class BooleanExpression
{
    public abstract bool Evaluate(Context context);
}

// 常量表達式
public sealed class ConstantExpression : BooleanExpression
{
    private readonly bool val;

    public ConstantExpression(bool val)
    {
        this.val = val;
    }

    public override bool Evaluate(Context context)
    {
        return this.val;
    }

    public override string ToString()
    {
        return val.ToString();
    }
}

// 與操作表達式
public sealed class AndExpression : BooleanExpression
{
    private readonly BooleanExpression left;
    private readonly BooleanExpression right;

    public AndExpression(BooleanExpression left, BooleanExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public override bool Evaluate(Context context)
    {
        return this.left.Evaluate(context) && this.right.Evaluate(context);
    }

    public override string ToString()
    {
        return string.Format("({0} & {1})", left.ToString(), right.ToString());
    }
}

// 或操作表達式
public sealed class OrExpression : BooleanExpression
{
    private readonly BooleanExpression left;
    private readonly BooleanExpression right;

    public OrExpression(BooleanExpression left, BooleanExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public override bool Evaluate(Context context)
    {
        return this.left.Evaluate(context) || this.right.Evaluate(context);
    }

    public override string ToString()
    {
        return string.Format("({0} | {1})", left.ToString(), right.ToString());
    }
}

// 非操作表達式
public sealed class NotExpression : BooleanExpression
{
    private readonly BooleanExpression expr;

    public NotExpression(BooleanExpression expr)
    {
        this.expr = expr;
    }

    public override bool Evaluate(Context context)
    {
        return !this.expr.Evaluate(context);
    }

    public override string ToString()
    {
        return string.Format("(!{0})", expr.ToString());
    }
}

// 變量表達式
public class VariableExpression : BooleanExpression
{
    private readonly string name;

    public VariableExpression(string name)
    {
        this.name = name;
    }

    public override bool Evaluate(Context context)
    {
        return context.Lookup(this);
    }

    public string Name { get { return this.name;} }

    public override string ToString()
    {
        return this.name;
    }
}

// 操作上下文
public class Context
{
    private readonly Dictionary<VariableExpression,bool> map = new Dictionary<VariableExpression,bool>();

    public void Assign(VariableExpression expr,bool value)
    {
        if(map.ContainsKey(expr))
        {
            map[expr] = value;
        }
        else
        {
            map.Add(expr, value);
        }
    }

    public bool Lookup(VariableExpression expr)
    {
        return map[expr];
    }

    public override string ToString()
    {
        StringBuilder sb = new StringBuilder();

        foreach(KeyValuePair<VariableExpression,bool> kvp in map)
        {
            sb.AppendFormat("{0}={1},", kvp.Key.Name, kvp.Value);
        }

        return sb.ToString();
    }
}

// 測試。注意添加命名空間：
//     using system;
//     using System.Text;
//     using System.Collections.Generic;
public class App
{
    public static void Main(string[] args)
    {
        Context context = new Context();
        VariableExpression X = new VariableExpression("X");
        VariableExpression Y = new VariableExpression("Y");

        // ( true & X ) | ( Y & ( !X ) )
        BooleanExpression expr = new OrExpression(
                    new AndExpression(new ConstantExpression(true), X),
                    new AndExpression(Y, new NotExpression(X))
                );

        context.Assign(X,false);
        context.Assign(Y,true);

        Console.WriteLine("Expression : {0}", expr.ToString());
        Console.WriteLine("   Context : {0}", context.ToString());
        Console.WriteLine("    Result : {0}", expr.Evaluate(context));

    }
}
// 控制臺輸出：
//  Expression : ((True & X) | (Y & (!X)))
//      Context : X=False,Y=True,
//      Result : True

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

解釋器（Interpreter）

解釋器（Interpreter）

意圖

結構

動機

適用性

注意事項

示例一

問題

實現（C#）

示例二

問題

實現（C#）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

解釋器（Interpreter）

意圖

結構

動機

適用性

注意事項

示例一

問題

實現（C#）

示例二

問題

實現（C#）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频